diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index a4620a412..1bb09902a 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,5 +1,6 @@
-# TP-??? Your PR title here
+# TP2000-??? Your PR title here
 <!---
+                                                  <--- 50 characters
  * Include the JIRA ticket number, eg TP-123, to automatically link.
  * Use 50 characters maximum.
  * Do not end with a full-stop.
@@ -22,12 +23,12 @@ What is this PR doing, e.g. implementations, algorithms, etc.?
 --->
 
 <!---
-Optionally let reviewers know they need to run migrations or update dependencies before
+Let reviewers know they need to run migrations or update dependencies before
 testing by adding the following section:
-## Checklist
-- Requires migrations?
-- Requires dependency updates?
 --->
+## Checklist
+- Requires migrations? Yes / No
+- Requires dependency updates? Yes / No
 
 <!---
 Links to relevant material
diff --git a/common/jinja2/common/homepage.jinja b/common/jinja2/common/homepage.jinja
index 2cb48849e..35e0fd117 100644
--- a/common/jinja2/common/homepage.jinja
+++ b/common/jinja2/common/homepage.jinja
@@ -144,6 +144,30 @@
       </article>
     {% endif %}
 
+      <article class="masonry-card">
+        <h3 class="govuk-heading-m">Tasks and Workflows - TEST ONLY</h3>
+        <p class="govuk-body">
+          <a href="{{ url('workflow:task-ui-list') }}"
+            class="govuk-link"
+          >Tasks</a>
+        </p>
+        <p class="govuk-body"></p>
+          <a href="{{ url('workflow:task-workflow-ui-list') }}"
+            class="govuk-link"
+          >Workflows</a>
+        </p>
+        <p class="govuk-body"></p>
+          <a href="{{ url('workflow:task-and-workflow-ui-list') }}"
+            class="govuk-link"
+          >Tasks and Workflows</a>
+        </p>
+        <p class="govuk-body"></p>
+          <a href="{{ url('workflow:task-workflow-template-ui-list') }}"
+            class="govuk-link"
+          >Workflow templates</a>
+        </p>
+      </article>
+
     <article class="masonry-card">
       <h3 class="govuk-heading-m">Resources</h3>
       <p class="govuk-body">
diff --git a/common/jinja2/layouts/detail.jinja b/common/jinja2/layouts/detail.jinja
index d0a607a09..af8ab5375 100644
--- a/common/jinja2/layouts/detail.jinja
+++ b/common/jinja2/layouts/detail.jinja
@@ -1,4 +1,6 @@
 {% extends "layouts/layout.jinja" %}
+
+{% from "components/tabs/macro.njk" import govukTabs %}
 {% from "components/breadcrumbs.jinja" import breadcrumbs %}
 
 {% block breadcrumb %}
diff --git a/common/models/mixins/__init__.py b/common/models/mixins/__init__.py
index d2e203dd5..0592410b9 100644
--- a/common/models/mixins/__init__.py
+++ b/common/models/mixins/__init__.py
@@ -1,6 +1,7 @@
 """Mixins for models."""
 
 from django.db import models
+from django.db.models import signals
 
 
 class TimestampedMixin(models.Model):
@@ -11,3 +12,37 @@ class TimestampedMixin(models.Model):
 
     class Meta:
         abstract = True
+
+
+class WithSignalManagerMixin:
+    """A mixin that overrides default Manager methods to send pre_save signals
+    for model instances."""
+
+    def bulk_create(self, objs, **kwargs) -> list:
+        for obj in objs:
+            signals.pre_save.send(sender=self.model, instance=obj)
+        return super().bulk_create(objs, **kwargs)
+
+
+class WithSignalQuerysetMixin:
+    """A mixin that overrides default QuerySet methods to send pre_save signals
+    for model instances."""
+
+    def update(self, **kwargs) -> int:
+        old_instances_map = {}
+        pk_list = []
+        for old_instance in self.iterator():
+            old_instances_map[old_instance.pk] = old_instance
+            pk_list.append(old_instance.pk)
+
+        rows_updated = super().update(**kwargs)
+
+        for new_instance in self.model.objects.filter(pk__in=pk_list):
+            old_instance = old_instances_map.get(new_instance.pk)
+            signals.pre_save.send(
+                sender=self.model,
+                instance=new_instance,
+                old_instance=old_instance,
+            )
+
+        return rows_updated
diff --git a/common/static/common/js/components/WorkbasketUserAssignment/UnassignUserForm.js b/common/static/common/js/components/WorkbasketUserAssignment/UnassignUserForm.js
index 7a9fae768..e2d5c2779 100644
--- a/common/static/common/js/components/WorkbasketUserAssignment/UnassignUserForm.js
+++ b/common/static/common/js/components/WorkbasketUserAssignment/UnassignUserForm.js
@@ -5,8 +5,8 @@ import accessibleAutocomplete from "accessible-autocomplete";
 import PropTypes from "prop-types";
 
 function UnassignUserForm({ users }) {
-  const elementId = "assignments-select";
-  const elementName = "assignments";
+  const elementId = "assignees-select";
+  const elementName = "assignees";
   const label = "Unassign user";
   const hint = "Select a user to unassign";
 
@@ -66,7 +66,7 @@ UnassignUserForm.propTypes = {
     PropTypes.shape({
       pk: PropTypes.number.isRequired,
       name: PropTypes.string.isRequired,
-    })
+    }),
   ),
 };
 
diff --git a/common/static/common/js/components/WorkbasketUserAssignment/tests/__snapshots__/UnassignUserForm.test.js.snap b/common/static/common/js/components/WorkbasketUserAssignment/tests/__snapshots__/UnassignUserForm.test.js.snap
index 9427e9111..c25959a29 100644
--- a/common/static/common/js/components/WorkbasketUserAssignment/tests/__snapshots__/UnassignUserForm.test.js.snap
+++ b/common/static/common/js/components/WorkbasketUserAssignment/tests/__snapshots__/UnassignUserForm.test.js.snap
@@ -16,20 +16,20 @@ exports[`UnassignUserForm renders form 1`] = `
   >
     <label
       className="govuk-label"
-      htmlFor="assignments-select"
+      htmlFor="assignees-select"
     >
       Unassign user
     </label>
     <div
       className="govuk-hint"
-      id="assignments-hint"
+      id="assignees-hint"
     >
       Select a user to unassign
     </div>
     <select
       data-testid="unassign-user-select"
-      id="assignments-select"
-      name="assignments"
+      id="assignees-select"
+      name="assignees"
       required={true}
     >
       <option
diff --git a/common/static/common/scss/application.scss b/common/static/common/scss/application.scss
index dbe60d797..c93689c49 100644
--- a/common/static/common/scss/application.scss
+++ b/common/static/common/scss/application.scss
@@ -28,6 +28,7 @@ $govuk-image-url-function: frontend-image-url;
 @import "regulations";
 @import "workbaskets";
 @import "reference_documents";
+@import "tasks";
 @import "versions";
 @import "fake-link";
 @import "violations";
diff --git a/common/tests/factories.py b/common/tests/factories.py
index dff7f3505..d1c487b1b 100644
--- a/common/tests/factories.py
+++ b/common/tests/factories.py
@@ -7,6 +7,7 @@
 
 import factory
 from django.contrib.auth import get_user_model
+from django.db.models import signals
 from factory.fuzzy import FuzzyChoice
 from factory.fuzzy import FuzzyText
 from faker import Faker
@@ -30,7 +31,8 @@
 from measures.validators import OrderNumberCaptureCode
 from publishing.models import ProcessingState
 from quotas.validators import QuotaEventType
-from tasks.models import UserAssignment
+from tasks.models import ProgressState
+from tasks.models import TaskAssignee
 from workbaskets.validators import WorkflowStatus
 
 User = get_user_model()
@@ -1533,40 +1535,62 @@ class Meta:
         model = "notifications.CrownDependenciesEnvelopeFailedNotification"
 
 
+class CategoryFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("bs")
+
+    class Meta:
+        model = "tasks.Category"
+
+
+class ProgressStateFactory(factory.django.DjangoModelFactory):
+    name = FuzzyChoice(ProgressState.State.values)
+
+    class Meta:
+        model = "tasks.ProgressState"
+        django_get_or_create = ("name",)
+
+
 class TaskFactory(factory.django.DjangoModelFactory):
     title = factory.Faker("sentence")
     description = factory.Faker("sentence")
+    category = factory.SubFactory(CategoryFactory)
+    progress_state = factory.SubFactory(ProgressStateFactory)
     workbasket = factory.SubFactory(WorkBasketFactory)
+    creator = factory.SubFactory(UserFactory)
 
     class Meta:
         model = "tasks.Task"
 
 
-class UserAssignmentFactory(factory.django.DjangoModelFactory):
+class SubTaskFactory(TaskFactory):
+    parent_task = factory.SubFactory(TaskFactory)
+
+
+@factory.django.mute_signals(signals.pre_save)
+class TaskAssigneeFactory(factory.django.DjangoModelFactory):
     user = factory.SubFactory(UserFactory)
-    assigned_by = factory.SubFactory(UserFactory)
-    assignment_type = FuzzyChoice(UserAssignment.AssignmentType.values)
+    assignment_type = FuzzyChoice(TaskAssignee.AssignmentType.values)
     task = factory.SubFactory(TaskFactory)
 
     class Meta:
-        model = "tasks.UserAssignment"
+        model = "tasks.TaskAssignee"
 
 
 class AssignedWorkBasketFactory(WorkBasketFactory):
     """Creates a workbasket which has an assigned worker and reviewer."""
 
     @factory.post_generation
-    def user_assignments(self, create, extracted, **kwargs):
+    def create_workbasket_assignments(self, create, extracted, **kwargs):
         if not create:
             return
 
         task = TaskFactory.create(workbasket=self)
-        UserAssignmentFactory.create(
-            assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+        TaskAssigneeFactory.create(
+            assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
             task=task,
         )
-        UserAssignmentFactory.create(
-            assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+        TaskAssigneeFactory.create(
+            assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
             task=task,
         )
 
diff --git a/common/tests/test_util.py b/common/tests/test_util.py
index 388d3b2d5..cfcf79aa2 100644
--- a/common/tests/test_util.py
+++ b/common/tests/test_util.py
@@ -586,6 +586,45 @@ def test_make_real_edit_create_delete():
     assert workbasket.tracked_models.count() == 0
 
 
+@mock.patch("django.db.transaction.get_connection")
+def test_tablelock_as_context_manager(mock_get_connection):
+    mock_cursor = mock.MagicMock()
+    mock_get_connection.return_value.cursor.return_value.__enter__.return_value = (
+        mock_cursor
+    )
+
+    instance = factories.TestModel1Factory.create()
+    model = instance._meta.model
+    lock = util.TableLock.EXCLUSIVE
+
+    with util.TableLock(model, lock=lock):
+        assert model.objects.select_for_update().get(pk=instance.pk)
+        mock_cursor.execute.assert_called_once_with(
+            f"LOCK TABLE {model._meta.db_table} IN {lock} MODE",
+        )
+
+
+@mock.patch("django.db.transaction.get_connection")
+def test_tablelock_as_decorator(mock_get_connection):
+    mock_cursor = mock.MagicMock()
+    mock_get_connection.return_value.cursor.return_value.__enter__.return_value = (
+        mock_cursor
+    )
+
+    instance = factories.TestModel1Factory.create()
+    model = instance._meta.model
+    lock = util.TableLock.EXCLUSIVE
+
+    @util.TableLock.acquire_lock(model, lock=lock)
+    def decorated_function():
+        return True
+
+    assert decorated_function()
+    mock_cursor.execute.assert_called_once_with(
+        f"LOCK TABLE {model._meta.db_table} IN {lock} MODE",
+    )
+
+
 @pytest.mark.parametrize(
     "date_range,compared_date_range,expected",
     (
diff --git a/common/tests/test_views.py b/common/tests/test_views.py
index 86316da3e..8fe1fb0a4 100644
--- a/common/tests/test_views.py
+++ b/common/tests/test_views.py
@@ -16,7 +16,7 @@
 from common.views import HealthCheckView
 from common.views import handler403
 from common.views import handler500
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets.validators import WorkflowStatus
 
 pytestmark = pytest.mark.django_db
@@ -281,9 +281,9 @@ def test_homepage_cards_contain_expected_links(superuser_client):
 def test_homepage_card_currently_working_on(status, valid_user, valid_user_client):
     test_reason = "test reason"
     workbasket = factories.WorkBasketFactory.create(status=status, reason=test_reason)
-    factories.UserAssignmentFactory.create(
+    factories.TaskAssigneeFactory.create(
         user=valid_user,
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task__workbasket=workbasket,
     )
     TrackedModelCheckFactory.create(
diff --git a/common/util.py b/common/util.py
index bbdecf610..aef0adf8f 100644
--- a/common/util.py
+++ b/common/util.py
@@ -457,8 +457,8 @@ def get_field_tuple(model: Model, field_name: str) -> Tuple[str, Any]:
 
 
 class TableLock:
-    """Provides a decorator for locking database tables for the duration of a
-    decorated function."""
+    """Provides a decorator and context manager for locking database tables for
+    the duration of a decorated function or context block."""
 
     ACCESS_SHARE = "ACCESS SHARE"
     ROW_SHARE = "ROW SHARE"
@@ -480,6 +480,29 @@ class TableLock:
         ACCESS_EXCLUSIVE,
     )
 
+    def __init__(self, *models, lock=None):
+        if lock is None:
+            lock = self.ACCESS_EXCLUSIVE
+
+        if lock not in self.LOCK_TYPES:
+            raise ValueError("%s is not a PostgreSQL supported lock mode.")
+
+        self.lock = lock
+        self.models = models
+
+    def __enter__(self):
+        with atomic():
+            with transaction.get_connection().cursor() as cursor:
+                for model in self.models:
+                    if isinstance(model, str):
+                        model = apps.get_model(model)
+                    cursor.execute(
+                        f"LOCK TABLE {model._meta.db_table} IN {self.lock} MODE",
+                    )
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
     @classmethod
     def acquire_lock(cls, *models, lock=None):
         """
@@ -494,24 +517,11 @@ def myview(request)
         PostgreSQL's LOCK Documentation:
         http://www.postgresql.org/docs/8.3/interactive/sql-lock.html
         """
-        if lock is None:
-            lock = cls.ACCESS_EXCLUSIVE
-
-        if lock not in cls.LOCK_TYPES:
-            raise ValueError("%s is not a PostgreSQL supported lock mode.")
 
         @wrapt.decorator
         def wrapper(wrapped, instance, args, kwargs):
-            with atomic():
-                with transaction.get_connection().cursor() as cursor:
-                    for model in models:
-                        if isinstance(model, str):
-                            model = apps.get_model(model)
-                        cursor.execute(
-                            f"LOCK TABLE {model._meta.db_table} IN {lock} MODE",
-                        )
-
-                    return wrapped(*args, **kwargs)
+            with cls(*models, lock=lock):
+                return wrapped(*args, **kwargs)
 
         return wrapper
 
@@ -783,3 +793,19 @@ def make_real_edit(
                 cls.objects.filter(pk=obj.pk).update(update_type=UpdateType.DELETE)
 
         return None
+
+
+def get_related_names(instance, related_model) -> list[str]:
+    """
+    Return a list of related names of reverse foreign-key relationships to
+    (subclasses of) the specified `related_model` for the given `instance`.
+
+    If a reverse foreign-key relationship exists but no related name has been
+    defined, a default name in the format `relatedmodel_set` will be returned.
+    If no such relationships exist, an empty list is returned.
+    """
+    related_names = []
+    for field in instance._meta.get_fields():
+        if field.one_to_many and issubclass(field.related_model, related_model):
+            related_names.append(field.get_accessor_name())
+    return related_names
diff --git a/common/views/pages.py b/common/views/pages.py
index 23259ddf8..bc2259bdd 100644
--- a/common/views/pages.py
+++ b/common/views/pages.py
@@ -46,7 +46,7 @@
 from publishing.models import PackagedWorkBasket
 from quotas.models import QuotaOrderNumber
 from regulations.models import Regulation
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets.models import WorkBasket
 from workbaskets.models import WorkflowStatus
 
@@ -61,7 +61,7 @@ def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
 
         assignments = (
-            UserAssignment.objects.filter(user=self.request.user)
+            TaskAssignee.objects.filter(user=self.request.user)
             .assigned()
             .select_related("task__workbasket")
             .filter(
@@ -75,7 +75,7 @@ def get_context_data(self, **kwargs):
             assignment_type = (
                 "Assigned"
                 if assignment.assignment_type
-                == UserAssignment.AssignmentType.WORKBASKET_WORKER
+                == TaskAssignee.AssignmentType.WORKBASKET_WORKER
                 else "Reviewing"
             )
             rule_violations_count = workbasket.tracked_model_check_errors.count()
diff --git a/conftest.py b/conftest.py
index 4126ed4d7..f1006a227 100644
--- a/conftest.py
+++ b/conftest.py
@@ -71,7 +71,7 @@
 from measures.models import MonetaryUnit
 from measures.parsers import DutySentenceParser
 from publishing.models import PackagedWorkBasket
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets.models import WorkBasket
 from workbaskets.models import get_partition_scheme
 from workbaskets.validators import WorkflowStatus
@@ -291,7 +291,7 @@ def api_client() -> APIClient:
 
 @pytest.fixture
 def policy_group(db) -> Group:
-    group = factories.UserGroupFactory.create(name="Policy")
+    group = factories.UserGroupFactory.create(name="Tariff Managers")
 
     for app_label, codename in [
         ("common", "add_trackedmodel"),
@@ -302,12 +302,28 @@ def policy_group(db) -> Group:
         ("publishing", "consume_from_packaging_queue"),
         ("publishing", "manage_packaging_queue"),
         ("publishing", "view_envelope"),
-        ("tasks", "add_userassignment"),
-        ("tasks", "change_userassignment"),
+        ("tasks", "add_task"),
+        ("tasks", "change_task"),
+        ("tasks", "delete_task"),
+        ("tasks", "view_task"),
+        ("tasks", "add_taskassignee"),
+        ("tasks", "change_taskassignee"),
         ("tasks", "add_comment"),
         ("tasks", "view_comment"),
         ("tasks", "change_comment"),
         ("tasks", "delete_comment"),
+        ("tasks", "add_taskworkflow"),
+        ("tasks", "change_taskworkflow"),
+        ("tasks", "delete_taskworkflow"),
+        ("tasks", "view_taskworkflow"),
+        ("tasks", "add_taskworkflowtemplate"),
+        ("tasks", "change_taskworkflowtemplate"),
+        ("tasks", "delete_taskworkflowtemplate"),
+        ("tasks", "view_taskworkflowtemplate"),
+        ("tasks", "add_tasktemplate"),
+        ("tasks", "change_tasktemplate"),
+        ("tasks", "delete_tasktemplate"),
+        ("tasks", "view_tasktemplate"),
     ]:
         group.permissions.add(
             Permission.objects.get(
@@ -541,12 +557,12 @@ def workbasket():
         workbasket = factories.WorkBasketFactory.create()
 
     task = factories.TaskFactory.create(workbasket=workbasket)
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
     )
     return workbasket
diff --git a/settings/common.py b/settings/common.py
index 1b785b30a..903ca982b 100644
--- a/settings/common.py
+++ b/settings/common.py
@@ -887,6 +887,9 @@
 
 TRANSACTION_SCHEMA = os.getenv("TRANSACTION_SCHEMA", "workbaskets.models.SEED_FIRST")
 
+# TAP's default maximum number of items to display in a paginated list view.
+DEFAULT_PAGINATOR_PER_PAGE_MAX = 20
+
 # Default max number of objects that will be accurately counted by LimitedPaginator.
 LIMITED_PAGINATOR_MAX_COUNT = 200
 # Default max number of objects that will be accurately counted by MeasurePaginator.
diff --git a/settings/test.py b/settings/test.py
index 03b732549..5973d5380 100644
--- a/settings/test.py
+++ b/settings/test.py
@@ -8,7 +8,12 @@
 CSRF_COOKIE_SECURE = False
 SESSION_COOKIE_SECURE = False
 
-INSTALLED_APPS.append("common.tests")
+INSTALLED_APPS.extend(
+    [
+        "common.tests",
+        "tasks.tests.test_queue",
+    ],
+)
 
 # Bucket settings are belt-and-braces to guard against running in a real bucket
 HMRC_BUCKET_STORAGE_NAME = os.environ.get("TEST_HMRC_BUCKET_STORAGE_NAME", "test-hmrc")
diff --git a/tasks/admin.py b/tasks/admin.py
new file mode 100644
index 000000000..2d8e9c53d
--- /dev/null
+++ b/tasks/admin.py
@@ -0,0 +1,225 @@
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.safestring import mark_safe
+
+from tasks.models import Category
+from tasks.models import ProgressState
+from tasks.models import Task
+from tasks.models import TaskAssignee
+from tasks.models import TaskItem
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskLog
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+
+
+class ReadOnlyAdminMixin:
+    def has_add_permission(self, request, obj=None):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+
+class TaskAdminMixin:
+    def link_to_task(self, task: Task):
+        task_url = reverse(
+            "admin:tasks_task_change",
+            args=(task.pk,),
+        )
+        return mark_safe(
+            f'<a href="{task_url}">{task.pk}</a>',
+        )
+
+    def link_to_workbasket(self, workbasket):
+        workbasket_url = reverse(
+            "admin:workbaskets_workbasket_change",
+            args=(workbasket.pk,),
+        )
+        return mark_safe(
+            f'<a href="{workbasket_url}">{workbasket.pk}</a>',
+        )
+
+
+class SubtaskFilter(admin.SimpleListFilter):
+    title = "Subtasks"
+    parameter_name = "is_subtask"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("TRUE", "Subtasks"),
+            ("FALSE", "Tasks"),
+        )
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if value == "TRUE":
+            return queryset.subtasks()
+        elif value == "FALSE":
+            return queryset.parents()
+
+
+class TaskAdmin(ReadOnlyAdminMixin, TaskAdminMixin, admin.ModelAdmin):
+    list_display = [
+        "id",
+        "title",
+        "is_subtask",
+        "description",
+        "category",
+        "progress_state",
+        "parent_task_id",
+        "workbasket_id",
+        "creator",
+    ]
+    search_fields = ["id", "title", "description"]
+    list_filter = (
+        SubtaskFilter,
+        "category",
+        "progress_state",
+    )
+
+    def parent_task_id(self, obj):
+        if not obj.parent_task:
+            return None
+        return self.link_to_task(obj.parent_task)
+
+    def workbasket_id(self, obj):
+        if not obj.workbasket:
+            return "-"
+        return self.link_to_workbasket(obj.workbasket)
+
+
+class CategoryAdmin(admin.ModelAdmin):
+    search_fields = ["name"]
+
+
+class ProgressStateAdmin(admin.ModelAdmin):
+    search_fields = ["name"]
+
+
+class TaskAssigneeAdmin(ReadOnlyAdminMixin, TaskAdminMixin, admin.ModelAdmin):
+    list_display = ["id", "assignee", "assignment_type", "task_id", "unassigned_at"]
+    search_fields = ["user__username", "assignment_type", "task__id"]
+
+    @admin.display(description="User")
+    def assignee(self, obj):
+        if not obj.user:
+            return "Missing user!"
+        return obj.user.get_displayname()
+
+    def task_id(self, obj):
+        if not obj.task:
+            return "Missing task!"
+        return self.link_to_task(obj.task)
+
+
+class TaskLogAdmin(ReadOnlyAdminMixin, admin.ModelAdmin):
+    list_display = ["task", "action", "created_at"]
+    list_filter = ["action"]
+    readonly_fields = [
+        "id",
+        "action",
+        "description",
+        "task",
+        "instigator",
+        "created_at",
+    ]
+
+
+class TaskItemTemplateInline(admin.TabularInline):
+    model = TaskItemTemplate
+    readonly_fields = ("task_template_description", "position")
+
+    @admin.display(description="Description")
+    def task_template_description(self, obj):
+        return obj.task_template.description
+
+
+class TaskWorkflowTemplateAdmin(ReadOnlyAdminMixin, admin.ModelAdmin):
+    list_display = (
+        "id",
+        "title",
+        "description",
+        "task_templates_count",
+        "creator",
+    )
+    search_fields = ("title", "description")
+    inlines = [TaskItemTemplateInline]
+
+    @admin.display(description="Task templates")
+    def task_templates_count(self, obj):
+        return obj.get_task_templates().count()
+
+
+class TaskTemplateAdmin(ReadOnlyAdminMixin, admin.ModelAdmin):
+    list_display = (
+        "id",
+        "title",
+        "description",
+        "taskworkflowtemplate_id",
+        "created_at",
+    )
+    search_fields = ["id", "title", "description"]
+    list_filter = ["category"]
+
+    @admin.display(description="Task Workflow Template")
+    def taskworkflowtemplate_id(self, obj):
+        if not obj.taskitemtemplate:
+            return "-"
+        return self.link_to_task_workflow_template(obj.taskitemtemplate)
+
+    def link_to_task_workflow_template(self, task_item_template):
+        workflow_template_pk = task_item_template.workflow_template.pk
+        task_workflow_template_url = reverse(
+            "admin:tasks_taskworkflowtemplate_change",
+            args=(workflow_template_pk,),
+        )
+        return mark_safe(
+            f'<a href="{task_workflow_template_url}">{workflow_template_pk}</a>',
+        )
+
+
+class TaskItemInline(admin.TabularInline):
+    model = TaskItem
+    readonly_fields = ("task_description", "position")
+
+    @admin.display(description="Description")
+    def task_description(self, obj):
+        return obj.task.description
+
+
+class TaskWorflowAdmin(ReadOnlyAdminMixin, admin.ModelAdmin):
+    search_fields = ["summary_task__title"]
+    list_display = [
+        "id",
+        "title",
+        "description",
+        "task_count",
+        "creator_template",
+    ]
+    inlines = [TaskItemInline]
+
+    @admin.display(description="Tasks")
+    def task_count(self, obj):
+        return obj.get_tasks().count()
+
+
+admin.site.register(Task, TaskAdmin)
+
+admin.site.register(Category, CategoryAdmin)
+
+admin.site.register(ProgressState, ProgressStateAdmin)
+
+admin.site.register(TaskAssignee, TaskAssigneeAdmin)
+
+admin.site.register(TaskLog, TaskLogAdmin)
+
+admin.site.register(TaskWorkflowTemplate, TaskWorkflowTemplateAdmin)
+
+admin.site.register(TaskTemplate, TaskTemplateAdmin)
+
+admin.site.register(TaskWorkflow, TaskWorflowAdmin)
diff --git a/tasks/filters.py b/tasks/filters.py
new file mode 100644
index 000000000..f91a34540
--- /dev/null
+++ b/tasks/filters.py
@@ -0,0 +1,121 @@
+from django.db.models import TextChoices
+from django.forms import CheckboxSelectMultiple
+from django.urls import reverse_lazy
+from django_filters import ChoiceFilter
+from django_filters import ModelMultipleChoiceFilter
+
+from common.filters import TamatoFilter
+from common.widgets import RadioSelect
+from tasks.models import ProgressState
+from tasks.models import Task
+from tasks.models import TaskWorkflowTemplate
+
+
+class TaskFilter(TamatoFilter):
+
+    search_fields = (
+        "id",
+        "title",
+        "description",
+    )
+    clear_url = reverse_lazy("workflow:task-ui-list")
+
+    progress_state = ModelMultipleChoiceFilter(
+        label="Status",
+        help_text="Select all that apply",
+        queryset=ProgressState.objects.all(),
+        widget=CheckboxSelectMultiple,
+    )
+
+    class Meta:
+        model = Task
+        fields = ["search", "category", "progress_state"]
+
+    @property
+    def qs(self):
+        return super().qs.non_workflow()
+
+
+class TaskWorkflowFilter(TamatoFilter):
+    search_fields = (
+        "id",
+        "title",
+        "description",
+    )
+    clear_url = reverse_lazy("workflow:task-workflow-ui-list")
+
+    progress_state = ModelMultipleChoiceFilter(
+        label="Status",
+        help_text="Select all that apply",
+        queryset=ProgressState.objects.all(),
+        widget=CheckboxSelectMultiple,
+    )
+
+    class Meta:
+        model = Task
+        fields = ["search", "category", "progress_state"]
+
+    @property
+    def qs(self):
+        qs = super().qs
+        return qs.workflow_summary()
+
+
+class TasksAndWorkflowsChoices(TextChoices):
+    TASKS_ONLY = "TASKS_ONLY", "Tasks only"
+    WORKFLOWS_ONLY = "WORKFLOWS_ONLY", "Workflows only"
+
+
+class TaskAndWorkflowFilter(TamatoFilter):
+    search_fields = (
+        "id",
+        "title",
+        "description",
+    )
+    clear_url = reverse_lazy("workflow:task-and-workflow-ui-list")
+
+    tasks_and_workflows = ChoiceFilter(
+        choices=TasksAndWorkflowsChoices.choices,
+        method="filter_by_tasks_and_workflows",
+        widget=RadioSelect,
+        label="Tasks and workflows",
+        empty_label="Tasks and workflows",
+        help_text="Select the choice that applies",
+    )
+
+    progress_state = ModelMultipleChoiceFilter(
+        label="Status",
+        help_text="Select all that apply",
+        queryset=ProgressState.objects.all(),
+        widget=CheckboxSelectMultiple,
+    )
+
+    class Meta:
+        model = Task
+        fields = ["search", "tasks_and_workflows", "category", "progress_state"]
+
+    def filter_by_tasks_and_workflows(self, queryset, name, value):
+        if TasksAndWorkflowsChoices.TASKS_ONLY == value:
+            queryset = queryset.non_workflow()
+        elif TasksAndWorkflowsChoices.WORKFLOWS_ONLY == value:
+            queryset = queryset.workflow_summary()
+
+        return queryset
+
+    @property
+    def qs(self):
+        return super().qs.top_level()
+
+
+class WorkflowTemplateFilter(TamatoFilter):
+    search_fields = (
+        "id",
+        "title",
+        "description",
+        "creator__username",
+    )
+    clear_url = reverse_lazy("workflow:task-workflow-template-ui-list")
+
+    class Meta:
+        model = TaskWorkflowTemplate
+        fields = ["search"]
diff --git a/tasks/forms.py b/tasks/forms.py
new file mode 100644
index 000000000..5fab477ca
--- /dev/null
+++ b/tasks/forms.py
@@ -0,0 +1,305 @@
+from crispy_forms_gds.helper import FormHelper
+from crispy_forms_gds.layout import Fieldset
+from crispy_forms_gds.layout import Layout
+from crispy_forms_gds.layout import Size
+from crispy_forms_gds.layout import Submit
+from django.db import transaction
+from django.db.models import TextChoices
+from django.forms import CharField
+from django.forms import Form
+from django.forms import ModelChoiceField
+from django.forms import ModelForm
+from django.forms import Textarea
+
+from common.forms import BindNestedFormMixin
+from common.forms import RadioNested
+from common.forms import delete_form_for
+from common.validators import SymbolValidator
+from tasks.models import Task
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+from workbaskets.models import WorkBasket
+
+
+class TaskBaseForm(ModelForm):
+    class Meta:
+        model = Task
+        exclude = ["parent_task", "creator"]
+
+        error_messages = {
+            "title": {
+                "required": "Enter a title",
+            },
+            "description": {
+                "required": "Enter a description",
+            },
+            "progress_state": {
+                "required": "Select a status",
+            },
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.init_fields()
+        self.init_layout()
+
+    def init_fields(self):
+        self.fields["progress_state"].label = "Status"
+        self.fields["workbasket"].queryset = WorkBasket.objects.editable()
+
+    def init_layout(self):
+        self.helper = FormHelper(self)
+        self.helper.label_size = Size.SMALL
+        self.helper.legend_size = Size.SMALL
+        self.helper.layout = Layout(
+            "title",
+            "description",
+            "category",
+            "progress_state",
+            "workbasket",
+            Submit(
+                "submit",
+                "Save",
+                data_module="govuk-button",
+                data_prevent_double_click="true",
+            ),
+        )
+
+
+class TaskCreateForm(TaskBaseForm):
+    def save(self, user, commit=True):
+        instance = super().save(commit=False)
+        instance.creator = user
+        if commit:
+            instance.save()
+        return instance
+
+
+class TaskUpdateForm(TaskBaseForm):
+    pass
+
+
+class SubTaskCreateForm(TaskBaseForm):
+    def save(self, parent_task, user, commit=True):
+        instance = super().save(commit=False)
+        instance.creator = user
+        instance.parent_task = parent_task
+        if commit:
+            instance.save()
+        return instance
+
+
+TaskDeleteForm = delete_form_for(Task)
+
+
+class TaskWorkflowTemplateForm(Form):
+    workflow_template = ModelChoiceField(
+        label="",
+        queryset=TaskWorkflowTemplate.objects.all(),
+        help_text="Select a workflow template.",
+        error_messages={
+            "required": "Select a workflow template",
+        },
+    )
+
+
+class TaskWorkflowCreateForm(BindNestedFormMixin, Form):
+    class CreateType(TextChoices):
+        WITH_TEMPLATE = "WITH_TEMPLATE", "Yes"
+        WITHOUT_TEMPLATE = "WITHOUT_TEMPLATE", "No"
+
+    title = CharField(
+        max_length=255,
+        validators=[SymbolValidator],
+        error_messages={
+            "required": "Enter a title for the workflow",
+        },
+    )
+
+    description = CharField(
+        validators=[SymbolValidator],
+        widget=Textarea(),
+        error_messages={
+            "required": "Enter a description for the workflow",
+        },
+    )
+
+    create_type = RadioNested(
+        label="Do you want to use a workflow template?",
+        choices=CreateType.choices,
+        nested_forms={
+            CreateType.WITH_TEMPLATE.value: [TaskWorkflowTemplateForm],
+            CreateType.WITHOUT_TEMPLATE.value: [],
+        },
+        error_messages={
+            "required": "Select if you want to use a workflow template",
+        },
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.bind_nested_forms(*args, **kwargs)
+
+        self.helper = FormHelper(self)
+        self.helper.label_size = Size.SMALL
+        self.helper.legend_size = Size.SMALL
+        self.helper.layout = Layout(
+            Fieldset(
+                "title",
+                "description",
+            ),
+            "create_type",
+            Submit(
+                "submit",
+                "Create",
+                data_module="govuk-button",
+                data_prevent_double_click="true",
+            ),
+        )
+
+
+TaskWorkflowDeleteForm = delete_form_for(TaskWorkflow)
+
+
+class TaskWorkflowUpdateForm(ModelForm):
+    title = CharField(
+        max_length=255,
+        validators=[SymbolValidator],
+        error_messages={
+            "required": "Enter a title",
+        },
+    )
+    description = CharField(
+        validators=[SymbolValidator],
+        widget=Textarea(),
+        error_messages={
+            "required": "Enter a description",
+        },
+    )
+
+    class Meta:
+        model = TaskWorkflow
+        fields = []
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.init_fields()
+        self.init_layout()
+
+    def init_fields(self):
+        self.fields["title"].initial = self.instance.summary_task.title
+        self.fields["description"].initial = self.instance.summary_task.description
+
+    def init_layout(self):
+        self.helper = FormHelper(self)
+        self.helper.label_size = Size.SMALL
+        self.helper.legend_size = Size.SMALL
+        self.helper.layout = Layout(
+            "title",
+            "description",
+            Submit(
+                "submit",
+                "Update",
+                data_module="govuk-button",
+                data_prevent_double_click="true",
+            ),
+        )
+
+    @transaction.atomic
+    def save(self, commit=True):
+        summary_task = self.instance.summary_task
+        summary_task.title = self.cleaned_data["title"]
+        summary_task.description = self.cleaned_data["description"]
+        if commit:
+            summary_task.save()
+        return self.instance
+
+
+class TaskWorkflowTemplateBaseForm(ModelForm):
+    class Meta:
+        model = TaskWorkflowTemplate
+        fields = ("title", "description")
+
+        error_messages = {
+            "title": {
+                "required": "Enter a title",
+            },
+            "description": {
+                "required": "Enter a description",
+            },
+        }
+
+    def __init__(self, *args, submit_title, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.helper = FormHelper(self)
+        self.helper.label_size = Size.SMALL
+        self.helper.legend_size = Size.SMALL
+        self.helper.layout = Layout(
+            "title",
+            "description",
+            Submit(
+                "submit",
+                submit_title,
+                data_module="govuk-button",
+                data_prevent_double_click="true",
+            ),
+        )
+
+
+class TaskWorkflowTemplateCreateForm(TaskWorkflowTemplateBaseForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, submit_title="Create", **kwargs)
+
+    def save(self, user, commit=True):
+        instance = super().save(commit=False)
+        instance.creator = user
+        if commit:
+            instance.save()
+        return instance
+
+
+class TaskWorkflowTemplateUpdateForm(TaskWorkflowTemplateBaseForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, submit_title="Update", **kwargs)
+
+
+TaskWorkflowTemplateDeleteForm = delete_form_for(TaskWorkflowTemplate)
+
+
+class TaskTemplateFormBase(ModelForm):
+    class Meta:
+        model = TaskTemplate
+        fields = ("title", "description")
+
+    def __init__(self, *args, submit_title, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.helper = FormHelper(self)
+        self.helper.label_size = Size.SMALL
+        self.helper.legend_size = Size.SMALL
+        self.helper.layout = Layout(
+            "title",
+            "description",
+            Submit(
+                "submit",
+                submit_title,
+                data_module="govuk-button",
+                data_prevent_double_click="true",
+            ),
+        )
+
+
+class TaskTemplateCreateForm(TaskTemplateFormBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, submit_title="Create", **kwargs)
+
+
+class TaskTemplateUpdateForm(TaskTemplateFormBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, submit_title="Update", **kwargs)
+
+
+TaskTemplateDeleteForm = delete_form_for(TaskTemplate)
diff --git a/tasks/jinja2/tasks/confirm_create.jinja b/tasks/jinja2/tasks/confirm_create.jinja
new file mode 100644
index 000000000..badec2989
--- /dev/null
+++ b/tasks/jinja2/tasks/confirm_create.jinja
@@ -0,0 +1,42 @@
+{% extends "common/confirm_create.jinja" %}
+
+{% from "components/breadcrumbs/macro.njk" import govukBreadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = verbose_name|capitalize ~ " created" %}
+
+{% block breadcrumb %}
+  {{ govukBreadcrumbs({
+    "items": [
+      {"text": "Home", "href": url("home")},
+      {"text": "Create a new " ~ verbose_name, "href": url("workflow:task-ui-create") },
+      {"text": verbose_name|capitalize ~ " created"}
+    ]
+  }) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": verbose_name|capitalize ~ ": " ~ object.title,
+    "text": "You have created a new " ~ verbose_name,
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View " ~ verbose_name,
+    "href": url('workflow:task-ui-detail', kwargs={"pk": object.pk}),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li><a href="{{ url("workflow:task-ui-list") }}">Find and view tasks</a></li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/confirm_delete.jinja b/tasks/jinja2/tasks/confirm_delete.jinja
new file mode 100644
index 000000000..6beb6198f
--- /dev/null
+++ b/tasks/jinja2/tasks/confirm_delete.jinja
@@ -0,0 +1,41 @@
+{% extends "layouts/confirm.jinja" %}
+
+{% from "components/breadcrumbs/macro.njk" import govukBreadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Task deleted" %}
+
+{% block breadcrumb %}
+  {{ govukBreadcrumbs({
+    "items": [
+      {"text": "Find and view tasks", "href": url("workflow:task-ui-list")},
+      {"text": page_title}
+    ]
+  }) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": "Task ID: " ~ deleted_pk,
+    "text": verbose_name|capitalize ~ " has been deleted",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "Find and view tasks",
+    "href": url("workflow:task-ui-list"),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li><a href="{{ url("workflow:task-ui-create") }}">Create a task</a></li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/confirm_update.jinja b/tasks/jinja2/tasks/confirm_update.jinja
new file mode 100644
index 000000000..b4b075802
--- /dev/null
+++ b/tasks/jinja2/tasks/confirm_update.jinja
@@ -0,0 +1,41 @@
+{% extends "common/confirm_update.jinja" %}
+
+{% from "components/breadcrumbs/macro.njk" import govukBreadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = page_title %}
+
+{% block breadcrumb %}
+  {{ govukBreadcrumbs({
+    "items": [
+      {"text": object_type ~ ": " ~ object.title, "href": url("workflow:task-ui-detail", kwargs={"pk": object.pk})},
+      {"text": page_title}
+    ]
+  }) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": object_type ~ ": " ~ object.title,
+    "text": object_type ~ " has been updated",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View " ~ object_type,
+    "href": url('workflow:task-ui-detail', kwargs={"pk": object.pk}),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li><a href="{{ url("workflow:task-ui-list") }}">Find and view tasks</a></li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/delete.jinja b/tasks/jinja2/tasks/delete.jinja
new file mode 100644
index 000000000..574aa28a5
--- /dev/null
+++ b/tasks/jinja2/tasks/delete.jinja
@@ -0,0 +1,41 @@
+{% extends "common/delete.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/warning-text/macro.njk" import govukWarningText %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Delete my Task:" ~ object.title %}
+
+{% block content %}
+<div class="govuk-!-width-two-thirds">
+  <h1 class="govuk-heading-xl">Delete {{ verbose_name }}: {{ object.title }}</h1>
+  {% if page_label %}
+    <div class="govuk-hint"> {{ page_label }}</div>
+  {% endif %}
+  {% block form %}
+    {{ govukWarningText({
+    "text": "Are you sure you want to delete this " ~ verbose_name ~ "?"
+  }) }}
+
+  {% if not object.parent_task %}
+    {% set url_name = "workflow:task-ui-delete" %}
+  {% else %}
+    {% set url_name = "workflow:subtask-ui-delete" %}
+  {% endif %}
+  
+  {% call django_form(action=url(url_name, kwargs={"pk": object.pk})) %}
+    {{ crispy(form) }}
+  {% endcall %}
+
+  {% endblock %}
+</div>
+{% endblock %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(request, [
+      {"text": "Find and view tasks", "href": url("workflow:task-ui-list")},
+      {"text": verbose_name ~ " :" ~ object.title, "href": url("workflow:task-ui-detail", kwargs={"pk": object.pk})},
+      {"text": page_title}
+    ])
+  }}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/detail.jinja b/tasks/jinja2/tasks/detail.jinja
new file mode 100644
index 000000000..d19cd9dca
--- /dev/null
+++ b/tasks/jinja2/tasks/detail.jinja
@@ -0,0 +1,134 @@
+{% extends "layouts/layout.jinja" %}
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Task: " ~ object.title %}
+
+{%if object.parent_task%}
+  {% set edit_url = url("workflow:subtask-ui-update", kwargs={"pk": object.pk}) %}
+{% else %}
+  {% set edit_url = url("workflow:task-ui-update", kwargs={"pk": object.pk}) %}
+{% endif%}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(request, [
+      {"text": "Find and view tasks", "href": url("workflow:task-ui-list")},
+      {"text": page_title}
+    ]
+  ) }}
+{% endblock %}
+
+{% block content %}
+  <div class="govuk-grid-row">
+    <div class="govuk-grid-column-two-thirds">
+      <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+    </div>
+  </div>
+
+  <h2 class="govuk-heading-m">Details</h2>
+  
+  <dl class="govuk-summary-list">
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      ID
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.pk }}
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Title
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.title }}
+    </dd>
+    <dd class="govuk-summary-list__actions">
+      <a class="govuk-link" href="{{ edit_url }}">Change<span class="govuk-visually-hidden"> title</span></a>
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Description
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.description }}
+    </dd>
+    <dd class="govuk-summary-list__actions">
+      <a class="govuk-link" href="{{ edit_url }}">Change<span class="govuk-visually-hidden"> description</span></a>
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Category
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.category }}
+    </dd>
+    <dd class="govuk-summary-list__actions">
+      <a class="govuk-link" href="{{ edit_url }}">Change<span class="govuk-visually-hidden"> category</span></a>
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Status
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.progress_state }}
+    </dd>
+    <dd class="govuk-summary-list__actions">
+      <a class="govuk-link" href="{{ edit_url }}">Change<span class="govuk-visually-hidden"> status</span></a>
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Created
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ "{:%d %b %Y %H:%M}".format(object.created_at) }}
+    </dd>
+  </div>
+
+  <div class="govuk-summary-list__row">
+    <dt class="govuk-summary-list__key">
+      Created by
+    </dt>
+    <dd class="govuk-summary-list__value">
+      {{ object.creator.get_displayname() if object.creator else "-" }}
+    </dd>
+  </div>
+</dl>
+
+<div class="govuk-button-group">
+{% if not object.parent_task %}
+  {{ govukButton({
+    "text": "Delete task",
+    "href": url("workflow:task-ui-delete", kwargs={"pk": object.pk}),
+    "classes": "govuk-button--warning"
+  }) }}
+  {% else %}
+    {{ govukButton({
+    "text": "Delete subtask",
+    "href": url("workflow:subtask-ui-delete", kwargs={"pk": object.pk}),
+    "classes": "govuk-button--warning"
+  }) }}
+  {% endif %}
+  {{ govukButton({
+    "text": "Find and view tasks",
+    "href": url("workflow:task-ui-list"),
+    "classes": "govuk-button--secondary"
+  }) }}
+  {% if not object.parent_task %}
+    {{ govukButton({
+      "text": "Create subtask",
+      "href": url("workflow:subtask-ui-create", kwargs={"parent_task_pk": object.pk}),
+      "classes": "govuk-button--secondary"
+    }) }}
+  {% endif %}
+</div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/edit.jinja b/tasks/jinja2/tasks/edit.jinja
new file mode 100644
index 000000000..d2d0bde91
--- /dev/null
+++ b/tasks/jinja2/tasks/edit.jinja
@@ -0,0 +1,18 @@
+{% extends "layouts/form.jinja" %}
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(request, [
+      {"text": "Find and view tasks", "href": url("workflow:task-ui-list")},
+      {"text": "Task: " ~ object.title, "href": url("workflow:task-ui-detail", kwargs={"pk": object.pk})},
+      {"text": page_title}
+    ])
+  }}
+{% endblock %}
+
+{% block form %}
+  {% call django_form() %}
+    {{ crispy(form) }}
+  {% endcall %}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/includes/task_queue.jinja b/tasks/jinja2/tasks/includes/task_queue.jinja
new file mode 100644
index 000000000..1f55b66d3
--- /dev/null
+++ b/tasks/jinja2/tasks/includes/task_queue.jinja
@@ -0,0 +1,78 @@
+{% from "components/table/macro.njk" import govukTable %}
+{% from "tasks/macros/item_actions.jinja" import render_item_button %}
+
+{%- set table_rows = [] -%}
+
+{%- for obj in object_list %}
+  {%- set up_down_cell_content %}
+    {% if object_list|length == 1 %}
+      {# No buttons needed for a single item #}
+    {% elif loop.index == 1 %}
+      {{ render_item_button(obj, "demote", use_icon=True) }}
+    {% elif loop.index == 2 %}
+      {{ render_item_button(obj, "promote", use_icon=True) }}
+      <br>
+      {% if 2 < object_list | length %}
+        {{ render_item_button(obj, "demote", use_icon=True) }}
+      {% endif %}
+    {% elif loop.index == object_list | length %}
+      {{ render_item_button(obj, "promote", use_icon=True) }}
+    {% else %}
+      {{ render_item_button(obj, "promote", use_icon=True) }}
+      <br>
+      {{ render_item_button(obj, "demote", use_icon=True) }}
+    {% endif %}
+  {% endset -%}
+
+  {%- set title_cell_content %}
+    <a href="{{ obj.get_url(action='detail') }}" class="govuk-link">{{ obj.title }}</a>
+  {% endset -%}
+
+  {%- set description_cell_content %}
+    <span>{{ obj.description|truncate(50) }}</span>
+  {% endset -%}
+
+  {%- set order_cell_content %}
+    {% if object_list|length == 1 %}
+      {# No buttons needed for a single item #}
+    {% elif loop.index == 1 %}
+      {{ render_item_button(obj, "demote_to_last") }}
+    {% elif loop.index == object_list | length %}
+      {{ render_item_button(obj, "promote_to_first") }}
+    {% else %}
+      {{ render_item_button(obj, "promote_to_first") }}
+      <br>
+      {{ render_item_button(obj, "demote_to_last") }}
+    {% endif %}
+  {% endset -%}
+
+  {%- set remove_cell_content %}
+    <a href="{{ obj.get_url("delete") }}" class="govuk-link">Remove</a>
+  {% endset -%}
+
+  {{ table_rows.append([
+    {"html": up_down_cell_content},
+    {"text": loop.index},
+    {"html": title_cell_content},
+    {"html": description_cell_content},
+    {"html": order_cell_content},
+    {"html": remove_cell_content},
+  ]) or "" }}
+
+{% endfor -%}
+
+<form method="post">
+    <input type="hidden" name="csrfmiddlewaretoken" value="{{ csrf_token }}">
+
+  {{ govukTable({
+    "head": [
+      {"text": ""},
+      {"text": "Position"},
+      {"text": "Title"},
+      {"text": "Description"},
+      {"text": "Order"},
+      {"text": "Remove"},
+    ],
+    "rows": table_rows,
+  }) }}
+</form>
diff --git a/tasks/jinja2/tasks/list.jinja b/tasks/jinja2/tasks/list.jinja
new file mode 100644
index 000000000..f516e5ca1
--- /dev/null
+++ b/tasks/jinja2/tasks/list.jinja
@@ -0,0 +1,82 @@
+{% extends "layouts/layout.jinja" %}
+
+{% from "components/table/macro.njk" import govukTable %}
+{% from "components/create_sortable_anchor.jinja" import create_sortable_anchor %}
+
+{% set page_title = "Find and view tasks" %}
+
+{% set base_url = url("workflow:task-ui-list") %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+  <p class="govuk-body">
+    Search for tasks.
+    Alternatively, <a class="govuk-link" href="{{ url("workflow:task-ui-create") }}">create a new task</a>.
+  </p>
+
+  <div class="filter-layout">
+    <div class="filter-layout__filters">
+      <h2 class="govuk-heading-m govuk-!-margin-top-3">Search and filter</h2>
+      <form method="get" action="{{ url("workflow:task-ui-list") }}">
+          {{ crispy(filter.form) }}
+      </form>
+    </div>
+
+  <div class="filter-layout__content">
+    {% if paginator.count > 0 %}
+      {% include "includes/common/pagination-list-summary.jinja" %}
+    {% endif %}
+    {% if object_list %}
+      {% set table_rows = [] %}
+      {% for object in object_list %}
+        {%- set task_linked_id -%}
+          <a
+            class="govuk-link"
+            href="{{ url("workflow:task-ui-detail", kwargs={"pk": object.pk}) }}"
+          >{{ object.pk }}</a>
+        {%- endset -%}
+
+        {%- set workbasket_linked_id -%}
+          {% if object.workbasket %}
+            <a
+              class="govuk-link"
+              href="{{ url("workbaskets:workbasket-ui-detail", kwargs={"pk": object.workbasket.pk}) }}"
+            >{{ object.workbasket.pk }}</a>
+          {% else %}
+            -
+          {%- endif -%}
+        {%- endset -%}
+
+        {{ table_rows.append([
+          {"text": task_linked_id},
+          {"text": object.title},
+          {"text": object.category},
+          {"text": object.progress_state},
+          {"text": workbasket_linked_id},
+          {"text": "{:%d %b %Y}".format(object.created_at)},
+        ]) or "" }}
+      {% endfor %}
+
+      {{ govukTable({
+        "head": [
+          {"text": "ID"},
+          {"text": "Title"},
+          {"text": "Category"},
+          {"text": "Status"},
+          {"text": "Workbasket"},
+          {"text": create_sortable_anchor(request, "created_at", "Created", base_url)},
+        ],
+          "rows": table_rows
+        }) }}
+    {% else %}
+      <p class="govuk-body">There are no results for your search, please:</p>
+      <ul class="govuk-list govuk-list--bullet">
+        <li>check the spelling of your keywords</li>
+        <li>use more general keywords</li>
+        <li>select or deselect different filters</li>
+      </ul>
+    {% endif %}
+    {% include "includes/common/pagination.jinja" %}
+  </div>
+</div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/macros/item_actions.jinja b/tasks/jinja2/tasks/macros/item_actions.jinja
new file mode 100644
index 000000000..89e209b0b
--- /dev/null
+++ b/tasks/jinja2/tasks/macros/item_actions.jinja
@@ -0,0 +1,29 @@
+{% macro render_item_button(obj, action, use_icon=False) %}
+  {% set action_text = {
+    "promote": "Move up",
+    "demote": "Move down",
+    "promote_to_first": "Move to first",
+    "demote_to_last": "Move to last",
+  }[action] %}
+
+  {% set icon_src = {
+    "promote": "/common/images/chevron-up.svg",
+    "demote": "/common/images/chevron-down.svg",
+  }[action] %}
+
+  <button name="{{ action }}"
+    value="{{ obj.pk }}"
+    class="govuk-link fake-link govuk-!-padding-right-2"
+    data-module="govuk-button"
+    data-prevent-double-click="true"
+  >
+    {% if use_icon and icon_src %}
+      <img class="icon"
+        src="{{ static(icon_src) }}"
+        alt="{{ action_text}} icon"
+      >
+    {% else %}
+      {{ action_text }}
+    {% endif%}
+  </button>
+{% endmacro %}
diff --git a/tasks/jinja2/tasks/workflows/confirm_create.jinja b/tasks/jinja2/tasks/workflows/confirm_create.jinja
new file mode 100644
index 000000000..a84c0b9d6
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/confirm_create.jinja
@@ -0,0 +1,61 @@
+{% extends "common/confirm_create.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set object_name = object._meta.verbose_name %}
+{% set page_title = object_name ~ " created" %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": object.get_url("list")},
+      {
+        "text": "Create a " ~ object_name,
+        "href": object.get_url("create"),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": object_name|capitalize ~ ": " ~ object,
+    "text": "You have created a new " ~ object_name,
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View " ~ object_name,
+    "href": object.get_url("detail"),
+    "classes": "govuk-button"
+  }) }}
+
+  {% if object_name == "workflow" %}
+    {{ govukButton({
+      "text": "Create a task",
+      "href": "#TODO",
+      "classes": "govuk-button--secondary"
+    }) }}
+  {% elif object_name == "workflow template" %}
+    {{ govukButton({
+      "text": "Create a task template",
+      "href": url("workflow:task-template-ui-create", kwargs={"workflow_template_pk": object.pk}),
+      "classes": "govuk-button--secondary"
+    }) }}
+  {% endif %}
+{% endblock %}
+
+{% block actions %}
+  <li>
+    <a href={{ object.get_url("list") }} class="govuk-link">Find and view {{object_name}}s</a>
+  </li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/confirm_delete.jinja b/tasks/jinja2/tasks/workflows/confirm_delete.jinja
new file mode 100644
index 000000000..5c333a081
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/confirm_delete.jinja
@@ -0,0 +1,41 @@
+{% extends "layouts/confirm.jinja" %}
+
+{% from "components/breadcrumbs/macro.njk" import govukBreadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = verbose_name|capitalize ~ " deleted" %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {"text": "Find and view "~ verbose_name ~ "s", "href": list_url},
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": verbose_name|capitalize ~ " ID: " ~ deleted_pk,
+    "text": verbose_name|capitalize ~ " has been deleted",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "Find and view " ~ verbose_name ~ "s",
+    "href": list_url,
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Create a " ~ verbose_name,
+    "href": create_url,
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/confirm_update.jinja b/tasks/jinja2/tasks/workflows/confirm_update.jinja
new file mode 100644
index 000000000..9c4efc761
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/confirm_update.jinja
@@ -0,0 +1,53 @@
+{% extends "layouts/confirm.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set object_name = object._meta.verbose_name %}
+{% set page_title = object_name|capitalize ~ " updated" %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {"text": "Find and view " ~ object_name ~ "s", "href": object.get_url("list")},
+      {"text": object_name|capitalize ~ ": " ~ object.title, "href": object.get_url("detail")},
+      {"text": page_title}
+    ],
+    with_workbasket=False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": object_name|capitalize ~ ": " ~ object,
+    "text": "You have updated the " ~ object_name,
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View " ~ object_name,
+    "href": object.get_url("detail"),
+    "classes": "govuk-button"
+  }) }}
+  {% if object_name == "workflow" %}
+    {{ govukButton({
+      "text": "Create a task",
+      "href": "#TODO",
+      "classes": "govuk-button--secondary"
+    }) }}
+  {% elif object_name == "workflow template" %}
+    {{ govukButton({
+      "text": "Create a task template",
+      "href": url("workflow:task-template-ui-create", kwargs={"workflow_template_pk": object.pk}),
+      "classes": "govuk-button--secondary"
+    }) }}
+  {% endif %}
+{% endblock %}
+
+{% block actions %}
+  <a href={{ object.get_url("list") }} class="govuk-link">Find and view {{object_name}}s</a>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/create.jinja b/tasks/jinja2/tasks/workflows/create.jinja
new file mode 100644
index 000000000..a2affcceb
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/create.jinja
@@ -0,0 +1,16 @@
+{% extends "layouts/create.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+
+{% set page_title = "Create a " ~ verbose_name  %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {"text": "Find and view "~ verbose_name ~ "s", "href": list_url},
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/delete.jinja b/tasks/jinja2/tasks/workflows/delete.jinja
new file mode 100644
index 000000000..aff449a61
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/delete.jinja
@@ -0,0 +1,33 @@
+{% extends "layouts/form.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/warning-text/macro.njk" import govukWarningText %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set object_name = object._meta.verbose_name %}
+{% set page_title = "Delete " ~ object_name ~ ": " ~ object.title %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {"text": "Find and view "~ object_name ~ "s", "href": object.get_url("list")},
+      {
+        "text": object_name|capitalize ~ ": " ~ object.title,
+        "href": object.get_url("detail"),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block form %}
+  {{ govukWarningText({
+    "text": "Are you sure you want to delete this " ~ object_name ~ "?",
+  }) }}
+
+  {% call django_form(action=object.get_url("delete")) %}
+    {{ crispy(form) }}
+  {% endcall %}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/detail.jinja b/tasks/jinja2/tasks/workflows/detail.jinja
new file mode 100644
index 000000000..db9be5e80
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/detail.jinja
@@ -0,0 +1,105 @@
+{% extends "layouts/layout.jinja" %}
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set object_name = object._meta.verbose_name %}
+
+{% set page_title = object_name|capitalize ~ ": " ~ object.title %}
+
+{% if object_name == "workflow" %}
+  {% set task_object_name = "task" %}
+  {% set task_object_create_url = "#TODO" %}
+{% elif object_name == "workflow template" %}
+  {% set task_object_name = "task template" %}
+  {% set task_object_create_url = url("workflow:task-template-ui-create", kwargs={"workflow_template_pk": object.pk}) %}
+{% endif %}
+
+{% set list_include = "tasks/includes/task_queue.jinja" %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(request, [
+      {"text": "Find and view "~ object_name ~ "s", "href": object.get_url("list")},
+      {"text": page_title}
+    ],
+    with_workbasket=False,
+  ) }}
+{% endblock %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+
+  <h2 class="govuk-heading-m">Details</h2>
+  
+  <dl class="govuk-summary-list">
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">
+        ID
+      </dt>
+      <dd class="govuk-summary-list__value">
+        {{ object.pk }}
+      </dd>
+      <dd class="govuk-summary-list__actions"></dd>
+    </div>
+
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">
+        Title
+      </dt>
+      <dd class="govuk-summary-list__value">
+        {{ object.title }}
+      </dd>
+      <dd class="govuk-summary-list__actions">
+        <a class="govuk-link" href="{{ object.get_url("edit") }}">Change<span class="govuk-visually-hidden"> title</span></a>
+      </dd>
+    </div>
+
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">
+        Description
+      </dt>
+      <dd class="govuk-summary-list__value">
+        {{ object.description }}
+      </dd>
+      <dd class="govuk-summary-list__actions">
+        <a class="govuk-link" href="{{ object.get_url("edit") }}">Change<span class="govuk-visually-hidden"> description</span></a>
+      </dd>
+    </div>
+  </dl>
+
+  <div class="govuk-grid-row">
+    <div class="govuk-grid-column-three-quarters">
+      <h2 class="govuk-heading-m">{{ task_object_name|capitalize }}s</h2>
+    </div>
+
+    <div class="govuk-grid-column-one-quarter">
+      {{ govukButton({
+        "text": "Create a " ~ task_object_name,
+        "href": task_object_create_url,
+        "classes": "govuk-button align-right"
+      }) }}
+    </div>
+  </div>
+
+  <div class="govuk-grid-row">
+    <div class="govuk-grid-column-full">
+      {% if object_list %}
+        {% include list_include %}
+      {% else %}
+        <p class="govuk-body">There are no {{ task_object_name }}s for this {{ object_name }}.</p>
+      {% endif %}
+    </div>
+  </div>
+
+  <div class="govuk-button-group govuk-!-margin-top-6">
+    {{ govukButton({
+      "text": "Delete " ~ object_name,
+      "href": object.get_url("delete"),
+      "classes": "govuk-button--warning"
+    }) }}
+    {{ govukButton({
+      "text": "Find and view " ~ object_name ~ "s",
+      "href": object.get_url("list"),
+      "classes": "govuk-button--secondary"
+    }) }}
+  </div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/edit.jinja b/tasks/jinja2/tasks/workflows/edit.jinja
new file mode 100644
index 000000000..f4789b63d
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/edit.jinja
@@ -0,0 +1,22 @@
+{% extends "layouts/form.jinja" %}
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+
+{% set object_name = object._meta.verbose_name %}
+
+{% set page_title = "Edit " ~ object_name ~ " details" %}
+
+{% block breadcrumb %}
+  {{ breadcrumbs(request, [
+      {"text": "Find and view " ~ object_name ~ "s", "href": object.get_url("list")},
+      {"text": object_name|capitalize ~ ": " ~ object.title, "href": object.get_url("detail")},
+      {"text": page_title}
+    ],
+    with_workbasket=False,
+  )}}
+{% endblock %}
+
+{% block form %}
+  {% call django_form() %}
+    {{ crispy(form) }}
+  {% endcall %}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/list.jinja b/tasks/jinja2/tasks/workflows/list.jinja
new file mode 100644
index 000000000..fd76656f0
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/list.jinja
@@ -0,0 +1,86 @@
+{% extends "layouts/layout.jinja" %}
+
+{% from "components/table/macro.njk" import govukTable %}
+{% from "components/create_sortable_anchor.jinja" import create_sortable_anchor %}
+
+{% set page_title = "Find and view tasks workflows" %}
+
+{% set base_url = url("workflow:task-workflow-ui-list") %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+  <p class="govuk-body">
+    Search for workflows. Alternatively,
+    <a class="govuk-link" href="{{ url('workflow:task-workflow-ui-create') }}">create a new workflow</a>
+  </p>
+
+  <div class="filter-layout">
+    <div class="filter-layout__filters">
+      <h2 class="govuk-heading-m govuk-!-margin-top-3">Search and filter</h2>
+
+      <form method="get" action="{{ url("workflow:task-workflow-ui-list") }}">
+          {{ crispy(filter.form) }}
+      </form>
+    </div>
+
+    <div class="filter-layout__content">
+      {% if paginator.count > 0 %}
+        {% include "includes/common/pagination-list-summary.jinja" %}
+      {% endif %}
+
+      {% if object_list %}
+        {% set table_rows = [] %}
+
+        {% for object in object_list %}
+          {%- set task_linked_id -%}
+            <a
+              class="govuk-link"
+              href="{{ url('workflow:task-workflow-ui-detail', kwargs={'pk':  object.taskworkflow.pk}) }}"
+            >{{ object.taskworkflow.pk }}</a>
+          {%- endset -%}
+
+          {%- set workbasket_linked_id -%}
+            {% if object.workbasket %}
+              <a
+                class="govuk-link"
+                href="{{ url("workbaskets:workbasket-ui-detail", kwargs={"pk": object.workbasket.pk}) }}"
+              >{{ object.workbasket.pk }}</a>
+            {%- else -%}
+              -
+            {%- endif -%}
+          {%- endset -%}
+
+          {{ table_rows.append([
+            {"text": task_linked_id},
+            {"text": object.title},
+            {"text": object.category},
+            {"text": object.progress_state},
+            {"text": workbasket_linked_id},
+            {"text": "{:%d %b %Y}".format(object.created_at)},
+          ]) or "" }}
+        {% endfor %}
+
+        {{ govukTable({
+          "head": [
+            {"text": "ID"},
+            {"text": "Title"},
+            {"text": "Category"},
+            {"text": "Status"},
+            {"text": "Workbasket"},
+            {"text": create_sortable_anchor(request, "created_at", "Created", base_url)},
+          ],
+            "rows": table_rows
+          }) }}
+      {% else %}
+        <p class="govuk-body">There are no results for your search, please:</p>
+        <ul class="govuk-list govuk-list--bullet">
+          <li>check the spelling of your keywords</li>
+          <li>use more general keywords</li>
+          <li>select or deselect different filters</li>
+        </ul>
+      {% endif %}
+
+      {% include "includes/common/pagination.jinja" %}
+    </div>
+  </div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task-and-workflow-list.jinja b/tasks/jinja2/tasks/workflows/task-and-workflow-list.jinja
new file mode 100644
index 000000000..e0e5339ae
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task-and-workflow-list.jinja
@@ -0,0 +1,105 @@
+{% extends "layouts/layout.jinja" %}
+
+{% from "components/table/macro.njk" import govukTable %}
+{% from "components/create_sortable_anchor.jinja" import create_sortable_anchor %}
+
+{% set page_title = "Find and view tasks and workflows" %}
+
+{% set base_url = url("workflow:task-and-workflow-ui-list") %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+  <p class="govuk-body">
+    Search for tasks and workflows. Alternatively
+    <a class="govuk-link" href="{{ url('workflow:task-ui-create') }}">create a new task</a>
+    or
+    <a class="govuk-link" href="{{ url('workflow:task-workflow-ui-create') }}">create a new workflow</a>.
+  </p>
+
+  <div class="filter-layout">
+    <div class="filter-layout__filters">
+      <h2 class="govuk-heading-m govuk-!-margin-top-3">Search and filter</h2>
+
+      <form method="get" action="{{ base_url }}">
+          {{ crispy(filter.form) }}
+      </form>
+    </div>
+
+    <div class="filter-layout__content">
+      {% if paginator.count > 0 %}
+        {% include "includes/common/pagination-list-summary.jinja" %}
+      {% endif %}
+
+      {% if object_list %}
+        {% set table_rows = [] %}
+
+        {% for object in object_list %}
+          {%- set task_linked_id -%}
+            {% if object.taskworkflow %}
+              <a
+                class="govuk-link"
+                href="{{ url('workflow:task-workflow-ui-detail', kwargs={'pk': object.taskworkflow.pk}) }}"
+              >{{ object.pk }}</a>
+            {% else %}
+              <a
+                class="govuk-link"
+                href="{{ url('workflow:task-ui-detail', kwargs={'pk': object.pk}) }}"
+              >{{ object.pk }}</a>
+            {% endif %}
+          {%- endset -%}
+
+          {%- set workbasket_linked_id -%}
+            {% if object.workbasket %}
+              <a
+                class="govuk-link"
+                href="{{ url('workbaskets:workbasket-ui-detail', kwargs={'pk': object.workbasket.pk}) }}"
+              >{{ object.workbasket.pk }}</a>
+            {%- else -%}
+              -
+            {%- endif -%}
+          {%- endset -%}
+
+          {%- set object_type -%}
+            {% if object.is_summary_task %}
+              Workflow
+            {% else %}
+              Task
+            {% endif %}
+          {%- endset -%}
+
+          {{ table_rows.append([
+            {"text": task_linked_id},
+            {"text": object.title},
+            {"text": object_type},
+            {"text": object.category},
+            {"text": object.progress_state},
+            {"text": workbasket_linked_id},
+            {"text": "{:%d %b %Y}".format(object.created_at)},
+          ]) or "" }}
+        {% endfor %}
+
+        {{ govukTable({
+          "head": [
+            {"text": "ID"},
+            {"text": "Title"},
+            {"text": "Type"},
+            {"text": "Category"},
+            {"text": "Status"},
+            {"text": "Workbasket"},
+            {"text": create_sortable_anchor(request, "created_at", "Created", base_url)},
+          ],
+            "rows": table_rows
+          }) }}
+      {% else %}
+        <p class="govuk-body">There are no results for your search, please:</p>
+        <ul class="govuk-list govuk-list--bullet">
+          <li>check the spelling of your keywords</li>
+          <li>use more general keywords</li>
+          <li>select or deselect different filters</li>
+        </ul>
+      {% endif %}
+
+      {% include "includes/common/pagination.jinja" %}
+    </div>
+  </div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_confirm_create.jinja b/tasks/jinja2/tasks/workflows/task_template_confirm_create.jinja
new file mode 100644
index 000000000..0c532419c
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_confirm_create.jinja
@@ -0,0 +1,53 @@
+{% extends "common/confirm_create.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Task template created" %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url(
+          "workflow:task-workflow-template-ui-detail",
+          kwargs={"pk": task_workflow_template.pk}),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": "Task template: " ~ object.title,
+    "text": "You have created a new task template",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View task template",
+    "href": url("workflow:task-template-ui-detail", kwargs={"pk": object.pk}),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li><a href="{{ url('workflow:task-workflow-template-ui-list') }}" class="govuk-link">Find and edit workflow templates</a></li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_confirm_delete.jinja b/tasks/jinja2/tasks/workflows/task_template_confirm_delete.jinja
new file mode 100644
index 000000000..66d11df2e
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_confirm_delete.jinja
@@ -0,0 +1,61 @@
+{% extends "layouts/confirm.jinja" %}
+
+{% from "components/breadcrumbs/macro.njk" import govukBreadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Task template deleted" %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url(
+          "workflow:task-workflow-template-ui-detail",
+          kwargs={"pk": task_workflow_template.pk},
+        ),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": "Task template ID: " ~ deleted_pk,
+    "text": "Task template has been deleted",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View workflow template",
+    "href": url(
+      "workflow:task-workflow-template-ui-detail",
+      kwargs={"pk": task_workflow_template.pk},
+    ),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li>
+    <a class="govuk-link"
+      href="{{ url('workflow:task-template-ui-create', kwargs={'workflow_template_pk': task_workflow_template.pk}) }}"
+    >Create a task template</a>
+  </li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_confirm_update.jinja b/tasks/jinja2/tasks/workflows/task_template_confirm_update.jinja
new file mode 100644
index 000000000..37c745db3
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_confirm_update.jinja
@@ -0,0 +1,52 @@
+{% extends "common/confirm_update.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/panel/macro.njk" import govukPanel %}
+{% from "components/button/macro.njk" import govukButton %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url(
+          "workflow:task-workflow-template-ui-detail",
+          kwargs={"pk": task_workflow_template.pk},
+        ),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block panel %}
+  {{ govukPanel({
+    "titleText": "Task template: " ~ object.title,
+    "text": "Task template has been updated",
+    "classes": "govuk-!-margin-bottom-7"
+  }) }}
+{% endblock %}
+
+{% block button_group %}
+  {{ govukButton({
+    "text": "View task template",
+    "href": url("workflow:task-template-ui-detail", kwargs={"pk": object.pk}),
+    "classes": "govuk-button"
+  }) }}
+  {{ govukButton({
+    "text": "Return to homepage",
+    "href": url("home"),
+    "classes": "govuk-button--secondary"
+  }) }}
+{% endblock %}
+
+{% block actions %}
+  <li><a href="{{ url('workflow:task-workflow-template-ui-list') }}" class="govuk-link">Find and edit workflow templates</a></li>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_delete.jinja b/tasks/jinja2/tasks/workflows/task_template_delete.jinja
new file mode 100644
index 000000000..0bb6a8066
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_delete.jinja
@@ -0,0 +1,43 @@
+{% extends "common/delete.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/warning-text/macro.njk" import govukWarningText %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Delete task template:" ~ object.title %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url("workflow:task-workflow-template-ui-detail", kwargs={"pk": task_workflow_template.pk}),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block form %}
+  {{ govukWarningText({
+    "text": "Are you sure you want to delete this task template?"
+  }) }}
+
+  {% call django_form(
+      action=url(
+        "workflow:task-template-ui-delete",
+        kwargs={
+          "workflow_template_pk": task_workflow_template.pk,
+          "pk": object.pk,
+        }),
+  ) %}
+    {{ crispy(form) }}
+  {% endcall %}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_detail.jinja b/tasks/jinja2/tasks/workflows/task_template_detail.jinja
new file mode 100644
index 000000000..f42ff3f41
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_detail.jinja
@@ -0,0 +1,72 @@
+{% extends "layouts/layout.jinja" %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+{% from "components/button/macro.njk" import govukButton %}
+
+{% set page_title = "Task template: " ~ object.title %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url(
+          "workflow:task-workflow-template-ui-detail",
+          kwargs={"pk": task_workflow_template.pk}),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+
+  <h2 class="govuk-heading-m">Details</h2>
+
+  <dl class="govuk-summary-list">
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">ID</dt>
+      <dd class="govuk-summary-list__value">{{ object.pk }}</dd>
+      <dd class="govuk-summary-list__actions"></dd>
+    </div>
+
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">Title</dt>
+      <dd class="govuk-summary-list__value">{{ object.title }}</dd>
+      <dd class="govuk-summary-list__actions">
+        <a class="govuk-link" href="{{ object.get_url(action='edit') }}">Change<span class="govuk-visually-hidden"> title</span></a>
+      </dd>
+    </div>
+
+    <div class="govuk-summary-list__row">
+      <dt class="govuk-summary-list__key">Description</dt>
+      <dd class="govuk-summary-list__value">{{ object.description }}</dd>
+      <dd class="govuk-summary-list__actions">
+        <a class="govuk-link" href="{{ object.get_url(action='edit') }}">Change<span class="govuk-visually-hidden"> description</span></a>
+      </dd>
+    </div>
+  </dl>
+
+  <div class="govuk-button-group govuk-!-margin-top-6">
+  {{ govukButton({
+      "text": "Delete task template",
+      "href": url(
+        "workflow:task-template-ui-delete",
+        kwargs={
+          "workflow_template_pk": task_workflow_template.pk,
+          "pk": object.pk,
+        },
+      ),
+
+      "classes": "govuk-button--warning"
+  }) }}
+  </div>
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/task_template_save.jinja b/tasks/jinja2/tasks/workflows/task_template_save.jinja
new file mode 100644
index 000000000..5ac41d48d
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/task_template_save.jinja
@@ -0,0 +1,22 @@
+{% extends 'layouts/create.jinja' %}
+
+{% from "components/breadcrumbs.jinja" import breadcrumbs %}
+
+
+{% block breadcrumb %}
+  {{ breadcrumbs(
+    request,
+    [
+      {
+        "text": "Find and view workflow templates",
+        "href": url("workflow:task-workflow-template-ui-list"),
+      },
+      {
+        "text": "Workflow template: " ~ task_workflow_template.title,
+        "href": url("workflow:task-workflow-template-ui-detail", kwargs={"pk": task_workflow_template.pk}),
+      },
+      {"text": page_title}
+    ],
+    False,
+  ) }}
+{% endblock %}
diff --git a/tasks/jinja2/tasks/workflows/template_list.jinja b/tasks/jinja2/tasks/workflows/template_list.jinja
new file mode 100644
index 000000000..3be85f30e
--- /dev/null
+++ b/tasks/jinja2/tasks/workflows/template_list.jinja
@@ -0,0 +1,71 @@
+{% extends "layouts/layout.jinja" %}
+
+{% from "components/table/macro.njk" import govukTable %}
+{% from "components/create_sortable_anchor.jinja" import create_sortable_anchor %}
+
+{% set page_title = "Find and view task workflow templates" %}
+
+{% set base_url = url("workflow:task-workflow-template-ui-list") %}
+
+{% block content %}
+  <h1 class="govuk-heading-xl">{{ page_title }}</h1>
+  <p class="govuk-body">
+    Search for task workflow templates.
+    Alternatively, <a class="govuk-link" href="{{ url("workflow:task-workflow-template-ui-create") }}">create a new task workflow template</a>.
+  </p>
+
+  <div class="filter-layout">
+    <div class="filter-layout__filters">
+      <h2 class="govuk-heading-m govuk-!-margin-top-3">Search and filter</h2>
+      <form method="get" action="{{ url("workflow:task-workflow-template-ui-list") }}">
+          {{ crispy(filter.form) }}
+      </form>
+    </div>
+
+  <div class="filter-layout__content">
+    {% if paginator.count > 0 %}
+      {% include "includes/common/pagination-list-summary.jinja" %}
+    {% endif %}
+    {% if object_list %}
+      {% set table_rows = [] %}
+      {% for object in object_list %}
+        {%- set workflow_template_linked_id -%}
+          <a
+            class="govuk-link"
+            href="{{ url("workflow:task-workflow-template-ui-detail", kwargs={"pk": object.pk}) }}"
+          >{{ object.pk }}</a>
+        {%- endset -%}
+
+        {{ table_rows.append([
+          {"text": workflow_template_linked_id},
+          {"text": object.title},
+          {"text": object.description},
+          {"text": object.creator.get_displayname() if object.creator else "Unknown"},
+          {"text": object.created_at.strftime(datetime_format)},
+          {"text": object.updated_at.strftime(datetime_format)},
+        ]) or "" }}
+      {% endfor %}
+
+      {{ govukTable({
+        "head": [
+          {"text": "ID"},
+          {"text": "Title"},
+          {"text": "Description"},
+          {"text": "Created by"},
+          {"text": create_sortable_anchor(request, "created_at", "Created", base_url)},
+          {"text": create_sortable_anchor(request, "updated_at", "Last Updated", base_url)},
+        ],
+          "rows": table_rows
+        }) }}
+    {% else %}
+      <p class="govuk-body">There are no results for your search, please:</p>
+      <ul class="govuk-list govuk-list--bullet">
+        <li>check the spelling of your keywords</li>
+        <li>use more general keywords</li>
+        <li>select or deselect different filters</li>
+      </ul>
+    {% endif %}
+    {% include "includes/common/pagination.jinja" %}
+  </div>
+</div>
+{% endblock %}
\ No newline at end of file
diff --git a/tasks/migrations/0003_rename_userassignment_taskassignee.py b/tasks/migrations/0003_rename_userassignment_taskassignee.py
new file mode 100644
index 000000000..45e8c73c1
--- /dev/null
+++ b/tasks/migrations/0003_rename_userassignment_taskassignee.py
@@ -0,0 +1,60 @@
+# Generated by Django 4.2.14 on 2024-09-05 14:06
+
+from django.conf import settings
+from django.db import migrations
+from django.db import models
+
+
+def forwards_delete_outdated_permissions(apps, schema_editor):
+    """Deletes old set of permissions belonging to `UserAssignment` following
+    the renaming to `TaskAssignee` as Django creates a new set of permissions
+    for the renamed table."""
+    Permission = apps.get_model("auth.Permission")
+    Permission.objects.filter(
+        models.Q(codename="add_userassignment")
+        | models.Q(codename="change_userassignment")
+        | models.Q(codename="delete_userassignment")
+        | models.Q(codename="view_userassignment"),
+    ).delete()
+
+
+def backwards_delete_outdated_permissions(apps, schema_editor):
+    """Deletes old set of permissions belonging to `TaskAssignee` following the
+    renaming back to `UserAssignment` as Django creates a new set of permissions
+    for the renamed table."""
+    Permission = apps.get_model("auth.Permission")
+    Permission.objects.filter(
+        models.Q(codename="add_taskassignee")
+        | models.Q(codename="change_taskassignee")
+        | models.Q(codename="delete_taskassignee")
+        | models.Q(codename="view_taskassignee"),
+    ).delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("tasks", "0002_comment"),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name="UserAssignment",
+            new_name="TaskAssignee",
+        ),
+        migrations.AlterField(
+            model_name="taskassignee",
+            name="task",
+            field=models.ForeignKey(
+                editable=False,
+                on_delete=models.deletion.CASCADE,
+                related_name="assignees",
+                to="tasks.task",
+            ),
+        ),
+        migrations.RunPython(
+            forwards_delete_outdated_permissions,
+            backwards_delete_outdated_permissions,
+        ),
+    ]
diff --git a/tasks/migrations/0004_taskcategory_taskprogressstate_task_category_and_more.py b/tasks/migrations/0004_taskcategory_taskprogressstate_task_category_and_more.py
new file mode 100644
index 000000000..f76c7f31b
--- /dev/null
+++ b/tasks/migrations/0004_taskcategory_taskprogressstate_task_category_and_more.py
@@ -0,0 +1,134 @@
+# Generated by Django 4.2.14 on 2024-09-06 14:33
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+from tasks.models import ProgressState as TaskProgressState
+from workbaskets.validators import WorkflowStatus
+
+
+def forwards_create_default_task_progress_state_instances(apps, schema_editor):
+    """Creates default `ProgressState` instances for `TO_DO`, `IN_PROGRESS` and
+    `DONE`."""
+    ProgressState = apps.get_model("tasks", "ProgressState")
+    progress_states = [ProgressState(name=state) for state in TaskProgressState.State]
+    ProgressState.objects.bulk_create(progress_states)
+
+
+def forwards_update_existing_tasks_progress_state(apps, schema_editor):
+    """
+    Updates `progress_state` on existing `Task` instances that have an
+    associated workbasket.
+
+    Tasks with an unpublished workbasket are set to `ProgressState.State.IN_PROGRESS`
+    and tasks with a published workbasket are set to `ProgressState.State.DONE`.
+    """
+    ProgressState = apps.get_model("tasks", "ProgressState")
+    inprogress_state = ProgressState.objects.get(
+        name=TaskProgressState.State.IN_PROGRESS,
+    )
+    done_state = ProgressState.objects.get(name=TaskProgressState.State.DONE)
+    Task = apps.get_model("tasks", "Task")
+
+    Task.objects.filter(
+        models.Q(workbasket__status=WorkflowStatus.EDITING)
+        | models.Q(workbasket__status=WorkflowStatus.QUEUED)
+        | models.Q(workbasket__status=WorkflowStatus.ERRORED),
+    ).update(progress_state=inprogress_state)
+
+    Task.objects.filter(
+        models.Q(workbasket__status=WorkflowStatus.PUBLISHED)
+        | models.Q(workbasket__status=WorkflowStatus.ARCHIVED),
+    ).update(progress_state=done_state)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0003_rename_userassignment_taskassignee"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Category",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=255, unique=True)),
+            ],
+            options={
+                "ordering": ["name"],
+                "verbose_name_plural": "categories",
+            },
+        ),
+        migrations.CreateModel(
+            name="ProgressState",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        choices=[
+                            ("TO_DO", "To do"),
+                            ("IN_PROGRESS", "In progress"),
+                            ("DONE", "Done"),
+                        ],
+                        max_length=255,
+                        unique=True,
+                    ),
+                ),
+            ],
+        ),
+        migrations.RunPython(
+            forwards_create_default_task_progress_state_instances,
+            migrations.RunPython.noop,
+        ),
+        migrations.AddField(
+            model_name="task",
+            name="category",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.category",
+            ),
+        ),
+        migrations.AddField(
+            model_name="task",
+            name="progress_state",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.progressstate",
+            ),
+        ),
+        migrations.RunPython(
+            forwards_update_existing_tasks_progress_state,
+            migrations.RunPython.noop,
+        ),
+        migrations.AlterField(
+            model_name="task",
+            name="progress_state",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.progressstate",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0005_task_parent_task.py b/tasks/migrations/0005_task_parent_task.py
new file mode 100644
index 000000000..fa287684c
--- /dev/null
+++ b/tasks/migrations/0005_task_parent_task.py
@@ -0,0 +1,26 @@
+# Generated by Django 4.2.14 on 2024-09-09 08:14
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0004_taskcategory_taskprogressstate_task_category_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="task",
+            name="parent_task",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="subtasks",
+                to="tasks.task",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0006_task_creator.py b/tasks/migrations/0006_task_creator.py
new file mode 100644
index 000000000..14a36da18
--- /dev/null
+++ b/tasks/migrations/0006_task_creator.py
@@ -0,0 +1,27 @@
+# Generated by Django 4.2.14 on 2024-09-09 08:46
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("tasks", "0005_task_parent_task"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="task",
+            name="creator",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="created_tasks",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0007_create_tasklog.py b/tasks/migrations/0007_create_tasklog.py
new file mode 100644
index 000000000..05659f3fa
--- /dev/null
+++ b/tasks/migrations/0007_create_tasklog.py
@@ -0,0 +1,71 @@
+# Generated by Django 4.2.14 on 2024-09-09 11:03
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("tasks", "0006_task_creator"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="taskassignee",
+            name="assigned_by",
+        ),
+        migrations.CreateModel(
+            name="TaskLog",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "action",
+                    models.CharField(
+                        choices=[
+                            ("TASK_ASSIGNED", "Task Assigned"),
+                            ("TASK_UNASSIGNED", "Task Unassigned"),
+                            ("PROGRESS_STATE_UPDATED", "Progress State Updated"),
+                        ],
+                        editable=False,
+                        max_length=100,
+                    ),
+                ),
+                ("description", models.TextField(editable=False)),
+                (
+                    "instigator",
+                    models.ForeignKey(
+                        editable=False,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "task",
+                    models.ForeignKey(
+                        editable=False,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="logs",
+                        to="tasks.task",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]
diff --git a/tasks/migrations/0008_alter_task_workbasket.py b/tasks/migrations/0008_alter_task_workbasket.py
new file mode 100644
index 000000000..391ef9983
--- /dev/null
+++ b/tasks/migrations/0008_alter_task_workbasket.py
@@ -0,0 +1,27 @@
+# Generated by Django 4.2.14 on 2024-09-10 18:06
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("workbaskets", "0008_datarow_dataupload"),
+        ("tasks", "0007_create_tasklog"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="task",
+            name="workbasket",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="tasks",
+                to="workbaskets.workbasket",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0009_taskworkflowtemplate_taskworkflow_tasktemplate_and_more.py b/tasks/migrations/0009_taskworkflowtemplate_taskworkflow_tasktemplate_and_more.py
new file mode 100644
index 000000000..7eaf5611d
--- /dev/null
+++ b/tasks/migrations/0009_taskworkflowtemplate_taskworkflow_tasktemplate_and_more.py
@@ -0,0 +1,165 @@
+# Generated by Django 4.2.15 on 2024-11-04 12:23
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0008_alter_task_workbasket"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="TaskWorkflowTemplate",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("title", models.CharField(max_length=255)),
+                ("description", models.TextField(blank=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="TaskWorkflow",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("title", models.CharField(max_length=255)),
+                ("description", models.TextField(blank=True)),
+                (
+                    "creator_template",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="tasks.taskworkflowtemplate",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="TaskTemplate",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("title", models.CharField(max_length=255)),
+                ("description", models.TextField()),
+                (
+                    "category",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to="tasks.category",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="TaskItemTemplate",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "position",
+                    models.PositiveSmallIntegerField(db_index=True, editable=False),
+                ),
+                (
+                    "queue",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="queue_items",
+                        to="tasks.taskworkflowtemplate",
+                    ),
+                ),
+                (
+                    "task_template",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="tasks.tasktemplate",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["queue", "position"],
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="TaskItem",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "position",
+                    models.PositiveSmallIntegerField(db_index=True, editable=False),
+                ),
+                (
+                    "queue",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="queue_items",
+                        to="tasks.taskworkflow",
+                    ),
+                ),
+                (
+                    "task",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="tasks.task",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["queue", "position"],
+                "abstract": False,
+            },
+        ),
+    ]
diff --git a/tasks/migrations/0010_alter_task_progress_state.py b/tasks/migrations/0010_alter_task_progress_state.py
new file mode 100644
index 000000000..08557c906
--- /dev/null
+++ b/tasks/migrations/0010_alter_task_progress_state.py
@@ -0,0 +1,26 @@
+# Generated by Django 4.2.16 on 2024-11-12 15:08
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+import tasks.models.task
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0009_taskworkflowtemplate_taskworkflow_tasktemplate_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="task",
+            name="progress_state",
+            field=models.ForeignKey(
+                default=tasks.models.task.ProgressState.get_default_state_id,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.progressstate",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0011_taskworkflow_summary_task.py b/tasks/migrations/0011_taskworkflow_summary_task.py
new file mode 100644
index 000000000..3c9e9c435
--- /dev/null
+++ b/tasks/migrations/0011_taskworkflow_summary_task.py
@@ -0,0 +1,24 @@
+# Generated by Django 4.2.16 on 2024-11-20 17:22
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0010_alter_task_progress_state"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="taskworkflow",
+            name="summary_task",
+            field=models.OneToOneField(
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.task",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0012_taskworkflow_assign_summary_task.py b/tasks/migrations/0012_taskworkflow_assign_summary_task.py
new file mode 100644
index 000000000..ac8848ab8
--- /dev/null
+++ b/tasks/migrations/0012_taskworkflow_assign_summary_task.py
@@ -0,0 +1,24 @@
+# Generated by Django 4.2.16 on 2024-11-20 17:27
+
+from django.db import migrations
+
+
+def assign_new_summary_task_on_workflow(apps, schema_editor):
+    Task = apps.get_model("tasks", "Task")
+    TaskWorkflow = apps.get_model("tasks", "TaskWorkflow")
+
+    for task_workflow in TaskWorkflow.objects.all():
+        task_workflow.summary_task = Task.objects.create(
+            title="Workflow summarising task",
+            description="Workflow summarising task.",
+        )
+        task_workflow.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0011_taskworkflow_summary_task"),
+    ]
+
+    operations = [migrations.RunPython(assign_new_summary_task_on_workflow)]
diff --git a/tasks/migrations/0013_alter_taskworkflow_summary_task.py b/tasks/migrations/0013_alter_taskworkflow_summary_task.py
new file mode 100644
index 000000000..8e257e1a0
--- /dev/null
+++ b/tasks/migrations/0013_alter_taskworkflow_summary_task.py
@@ -0,0 +1,23 @@
+# Generated by Django 4.2.16 on 2024-11-20 17:31
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0012_taskworkflow_assign_summary_task"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="taskworkflow",
+            name="summary_task",
+            field=models.OneToOneField(
+                on_delete=django.db.models.deletion.PROTECT,
+                to="tasks.task",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0014_remove_taskworkflow_description_and_more.py b/tasks/migrations/0014_remove_taskworkflow_description_and_more.py
new file mode 100644
index 000000000..91757eed9
--- /dev/null
+++ b/tasks/migrations/0014_remove_taskworkflow_description_and_more.py
@@ -0,0 +1,30 @@
+# Generated by Django 4.2.16 on 2024-11-20 17:46
+
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0013_alter_taskworkflow_summary_task"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="taskworkflow",
+            name="description",
+        ),
+        migrations.RemoveField(
+            model_name="taskworkflow",
+            name="title",
+        ),
+        migrations.AlterField(
+            model_name="taskworkflowtemplate",
+            name="description",
+            field=models.TextField(
+                blank=True,
+                help_text="Description of what this workflow template is used for. ",
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0015_alter_taskworkflow_options_and_more.py b/tasks/migrations/0015_alter_taskworkflow_options_and_more.py
new file mode 100644
index 000000000..41e835e11
--- /dev/null
+++ b/tasks/migrations/0015_alter_taskworkflow_options_and_more.py
@@ -0,0 +1,21 @@
+# Generated by Django 4.2.15 on 2024-11-26 13:55
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0014_remove_taskworkflow_description_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="taskworkflow",
+            options={"verbose_name": "workflow"},
+        ),
+        migrations.AlterModelOptions(
+            name="taskworkflowtemplate",
+            options={"verbose_name": "workflow template"},
+        ),
+    ]
diff --git a/tasks/migrations/0016_taskworkflowtemplate_creator.py b/tasks/migrations/0016_taskworkflowtemplate_creator.py
new file mode 100644
index 000000000..68ad3ffa1
--- /dev/null
+++ b/tasks/migrations/0016_taskworkflowtemplate_creator.py
@@ -0,0 +1,27 @@
+# Generated by Django 4.2.15 on 2024-12-05 15:15
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("tasks", "0015_alter_taskworkflow_options_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="taskworkflowtemplate",
+            name="creator",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="created_taskworkflowtemplates",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
diff --git a/tasks/migrations/0017_rename_queue_taskitem_workflow_and_more.py b/tasks/migrations/0017_rename_queue_taskitem_workflow_and_more.py
new file mode 100644
index 000000000..1c2c8b37d
--- /dev/null
+++ b/tasks/migrations/0017_rename_queue_taskitem_workflow_and_more.py
@@ -0,0 +1,51 @@
+# Generated by Django 4.2.15 on 2024-12-05 15:46
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0016_taskworkflowtemplate_creator"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="taskitem",
+            old_name="queue",
+            new_name="workflow",
+        ),
+        migrations.AlterField(
+            model_name="taskitem",
+            name="workflow",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="workflow_items",
+                to="tasks.taskworkflow",
+            ),
+        ),
+        migrations.AlterModelOptions(
+            name="taskitem",
+            options={"ordering": ["workflow", "position"]},
+        ),
+        migrations.RenameField(
+            model_name="taskitemtemplate",
+            old_name="queue",
+            new_name="workflow_template",
+        ),
+        migrations.AlterField(
+            model_name="taskitemtemplate",
+            name="workflow_template",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="workflow_template_items",
+                to="tasks.taskworkflowtemplate",
+            ),
+        ),
+        migrations.AlterModelOptions(
+            name="taskitemtemplate",
+            options={"ordering": ["workflow_template", "position"]},
+        ),
+    ]
diff --git a/tasks/migrations/0018_taskworkflowtemplate_created_at_and_more.py b/tasks/migrations/0018_taskworkflowtemplate_created_at_and_more.py
new file mode 100644
index 000000000..ab4565535
--- /dev/null
+++ b/tasks/migrations/0018_taskworkflowtemplate_created_at_and_more.py
@@ -0,0 +1,29 @@
+# Generated by Django 4.2.15 on 2024-12-09 14:53
+
+import django.utils.timezone
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0017_rename_queue_taskitem_workflow_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="taskworkflowtemplate",
+            name="created_at",
+            field=models.DateTimeField(
+                auto_now_add=True,
+                default=django.utils.timezone.now,
+            ),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name="taskworkflowtemplate",
+            name="updated_at",
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]
diff --git a/tasks/migrations/0019_alter_task_options_alter_tasktemplate_options_and_more.py b/tasks/migrations/0019_alter_task_options_alter_tasktemplate_options_and_more.py
new file mode 100644
index 000000000..9219fcb7f
--- /dev/null
+++ b/tasks/migrations/0019_alter_task_options_alter_tasktemplate_options_and_more.py
@@ -0,0 +1,29 @@
+# Generated by Django 4.2.17 on 2024-12-17 16:04
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0018_taskworkflowtemplate_created_at_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="task",
+            options={"ordering": ["id"]},
+        ),
+        migrations.AlterModelOptions(
+            name="tasktemplate",
+            options={"ordering": ["id"]},
+        ),
+        migrations.AlterModelOptions(
+            name="taskworkflow",
+            options={"ordering": ["id"], "verbose_name": "workflow"},
+        ),
+        migrations.AlterModelOptions(
+            name="taskworkflowtemplate",
+            options={"ordering": ["id"], "verbose_name": "workflow template"},
+        ),
+    ]
diff --git a/tasks/models.py b/tasks/models.py
deleted file mode 100644
index 126675461..000000000
--- a/tasks/models.py
+++ /dev/null
@@ -1,113 +0,0 @@
-from datetime import datetime
-
-from django.conf import settings
-from django.db import models
-from django.utils.timezone import make_aware
-
-from common.models.mixins import TimestampedMixin
-from workbaskets.models import WorkBasket
-
-
-class Task(TimestampedMixin):
-    title = models.CharField(max_length=255)
-    description = models.TextField()
-    workbasket = models.ForeignKey(
-        WorkBasket,
-        on_delete=models.PROTECT,
-        related_name="tasks",
-    )
-
-    def __str__(self):
-        return self.title
-
-
-class UserAssignmentQueryset(models.QuerySet):
-    def assigned(self):
-        return self.exclude(unassigned_at__isnull=False)
-
-    def unassigned(self):
-        return self.exclude(unassigned_at__isnull=True)
-
-    def workbasket_workers(self):
-        return self.filter(
-            assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
-        )
-
-    def workbasket_reviewers(self):
-        return self.filter(
-            assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
-        )
-
-
-class UserAssignment(TimestampedMixin):
-    class AssignmentType(models.TextChoices):
-        WORKBASKET_WORKER = "WORKBASKET_WORKER", "Workbasket worker"
-        WORKBASKET_REVIEWER = "WORKBASKET_REVIEWER", "Workbasket reviewer"
-
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.PROTECT,
-        related_name="assigned_to",
-    )
-    assigned_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.PROTECT,
-        editable=False,
-        related_name="assigned_by",
-    )
-    assignment_type = models.CharField(
-        choices=AssignmentType.choices,
-        max_length=50,
-    )
-    task = models.ForeignKey(
-        Task,
-        on_delete=models.CASCADE,
-        editable=False,
-        related_name="user_assignments",
-    )
-    unassigned_at = models.DateTimeField(
-        auto_now=False,
-        blank=True,
-        null=True,
-    )
-
-    objects = UserAssignmentQueryset.as_manager()
-
-    def __str__(self):
-        return (
-            f"User: {self.user} ({self.assignment_type}), " f"Task ID: {self.task.id}"
-        )
-
-    @property
-    def is_assigned(self):
-        return True if not self.unassigned_at else False
-
-    @classmethod
-    def unassign_user(cls, user, task):
-        try:
-            assignment = cls.objects.get(user=user, task=task)
-            if assignment.unassigned_at:
-                return False
-            assignment.unassigned_at = make_aware(datetime.now())
-            assignment.save(update_fields=["unassigned_at"])
-            return True
-        except cls.DoesNotExist:
-            return False
-
-
-class Comment(TimestampedMixin):
-    author = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.PROTECT,
-        editable=False,
-        related_name="authored_comments",
-    )
-    content = models.TextField(
-        max_length=1000 * 5,  # Max words * average character word length.
-    )
-    task = models.ForeignKey(
-        Task,
-        on_delete=models.CASCADE,
-        editable=False,
-        related_name="comments",
-    )
diff --git a/tasks/models/__init__.py b/tasks/models/__init__.py
new file mode 100644
index 000000000..95be31658
--- /dev/null
+++ b/tasks/models/__init__.py
@@ -0,0 +1,37 @@
+"""Models used by all apps in the project."""
+
+from tasks.models.logs import TaskLog
+from tasks.models.queue import Queue
+from tasks.models.queue import QueueItem
+from tasks.models.queue import RequiredFieldError
+from tasks.models.task import Category
+from tasks.models.task import Comment
+from tasks.models.task import ProgressState
+from tasks.models.task import Task
+from tasks.models.task import TaskAssignee
+from tasks.models.workflow import TaskItem
+from tasks.models.workflow import TaskItemTemplate
+from tasks.models.workflow import TaskTemplate
+from tasks.models.workflow import TaskWorkflow
+from tasks.models.workflow import TaskWorkflowTemplate
+
+__all__ = [
+    # tasks.models.logs
+    "TaskLog",
+    # tasks.models.queue
+    "Queue",
+    "QueueItem",
+    "RequiredFieldError",
+    # tasks.models.task
+    "Category",
+    "Comment",
+    "ProgressState",
+    "Task",
+    "TaskAssignee",
+    # tasks.models.workflow
+    "TaskWorkflow",
+    "TaskItem",
+    "TaskWorkflowTemplate",
+    "TaskItemTemplate",
+    "TaskTemplate",
+]
diff --git a/tasks/models/logs.py b/tasks/models/logs.py
new file mode 100644
index 000000000..30c4bc046
--- /dev/null
+++ b/tasks/models/logs.py
@@ -0,0 +1,99 @@
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.db import models
+
+from common.models.mixins import TimestampedMixin
+from tasks.models.task import Task
+
+User = get_user_model()
+
+
+class TaskLogManager(models.Manager):
+    def create(
+        self,
+        task: Task,
+        action: "TaskLog.AuditActionType",
+        instigator: User,
+        **kwargs,
+    ) -> "TaskLog":
+        """
+        Creates a new `TaskLog` instance with a generated description based on
+        `action`, saving it to the database and returning the created instance.
+
+        A TaskLog's `description` is generated using a template retrieved from `TaskLog.AUDIT_ACTION_MAP` that maps an `action` to its corresponding description.
+        Additional `kwargs` are required to format the description template depending on the provided action.
+        """
+
+        if action not in self.model.AuditActionType:
+            raise ValueError(
+                f"The action '{action}' is an invalid TaskLog.AuditActionType value.",
+            )
+
+        description_template = self.model.AUDIT_ACTION_MAP.get(action)
+        if not description_template:
+            raise ValueError(
+                f"No description template found for action '{action}' in TaskLog.AUDIT_ACTION_MAP.",
+            )
+
+        context = {"instigator": instigator}
+
+        if action in {
+            self.model.AuditActionType.TASK_ASSIGNED,
+            self.model.AuditActionType.TASK_UNASSIGNED,
+        }:
+            assignee = kwargs.pop("assignee", None)
+            if not assignee:
+                raise ValueError(f"Missing 'assignee' in kwargs for action '{action}'.")
+            context["assignee"] = assignee
+
+        elif action == self.model.AuditActionType.PROGRESS_STATE_UPDATED:
+            progress_state = kwargs.pop("progress_state", None)
+            if not progress_state:
+                raise ValueError(
+                    f"Missing 'progress_state' in kwargs for action '{action}'.",
+                )
+            context["progress_state"] = progress_state
+
+        description = description_template.format(**context)
+
+        return super().create(
+            task=task,
+            action=action,
+            instigator=instigator,
+            description=description,
+            **kwargs,
+        )
+
+
+class TaskLog(TimestampedMixin):
+    class AuditActionType(models.TextChoices):
+        TASK_ASSIGNED = ("TASK_ASSIGNED",)
+        TASK_UNASSIGNED = ("TASK_UNASSIGNED",)
+        PROGRESS_STATE_UPDATED = ("PROGRESS_STATE_UPDATED",)
+
+    AUDIT_ACTION_MAP = {
+        AuditActionType.TASK_ASSIGNED: "{instigator} assigned {assignee}",
+        AuditActionType.TASK_UNASSIGNED: "{instigator} unassigned {assignee}",
+        AuditActionType.PROGRESS_STATE_UPDATED: "{instigator} changed the status to {progress_state}",
+    }
+
+    action = models.CharField(
+        max_length=100,
+        choices=AuditActionType.choices,
+        editable=False,
+    )
+    description = models.TextField(editable=False)
+    task = models.ForeignKey(
+        Task,
+        null=True,
+        on_delete=models.SET_NULL,
+        editable=False,
+        related_name="logs",
+    )
+    instigator = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.PROTECT,
+        editable=False,
+    )
+
+    objects = TaskLogManager()
diff --git a/tasks/models/queue.py b/tasks/models/queue.py
new file mode 100644
index 000000000..1dc679076
--- /dev/null
+++ b/tasks/models/queue.py
@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+from typing import Self
+
+from django.core.exceptions import FieldDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import models
+from django.db.transaction import atomic
+
+from common.util import TableLock
+from common.util import get_related_names
+
+
+class RequiredFieldError(Exception):
+    pass
+
+
+class Queue(models.Model):
+    """
+    A (FIFO) queue.
+
+    Note: This abstract class only supports a single, reverse foreign-key relationship
+    to `QueueItem` for each instance (i.e `QueueItem` instances are assumed to belong only to a single `Queue` instance).
+    """
+
+    class Meta:
+        abstract = True
+
+    def get_items(self) -> models.QuerySet:
+        """Get all queue items as a queryset."""
+        related_name = get_related_names(self, QueueItem)[0]
+        return getattr(self, related_name).all()
+
+    def get_first(self) -> QueueItem | None:
+        """Get the first item in the queue."""
+        return self.get_items().first()
+
+    def get_last(self) -> QueueItem | None:
+        """Get the last item in the queue."""
+        return self.get_items().last()
+
+    def get_item(self, position: int) -> QueueItem | None:
+        """Get the item at `position` position in the queue."""
+        try:
+            return self.get_items().get(position=position)
+        except ObjectDoesNotExist:
+            return None
+
+    @property
+    def max_position(self) -> int:
+        """
+        Returns the highest item position in the queue.
+
+        If the queue is empty it returns zero.
+        """
+        max = self.get_items().aggregate(
+            max_position=models.Max("position"),
+        )["max_position"]
+        return max if max is not None else 0
+
+
+class QueueItemMetaClass(models.base.ModelBase):
+    def __new__(cls, name, bases, attrs):
+        new_class = super().__new__(cls, name, bases, attrs)
+
+        if not new_class._meta.abstract:
+            queue_field_name = getattr(new_class, "queue_field", None)
+            cls.validate_queue_field(new_class, queue_field_name)
+
+        return new_class
+
+    @staticmethod
+    def validate_queue_field(new_class: type[Self], queue_field_name: str) -> None:
+        """Validate that concrete subclasses of `QueueItem` have a ForeignKey
+        field to a subclass of `Queue` model."""
+        try:
+            queue_field = new_class._meta.get_field(queue_field_name)
+        except FieldDoesNotExist:
+            queue_field = None
+
+        if not queue_field or not isinstance(queue_field, models.ForeignKey):
+            raise RequiredFieldError(
+                f"{new_class.__name__} must have a 'queue' ForeignKey field. The name of the field must match the value given to the 'queue_field' attribute on the model.",
+            )
+
+        if not issubclass(queue_field.remote_field.model, Queue):
+            raise RequiredFieldError(
+                f"{queue_field} must be a ForeignKey field to a subclass of 'Queue' model.",
+            )
+
+
+class QueueItemManager(models.Manager):
+    @atomic
+    def create(self, **kwargs) -> QueueItem:
+        """Create a new item instance in a queue, given by the `queue` named
+        param, and place it in last position."""
+
+        with TableLock(self.model, lock=TableLock.EXCLUSIVE):
+            queue_field = self.model.queue_field
+            queue = kwargs.pop(queue_field)
+            position = kwargs.pop("position", (queue.get_items().count() + 1))
+
+            if position <= 0:
+                raise ValueError(
+                    "QueueItem.position must be a positive integer greater than zero.",
+                )
+
+            return super().create(
+                position=position,
+                **{queue_field: queue},
+                **kwargs,
+            )
+
+
+class QueueItem(models.Model, metaclass=QueueItemMetaClass):
+    """Item that is a member of a Queue."""
+
+    class Meta:
+        abstract = True
+        ordering = ["queue", "position"]
+
+    queue_field: str = "queue"
+    """
+    The name of the required ForeignKey field relating this instance to a Queue
+    instance.
+
+    The value of this attribute can be inherited as is or overridden in
+    subclasses to reflect the specific purpose or role of the queue.
+
+    If this value is overridden, the subclass must redefine the `Meta` class
+    to maintain ordering based on the queue field.
+    """
+
+    position = models.PositiveSmallIntegerField(
+        db_index=True,
+        editable=False,
+    )
+    """
+    1-based positioning - 1 is the first position.
+    """
+
+    objects = QueueItemManager()
+
+    def get_queue_field(self) -> str:
+        """Return the queue field name on this instance."""
+        return self.__class__.queue_field
+
+    def get_queue(self) -> type[Queue]:
+        """Return the queue instance related to this instance."""
+        return getattr(self, self.get_queue_field())
+
+    @atomic
+    def delete(self):
+        """Remove and delete instance from its queue, shuffling all successive
+        queued instances up one position."""
+        instance = self.__class__.objects.select_for_update(nowait=True).get(pk=self.pk)
+
+        to_update = list(
+            self.__class__.objects.select_for_update(nowait=True)
+            .filter(
+                position__gt=instance.position,
+                **{self.get_queue_field(): self.get_queue()},
+            )
+            .values_list("pk", flat=True),
+        )
+
+        self.__class__.objects.filter(pk__in=to_update).update(
+            position=models.F("position") - 1,
+        )
+
+        return super().delete()
+
+    @atomic
+    def promote(self) -> Self:
+        """
+        Promote the instance by one place up the queue.
+
+        No change is made if the instance is already in its queue's first place.
+
+        Returns the promoted instance with any database updates applied.
+        """
+        instance = self.__class__.objects.select_for_update(nowait=True).get(pk=self.pk)
+
+        if instance.position == 1:
+            return instance
+
+        item_to_demote = self.__class__.objects.select_for_update(nowait=True).get(
+            position=instance.position - 1,
+            **{self.get_queue_field(): self.get_queue()},
+        )
+        item_to_demote.position += 1
+        instance.position -= 1
+        self.__class__.objects.bulk_update([instance, item_to_demote], ["position"])
+        instance.refresh_from_db()
+
+        return instance
+
+    @atomic
+    def demote(self) -> Self:
+        """
+        Demote the instance by one place down the queue.
+
+        No change is made if the instance is already in its queue's last place.
+
+        Returns the demoted instance with any database updates applied.
+        """
+        instance = self.__class__.objects.select_for_update(nowait=True).get(pk=self.pk)
+
+        queue_field = self.get_queue_field()
+        queue = self.get_queue()
+        queue_kwarg = {
+            queue_field: queue,
+        }
+
+        if instance.position == queue.max_position:
+            return instance
+
+        item_to_promote = self.__class__.objects.select_for_update(nowait=True).get(
+            position=instance.position + 1,
+            **queue_kwarg,
+        )
+        item_to_promote.position -= 1
+        instance.position += 1
+        self.__class__.objects.bulk_update([instance, item_to_promote], ["position"])
+        instance.refresh_from_db()
+
+        return instance
+
+    @atomic
+    def promote_to_first(self) -> Self:
+        """
+        Promote the instance to the first place in the queue so that it occupies
+        position 1.
+
+        No change is made if the instance is already in its queue's first place.
+
+        Returns the promoted instance with any database updates applied.
+        """
+
+        instance = self.__class__.objects.select_for_update(nowait=True).get(pk=self.pk)
+
+        if instance.position == 1:
+            return instance
+
+        to_update = list(
+            self.__class__.objects.select_for_update(nowait=True)
+            .filter(
+                position__lt=instance.position,
+                **{self.get_queue_field(): self.get_queue()},
+            )
+            .values_list("pk", flat=True),
+        )
+
+        self.__class__.objects.filter(pk__in=to_update).update(
+            position=models.F("position") + 1,
+        )
+
+        instance.position = 1
+        instance.save(update_fields=["position"])
+        instance.refresh_from_db()
+
+        return instance
+
+    @atomic
+    def demote_to_last(self) -> Self:
+        """
+        Demote the instance to the last place in the queue so that it occupies
+        position of queue length.
+
+        No change is made if the instance is already in its queue's last place.
+
+        Returns the demoted instance with any database updates applied.
+        """
+        instance = self.__class__.objects.select_for_update(nowait=True).get(pk=self.pk)
+
+        queue_field = self.get_queue_field()
+        queue = self.get_queue()
+        queue_kwarg = {
+            queue_field: queue,
+        }
+
+        last_place = queue.max_position
+        if instance.position == last_place:
+            return instance
+
+        to_update = list(
+            self.__class__.objects.select_for_update(nowait=True)
+            .filter(
+                position__gt=instance.position,
+                **queue_kwarg,
+            )
+            .values_list("pk", flat=True),
+        )
+
+        self.__class__.objects.filter(pk__in=to_update).update(
+            position=models.F("position") - 1,
+        )
+
+        instance.position = last_place
+        instance.save(update_fields=["position"])
+        instance.refresh_from_db()
+
+        return instance
diff --git a/tasks/models/task.py b/tasks/models/task.py
new file mode 100644
index 000000000..a93970dd7
--- /dev/null
+++ b/tasks/models/task.py
@@ -0,0 +1,271 @@
+from datetime import datetime
+
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.db import transaction
+from django.urls import reverse
+from django.utils.timezone import make_aware
+
+from common.models.mixins import TimestampedMixin
+from common.models.mixins import WithSignalManagerMixin
+from common.models.mixins import WithSignalQuerysetMixin
+from workbaskets.models import WorkBasket
+
+User = get_user_model()
+
+
+class ProgressState(models.Model):
+    class State(models.TextChoices):
+        TO_DO = "TO_DO", "To do"
+        IN_PROGRESS = "IN_PROGRESS", "In progress"
+        DONE = "DONE", "Done"
+
+    DEFAULT_STATE_NAME = State.TO_DO
+    """The name of the default `State` object for `ProgressState`."""
+
+    name = models.CharField(
+        max_length=255,
+        choices=State.choices,
+        unique=True,
+    )
+
+    def __str__(self):
+        return self.get_name_display()
+
+    @classmethod
+    def get_default_state_id(cls):
+        """Get the id / pk of the default `State` object for `ProgressState`."""
+        # Failsafe get_or_create() avoids attempt to get non-existant instance.
+        default, _ = cls.objects.get_or_create(name=cls.DEFAULT_STATE_NAME)
+        return default.id
+
+
+class TaskManager(WithSignalManagerMixin, models.Manager):
+    pass
+
+
+class TaskQueryset(WithSignalQuerysetMixin, models.QuerySet):
+    def non_workflow(self) -> "TaskQueryset":
+        """Return a queryset of standalone Task instances that are not part of a
+        workflow and are not subtasks."""
+        return self.filter(
+            models.Q(parent_task__isnull=True)
+            & models.Q(taskitem__isnull=True)
+            & models.Q(taskworkflow__isnull=True),
+        )
+
+    def workflow_summary(self) -> "TaskQueryset":
+        """
+        Return a queryset of summary Task instances of TaskWorkflows, i.e. those
+        with a non-null related_name=taskworkflow.
+
+        Summary Task instances are never subtasks.
+        """
+        return self.filter(
+            models.Q(taskworkflow__isnull=False),
+        )
+
+    def top_level(self) -> "TaskQueryset":
+        """
+        Return a queryset of Task instances that are not subtasks and are
+        either:
+        1. Stand-alone Task instances that are not part of a Workflow tasks
+        2. Workflow.summary_task instances.
+
+        The intent is to provide a top-level filtering of Task instances,
+        permitting a combined at-a-glance view of Tasks and Workflow instances.
+        """
+        return self.filter(
+            (models.Q(taskitem__isnull=True) | models.Q(taskworkflow__isnull=False))
+            & models.Q(parent_task__isnull=True),
+        )
+
+    def parents(self):
+        """Returns a queryset of tasks who do not have subtasks linked to
+        them."""
+        return self.filter(
+            models.Q(parent_task=None),
+        )
+
+    def subtasks(self):
+        """Returns a queryset of tasks who have parent tasks linked to them."""
+        return self.exclude(models.Q(parent_task=None))
+
+
+class TaskBase(TimestampedMixin):
+    """Abstract model mixin containing model fields common to TaskTemplate and
+    Task models."""
+
+    class Meta:
+        abstract = True
+
+    title = models.CharField(max_length=255)
+    description = models.TextField()
+    category = models.ForeignKey(
+        "Category",
+        blank=True,
+        null=True,
+        on_delete=models.PROTECT,
+    )
+
+
+class Task(TaskBase):
+    progress_state = models.ForeignKey(
+        ProgressState,
+        default=ProgressState.get_default_state_id,
+        on_delete=models.PROTECT,
+    )
+    parent_task = models.ForeignKey(
+        "self",
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE,
+        related_name="subtasks",
+    )
+    workbasket = models.ForeignKey(
+        WorkBasket,
+        blank=True,
+        null=True,
+        on_delete=models.PROTECT,
+        related_name="tasks",
+    )
+    creator = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        on_delete=models.PROTECT,
+        related_name="created_tasks",
+    )
+
+    objects = TaskManager.from_queryset(TaskQueryset)()
+
+    class Meta(TaskBase.Meta):
+        abstract = False
+        ordering = ["id"]
+
+    @property
+    @admin.display(boolean=True)
+    def is_subtask(self) -> bool:
+        return bool(self.parent_task)
+
+    @property
+    def is_summary_task(self) -> bool:
+        return hasattr(self, "taskworkflow")
+
+    def __str__(self):
+        return self.title
+
+    def get_url(self, action: str = "detail"):
+        if action == "detail":
+            return reverse("workflow:task-ui-detail", kwargs={"pk": self.pk})
+
+        return "#NOT-IMPLEMENTED"
+
+
+class Category(models.Model):
+    name = models.CharField(
+        max_length=255,
+        unique=True,
+    )
+
+    class Meta:
+        ordering = ["name"]
+        verbose_name_plural = "categories"
+
+    def __str__(self):
+        return self.name
+
+
+class TaskAssigneeManager(WithSignalManagerMixin, models.Manager):
+    pass
+
+
+class TaskAssigneeQueryset(WithSignalQuerysetMixin, models.QuerySet):
+    def assigned(self):
+        return self.exclude(unassigned_at__isnull=False)
+
+    def unassigned(self):
+        return self.exclude(unassigned_at__isnull=True)
+
+    def workbasket_workers(self):
+        return self.filter(
+            assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
+        )
+
+    def workbasket_reviewers(self):
+        return self.filter(
+            assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
+        )
+
+
+class TaskAssignee(TimestampedMixin):
+    class AssignmentType(models.TextChoices):
+        WORKBASKET_WORKER = "WORKBASKET_WORKER", "Workbasket worker"
+        WORKBASKET_REVIEWER = "WORKBASKET_REVIEWER", "Workbasket reviewer"
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.PROTECT,
+        related_name="assigned_to",
+    )
+    assignment_type = models.CharField(
+        choices=AssignmentType.choices,
+        max_length=50,
+    )
+    task = models.ForeignKey(
+        Task,
+        on_delete=models.CASCADE,
+        editable=False,
+        related_name="assignees",
+    )
+    unassigned_at = models.DateTimeField(
+        auto_now=False,
+        blank=True,
+        null=True,
+    )
+
+    objects = TaskAssigneeManager.from_queryset(TaskAssigneeQueryset)()
+
+    def __str__(self):
+        return (
+            f"User: {self.user} ({self.assignment_type}), " f"Task ID: {self.task.id}"
+        )
+
+    @property
+    def is_assigned(self):
+        return True if not self.unassigned_at else False
+
+    @classmethod
+    def unassign_user(cls, user, task, instigator):
+        from tasks.signals import set_current_instigator
+
+        try:
+            assignment = cls.objects.get(user=user, task=task)
+            if assignment.unassigned_at:
+                return False
+            set_current_instigator(instigator)
+            with transaction.atomic():
+                assignment.unassigned_at = make_aware(datetime.now())
+                assignment.save(update_fields=["unassigned_at"])
+            return True
+        except cls.DoesNotExist:
+            return False
+
+
+class Comment(TimestampedMixin):
+    author = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.PROTECT,
+        editable=False,
+        related_name="authored_comments",
+    )
+    content = models.TextField(
+        max_length=1000 * 5,  # Max words * average character word length.
+    )
+    task = models.ForeignKey(
+        Task,
+        on_delete=models.CASCADE,
+        editable=False,
+        related_name="comments",
+    )
diff --git a/tasks/models/workflow.py b/tasks/models/workflow.py
new file mode 100644
index 000000000..b0bb33c54
--- /dev/null
+++ b/tasks/models/workflow.py
@@ -0,0 +1,271 @@
+from django.conf import settings
+from django.db import models
+from django.db.transaction import atomic
+from django.urls import reverse
+
+from common.models import User
+from common.models.mixins import TimestampedMixin
+from tasks.models.queue import Queue
+from tasks.models.queue import QueueItem
+from tasks.models.task import Task
+from tasks.models.task import TaskBase
+
+# ----------------------
+# - Workflows and tasks.
+# ----------------------
+
+
+class TaskWorkflow(Queue):
+    """Workflow of ordered Tasks."""
+
+    summary_task = models.OneToOneField(
+        Task,
+        on_delete=models.PROTECT,
+    )
+    """Provides task-like filtering and display capabilities for this
+    workflow."""
+    creator_template = models.ForeignKey(
+        "tasks.TaskWorkflowTemplate",
+        null=True,
+        on_delete=models.SET_NULL,
+    )
+    """The template from which this workflow was created, if any."""
+
+    class Meta(Queue.Meta):
+        abstract = False
+        ordering = ["id"]
+        verbose_name = "workflow"
+
+    def __str__(self):
+        return self.title
+
+    @property
+    def title(self) -> str:
+        return self.summary_task.title
+
+    @property
+    def description(self) -> str:
+        return self.summary_task.description
+
+    def get_tasks(self) -> models.QuerySet:
+        """Get a QuerySet of the Tasks associated through their TaskItem
+        instances to this TaskWorkflow, ordered by the position of the
+        TaskItem."""
+        return Task.objects.filter(taskitem__workflow=self).order_by(
+            "taskitem__position",
+        )
+
+    def get_url(self, action: str = "detail"):
+        if action == "detail":
+            return reverse(
+                "workflow:task-workflow-ui-detail",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "edit":
+            return reverse(
+                "workflow:task-workflow-ui-update",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "delete":
+            return reverse(
+                "workflow:task-workflow-ui-delete",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "create":
+            return reverse(
+                "workflow:task-workflow-ui-create",
+            )
+        elif action == "list":
+            return reverse(
+                "workflow:task-workflow-ui-list",
+            )
+
+        return "#NOT-IMPLEMENTED"
+
+
+class TaskItem(QueueItem):
+    """Task item queue management for Task instances (these should always be
+    subtasks)."""
+
+    queue_field = "workflow"
+
+    workflow = models.ForeignKey(
+        TaskWorkflow,
+        related_name="workflow_items",
+        on_delete=models.CASCADE,
+    )
+    task = models.OneToOneField(
+        "tasks.Task",
+        on_delete=models.CASCADE,
+    )
+    """The Task instance managed by this TaskItem."""
+
+    class Meta(QueueItem.Meta):
+        abstract = False
+        ordering = ["workflow", "position"]
+
+
+# ----------------------------------------
+# - Template workflows and template tasks.
+# ----------------------------------------
+
+
+class TaskWorkflowTemplate(Queue, TimestampedMixin):
+    """Template used to create TaskWorkflow instance."""
+
+    title = models.CharField(
+        max_length=255,
+    )
+    """
+    A title name for the instance.
+
+    This isn't the same as the title assigned to a TaskWorkflow instance
+    generated from a template.
+    """
+    description = models.TextField(
+        blank=True,
+        help_text="Description of what this workflow template is used for. ",
+    )
+    """
+    Description of what the instance is used for.
+
+    This isn't the same as the description that may be applied to a TaskWorkflow
+    instance generated from a template.
+    """
+    creator = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        on_delete=models.PROTECT,
+        related_name="created_taskworkflowtemplates",
+    )
+
+    class Meta(Queue.Meta):
+        abstract = False
+        ordering = ["id"]
+        verbose_name = "workflow template"
+
+    def __str__(self):
+        return self.title
+
+    def get_task_templates(self) -> models.QuerySet:
+        """Get a QuerySet of the TaskTemplates associated through their
+        TaskItemTemplate instances to this TaskWorkflowTemplate, ordered by the
+        position of the TaskItemTemplate."""
+        return TaskTemplate.objects.filter(
+            taskitemtemplate__workflow_template=self,
+        ).order_by(
+            "taskitemtemplate__position",
+        )
+
+    @atomic
+    def create_task_workflow(
+        self,
+        title: str,
+        description: str,
+        creator: User,
+    ) -> "TaskWorkflow":
+        """Create a workflow and it subtasks, using values from this template
+        workflow and its task templates."""
+
+        summary_task = Task.objects.create(
+            title=title,
+            description=description,
+            creator=creator,
+        )
+        task_workflow = TaskWorkflow.objects.create(
+            summary_task=summary_task,
+            creator_template=self,
+        )
+
+        task_item_templates = TaskItemTemplate.objects.select_related(
+            "task_template",
+        ).filter(workflow_template=self)
+        for task_item_template in task_item_templates:
+            task_template = task_item_template.task_template
+            task = Task.objects.create(
+                title=task_template.title,
+                description=task_template.description,
+                category=task_template.category,
+            )
+            TaskItem.objects.create(
+                position=task_item_template.position,
+                workflow=task_workflow,
+                task=task,
+            )
+
+        return task_workflow
+
+    def get_url(self, action: str = "detail"):
+        if action == "detail":
+            return reverse(
+                "workflow:task-workflow-template-ui-detail",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "edit":
+            return reverse(
+                "workflow:task-workflow-template-ui-update",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "delete":
+            return reverse(
+                "workflow:task-workflow-template-ui-delete",
+                kwargs={"pk": self.pk},
+            )
+        elif action == "create":
+            return reverse(
+                "workflow:task-workflow-template-ui-create",
+            )
+        elif action == "list":
+            return reverse(
+                "workflow:task-workflow-template-ui-list",
+            )
+
+        return "#NOT-IMPLEMENTED"
+
+
+class TaskItemTemplate(QueueItem):
+    """Queue item management for TaskTemplate instances."""
+
+    queue_field = "workflow_template"
+
+    workflow_template = models.ForeignKey(
+        TaskWorkflowTemplate,
+        related_name="workflow_template_items",
+        on_delete=models.CASCADE,
+    )
+    task_template = models.OneToOneField(
+        "tasks.TaskTemplate",
+        on_delete=models.CASCADE,
+    )
+
+    class Meta(QueueItem.Meta):
+        abstract = False
+        ordering = ["workflow_template", "position"]
+
+
+class TaskTemplate(TaskBase):
+    """Template used to create Task instances from within a template
+    workflow."""
+
+    def get_url(self, action: str = "detail"):
+        if action == "detail":
+            return reverse("workflow:task-template-ui-detail", kwargs={"pk": self.pk})
+        elif action == "edit":
+            return reverse("workflow:task-template-ui-update", kwargs={"pk": self.pk})
+        elif action == "delete":
+            return reverse(
+                "workflow:task-template-ui-delete",
+                kwargs={
+                    "workflow_template_pk": self.taskitemtemplate.workflow_template.pk,
+                    "pk": self.pk,
+                },
+            )
+
+        return "#NOT-IMPLEMENTED"
+
+    class Meta(TaskBase.Meta):
+        abstract = False
+        ordering = ["id"]
+
+    def __str__(self):
+        return self.title
diff --git a/tasks/signals.py b/tasks/signals.py
new file mode 100644
index 000000000..af6392408
--- /dev/null
+++ b/tasks/signals.py
@@ -0,0 +1,67 @@
+import threading
+
+from django.db.models.signals import pre_save
+from django.dispatch import receiver
+
+from tasks.models import Task
+from tasks.models import TaskAssignee
+from tasks.models import TaskLog
+
+_thread_locals = threading.local()
+
+
+def get_current_instigator():
+    return getattr(_thread_locals, "instigator", None)
+
+
+def set_current_instigator(instigator):
+    _thread_locals.instigator = instigator
+
+
+@receiver(pre_save, sender=Task)
+def create_tasklog_for_task_update(sender, instance, old_instance=None, **kwargs):
+    """
+    Creates a `TaskLog` entry when a `Task` is being updated and the update
+    action is a `TaskLog.AuditActionType`.
+
+    Note that this signal is triggered before the `Task` instance is saved.
+    """
+    if instance._state.adding:
+        return
+
+    old_instance = old_instance or Task.objects.get(pk=instance.pk)
+
+    if instance.progress_state != old_instance.progress_state:
+        TaskLog.objects.create(
+            task=instance,
+            action=TaskLog.AuditActionType.PROGRESS_STATE_UPDATED,
+            instigator=get_current_instigator(),
+            progress_state=instance.progress_state,
+        )
+
+
+@receiver(pre_save, sender=TaskAssignee)
+def create_tasklog_for_task_assignee(sender, instance, old_instance=None, **kwargs):
+    """
+    Creates a `TaskLog` entry when a user is assigned to or unassigned from a
+    `Task`.
+
+    Note that this signal is triggered before the `TaskAssignee` instance is saved.
+    """
+    if instance._state.adding:
+        return TaskLog.objects.create(
+            task=instance.task,
+            action=TaskLog.AuditActionType.TASK_ASSIGNED,
+            instigator=get_current_instigator(),
+            assignee=instance.user,
+        )
+
+    old_instance = old_instance or TaskAssignee.objects.get(pk=instance.pk)
+
+    if instance.unassigned_at and instance.unassigned_at != old_instance.unassigned_at:
+        return TaskLog.objects.create(
+            task=instance.task,
+            action=TaskLog.AuditActionType.TASK_UNASSIGNED,
+            instigator=get_current_instigator(),
+            assignee=old_instance.user,
+        )
diff --git a/tasks/static/tasks/scss/_tasks.scss b/tasks/static/tasks/scss/_tasks.scss
new file mode 100644
index 000000000..c86541eec
--- /dev/null
+++ b/tasks/static/tasks/scss/_tasks.scss
@@ -0,0 +1,38 @@
+// Source: https://design-system.service.gov.uk/components/task-list/
+
+.govuk-task-list {
+  @include govuk-font($size: 19);
+  margin-top: 0;
+  @include govuk-responsive-margin(6, "bottom");
+  padding: 0;
+  list-style-type: none;
+}
+
+.govuk-task-list__item {
+  display: table;
+  position: relative;
+  width: 100%;
+  margin-bottom: 0;
+  padding-top: govuk-spacing(2);
+  padding-bottom: govuk-spacing(2);
+  border-bottom: 1px solid $govuk-border-colour;
+}
+
+.govuk-task-list__item:first-child {
+  border-top: 1px solid $govuk-border-colour;
+}
+
+.govuk-task-list__item--with-link:hover {
+  background: govuk-colour("light-grey");
+}
+
+.govuk-task-list__name-and-hint {
+  display: table-cell;
+  vertical-align: top;
+  @include govuk-text-colour;
+}
+
+.govuk-task-list__hint {
+  margin-top: govuk-spacing(1);
+  color: $govuk-secondary-text-colour;
+}
diff --git a/tasks/tests/conftest.py b/tasks/tests/conftest.py
index 47808d0c2..c56a17eff 100644
--- a/tasks/tests/conftest.py
+++ b/tasks/tests/conftest.py
@@ -1,8 +1,18 @@
 import pytest
 
+from common.tests.factories import CategoryFactory
+from common.tests.factories import ProgressStateFactory
+from common.tests.factories import SubTaskFactory
+from common.tests.factories import TaskAssigneeFactory
 from common.tests.factories import TaskFactory
-from common.tests.factories import UserAssignmentFactory
-from tasks.models import UserAssignment
+from tasks.models import Task
+from tasks.models import TaskAssignee
+from tasks.models import TaskItem
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+from tasks.tests import factories
 
 
 @pytest.fixture()
@@ -11,19 +21,136 @@ def task():
 
 
 @pytest.fixture()
-def user_assignment():
-    return UserAssignmentFactory.create()
+def subtask():
+    return SubTaskFactory.create()
 
 
 @pytest.fixture()
-def workbasket_worker_assignment():
-    return UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+def category():
+    return CategoryFactory.create()
+
+
+@pytest.fixture()
+def progress_state():
+    return ProgressStateFactory.create()
+
+
+@pytest.fixture()
+def task_assignee():
+    return TaskAssigneeFactory.create()
+
+
+@pytest.fixture()
+def workbasket_worker_assignee():
+    return TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
+    )
+
+
+@pytest.fixture()
+def workbasket_reviewer_assignee():
+    return TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
+    )
+
+
+@pytest.fixture()
+def task_workflow_template() -> TaskWorkflowTemplate:
+    """Return an empty TaskWorkflowTemplate instance (containing no items)."""
+    return factories.TaskWorkflowTemplateFactory.create()
+
+
+@pytest.fixture()
+def task_workflow_template_single_task_template_item(
+    task_workflow_template,
+) -> TaskWorkflowTemplate:
+    """Return a TaskWorkflowTemplate instance containing a single
+    TaskTemplateItem instance."""
+
+    task_template = factories.TaskTemplateFactory.create()
+    factories.TaskItemTemplateFactory.create(
+        workflow_template=task_workflow_template,
+        task_template=task_template,
+    )
+
+    assert task_workflow_template.get_items().count() == 1
+
+    return task_workflow_template
+
+
+@pytest.fixture()
+def task_workflow_template_three_task_template_items(
+    task_workflow_template,
+) -> TaskWorkflowTemplate:
+    """Return a TaskWorkflowTemplate instance containing three TaskItemTemplate
+    and related TaskTemplates."""
+
+    task_item_templates = []
+    for _ in range(3):
+        task_template = factories.TaskTemplateFactory.create()
+        task_item_template = factories.TaskItemTemplateFactory.create(
+            workflow_template=task_workflow_template,
+            task_template=task_template,
+        )
+        task_item_templates.append(task_item_template)
+
+    assert task_workflow_template.get_items().count() == 3
+    assert (
+        TaskItemTemplate.objects.filter(
+            workflow_template=task_workflow_template,
+        ).count()
+        == 3
     )
+    assert (
+        TaskTemplate.objects.filter(
+            taskitemtemplate__in=task_item_templates,
+        ).count()
+        == 3
+    )
+
+    return task_workflow_template
+
+
+@pytest.fixture()
+def task_workflow() -> TaskWorkflow:
+    """Return an empty TaskWorkflow instance (containing no items)."""
+    return factories.TaskWorkflowFactory.create()
 
 
 @pytest.fixture()
-def workbasket_reviewer_assignment():
-    return UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+def task_workflow_single_task_item(task_workflow) -> TaskWorkflow:
+    """Return a TaskWorkflow instance containing a single TaskItem instance with
+    associated Task instance."""
+
+    task_item = factories.TaskItemFactory.create(
+        workflow=task_workflow,
     )
+
+    assert task_workflow.get_items().count() == 1
+    assert task_workflow.get_items().get() == task_item
+
+    return task_workflow
+
+
+@pytest.fixture()
+def task_workflow_three_task_items(
+    task_workflow,
+) -> TaskWorkflow:
+    """Return a TaskWorkflow instance containing three TaskItems and related
+    Tasks."""
+
+    expected_count = 3
+
+    task_items = factories.TaskItemFactory.create_batch(
+        expected_count,
+        workflow=task_workflow,
+    )
+
+    assert task_workflow.get_items().count() == expected_count
+    assert TaskItem.objects.filter(workflow=task_workflow).count() == expected_count
+    assert (
+        Task.objects.filter(taskitem__in=[item.pk for item in task_items]).count()
+        == expected_count
+    )
+
+    return task_workflow
diff --git a/tasks/tests/factories.py b/tasks/tests/factories.py
new file mode 100644
index 000000000..95d66f29a
--- /dev/null
+++ b/tasks/tests/factories.py
@@ -0,0 +1,61 @@
+import factory
+from factory import SubFactory
+from factory.django import DjangoModelFactory
+
+from common.tests.factories import CategoryFactory
+from common.tests.factories import TaskFactory
+from tasks.models import TaskItem
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+
+
+class TaskWorkflowTemplateFactory(DjangoModelFactory):
+    """Factory to create TaskWorkflowTemplate instances."""
+
+    title = factory.Faker("sentence")
+    description = factory.Faker("sentence")
+
+    class Meta:
+        model = TaskWorkflowTemplate
+
+
+class TaskTemplateFactory(DjangoModelFactory):
+    """Factory to create TaskTemplate instances."""
+
+    title = factory.Faker("sentence")
+    description = factory.Faker("sentence")
+    category = factory.SubFactory(CategoryFactory)
+
+    class Meta:
+        model = TaskTemplate
+
+
+class TaskItemTemplateFactory(DjangoModelFactory):
+    """Factory to create TaskItemTemplate instances."""
+
+    class Meta:
+        model = TaskItemTemplate
+
+    workflow_template = SubFactory(TaskWorkflowTemplateFactory)
+    task_template = SubFactory(TaskTemplateFactory)
+
+
+class TaskWorkflowFactory(DjangoModelFactory):
+    """Factory to create TaskWorkflow instances."""
+
+    class Meta:
+        model = TaskWorkflow
+
+    summary_task = SubFactory(TaskFactory)
+
+
+class TaskItemFactory(DjangoModelFactory):
+    """Factory to create TaskItem instances."""
+
+    class Meta:
+        model = TaskItem
+
+    workflow = SubFactory(TaskWorkflowFactory)
+    task = SubFactory(TaskFactory)
diff --git a/tasks/tests/test_forms.py b/tasks/tests/test_forms.py
new file mode 100644
index 000000000..b4e7972f8
--- /dev/null
+++ b/tasks/tests/test_forms.py
@@ -0,0 +1,118 @@
+import pytest
+
+from common.tests.factories import ProgressStateFactory
+from common.tests.factories import TaskFactory
+from tasks import forms
+from tasks.models import ProgressState
+
+pytestmark = pytest.mark.django_db
+
+
+def test_create_subtask_assigns_correct_parent_task(valid_user):
+    """Tests that SubtaskCreateForm assigns the correct parent on form.save."""
+    parent_task_instance = TaskFactory.create()
+    progress_state = ProgressStateFactory.create(
+        name=ProgressState.State.IN_PROGRESS,
+    )
+
+    subtask_form_data = {
+        "progress_state": progress_state.pk,
+        "title": "subtask test title",
+        "description": "subtask test description",
+    }
+    form = forms.SubTaskCreateForm(data=subtask_form_data)
+    new_subtask = form.save(parent_task_instance, user=valid_user)
+
+    assert new_subtask.parent_task.pk == parent_task_instance.pk
+
+
+@pytest.mark.parametrize(
+    "form_data",
+    [
+        {
+            "title": "Test workflow 1",
+            "description": "Workflow created without using template",
+            "create_type": forms.TaskWorkflowCreateForm.CreateType.WITHOUT_TEMPLATE,
+        },
+        {
+            "title": "Test workflow 2",
+            "description": "Workflow created using template",
+            "create_type": forms.TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE,
+            "workflow_template": "",
+        },
+    ],
+    ids=(
+        "without_template",
+        "with_template",
+    ),
+)
+def test_workflow_create_form_valid_data(form_data, task_workflow_template):
+    """Tests that `TaskWorkflowCreateForm` returns expected cleaned_data given
+    valid form data."""
+
+    if "workflow_template" in form_data:
+        form_data["workflow_template"] = task_workflow_template
+
+    form = forms.TaskWorkflowCreateForm(form_data)
+    assert form.is_valid()
+    assert form.cleaned_data == form_data
+
+
+@pytest.mark.parametrize(
+    ("form_data", "field", "error_message"),
+    [
+        ({"title": ""}, "title", "Enter a title for the workflow"),
+        ({"description": ""}, "description", "Enter a description for the workflow"),
+        (
+            {"create_type": ""},
+            "create_type",
+            "Select if you want to use a workflow template",
+        ),
+        (
+            {
+                "create_type": forms.TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE,
+                "workflow_template": "",
+            },
+            "create_type",
+            "Select a workflow template",
+        ),
+        (
+            {
+                "create_type": forms.TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE,
+                "workflow_template": "invalidchoice",
+            },
+            "create_type",
+            "Select a valid choice. That choice is not one of the available choices.",
+        ),
+    ],
+    ids=(
+        "missing_title",
+        "missing_description",
+        "missing_create_type",
+        "missing_workflow_template",
+        "invalid_workflow_template",
+    ),
+)
+def test_workflow_create_form_invalid_data(form_data, field, error_message):
+    """Tests that `TaskWorkflowCreateForm` raises expected form errors given
+    invalid form data."""
+
+    form = forms.TaskWorkflowCreateForm(form_data)
+    assert not form.is_valid()
+    assert error_message in form.errors[field]
+
+
+def test_workflow_update_form_save(task_workflow):
+    """Tests that the details of `TaskWorkflow.summary_task` are updated when
+    calling form.save()."""
+    form_data = {
+        "title": "Updated workflow title",
+        "description": "Updated workflow description",
+    }
+
+    form = forms.TaskWorkflowUpdateForm(data=form_data, instance=task_workflow)
+    assert form.is_valid()
+
+    workflow = form.save()
+    assert workflow.summary_task.title == form_data["title"]
+    assert workflow.summary_task.description == form_data["description"]
diff --git a/tasks/tests/test_models.py b/tasks/tests/test_models.py
index cb7259218..ecf4c0fb9 100644
--- a/tasks/tests/test_models.py
+++ b/tasks/tests/test_models.py
@@ -1,58 +1,228 @@
 import pytest
-
-from tasks.models import UserAssignment
+from django.db.utils import IntegrityError
+
+from common.tests.factories import CategoryFactory
+from common.tests.factories import ProgressStateFactory
+from common.tests.factories import SubTaskFactory
+from common.tests.factories import TaskFactory
+from tasks.models import ProgressState
+from tasks.models import Task
+from tasks.models import TaskAssignee
+from tasks.models import TaskLog
+from tasks.tests.factories import TaskWorkflowFactory
 
 pytestmark = pytest.mark.django_db
 
 
-def test_user_assignment_unassign_user_classmethod(user_assignment):
-    user = user_assignment.user
-    task = user_assignment.task
+def test_task_category_uniqueness():
+    name = "Most favoured nation"
+    CategoryFactory.create(name=name)
+    with pytest.raises(IntegrityError):
+        CategoryFactory.create(name=name)
+
+
+def test_task_progress_state_uniqueness():
+    name = "Blocked"
+    ProgressState.objects.create(name=name)
+    with pytest.raises(IntegrityError):
+        ProgressState.objects.create(name=name)
 
-    assert UserAssignment.unassign_user(user=user, task=task)
+
+def test_task_assignee_unassign_user_classmethod(task_assignee):
+    user = task_assignee.user
+    task = task_assignee.task
+
+    assert TaskAssignee.unassign_user(user=user, task=task, instigator=user)
     # User has already been unassigned
-    assert not UserAssignment.unassign_user(user=user, task=task)
+    assert not TaskAssignee.unassign_user(user=user, task=task, instigator=user)
 
 
-def test_user_assignment_assigned_queryset(
-    user_assignment,
+def test_task_assignee_assigned_queryset(
+    task_assignee,
 ):
-    assert UserAssignment.objects.assigned().count() == 1
+    assert TaskAssignee.objects.assigned().count() == 1
 
-    user = user_assignment.user
-    task = user_assignment.task
-    UserAssignment.unassign_user(user=user, task=task)
+    user = task_assignee.user
+    task = task_assignee.task
+    TaskAssignee.unassign_user(user=user, task=task, instigator=user)
 
-    assert not UserAssignment.objects.assigned()
+    assert not TaskAssignee.objects.assigned()
 
 
-def test_user_assignment_unassigned_queryset(
-    user_assignment,
+def test_task_assignee_unassigned_queryset(
+    task_assignee,
 ):
-    assert not UserAssignment.objects.unassigned()
+    assert not TaskAssignee.objects.unassigned()
 
-    user = user_assignment.user
-    task = user_assignment.task
-    UserAssignment.unassign_user(user=user, task=task)
+    user = task_assignee.user
+    task = task_assignee.task
+    TaskAssignee.unassign_user(user=user, task=task, instigator=user)
 
-    assert UserAssignment.objects.unassigned().count() == 1
+    assert TaskAssignee.objects.unassigned().count() == 1
 
 
-def test_user_assignment_workbasket_workers_queryset(
-    workbasket_worker_assignment,
-    workbasket_reviewer_assignment,
+def test_task_assignee_workbasket_workers_queryset(
+    workbasket_worker_assignee,
+    workbasket_reviewer_assignee,
 ):
-    workbasket_workers = UserAssignment.objects.workbasket_workers()
+    workbasket_workers = TaskAssignee.objects.workbasket_workers()
 
     assert workbasket_workers.count() == 1
-    assert workbasket_worker_assignment in workbasket_workers
+    assert workbasket_worker_assignee in workbasket_workers
 
 
-def test_user_assignment_workbasket_reviewers_queryset(
-    workbasket_worker_assignment,
-    workbasket_reviewer_assignment,
+def test_task_assignee_workbasket_reviewers_queryset(
+    workbasket_worker_assignee,
+    workbasket_reviewer_assignee,
 ):
-    workbasket_reviewers = UserAssignment.objects.workbasket_reviewers()
+    workbasket_reviewers = TaskAssignee.objects.workbasket_reviewers()
 
     assert workbasket_reviewers.count() == 1
-    assert workbasket_reviewer_assignment in workbasket_reviewers
+    assert workbasket_reviewer_assignee in workbasket_reviewers
+
+
+def test_non_workflow_queryset(task, task_workflow_single_task_item):
+    """Test correct behaviour of TaskQueryset.non_workflow()."""
+
+    SubTaskFactory(parent_task=task)
+    SubTaskFactory(parent_task=task_workflow_single_task_item.get_tasks().get())
+
+    non_workflow_tasks = Task.objects.non_workflow()
+
+    # 1 x standalone task + 1 summary task + 1 x workflow task + 2 x subtasks
+    assert Task.objects.count() == 5
+    assert non_workflow_tasks.get() == task
+
+
+def test_workflow_summary_queryset(task, task_workflow_single_task_item):
+    """Test correct behaviour of TaskQueryset.workflow_summary()."""
+
+    """Return a queryset of TaskWorkflow summary Task instances, i.e. those
+    with a non-null related_name=taskworkflow."""
+
+    SubTaskFactory(parent_task=task)
+    SubTaskFactory(parent_task=task_workflow_single_task_item.get_tasks().get())
+
+    workflow_summary_tasks = Task.objects.workflow_summary()
+
+    # 1 x standalone task + 1 summary task + 1 x workflow task + 2 x subtasks
+    assert Task.objects.count() == 5
+    assert workflow_summary_tasks.get() == task_workflow_single_task_item.summary_task
+
+
+def test_top_level_task_queryset(task, task_workflow_single_task_item):
+    """Test correct behaviour of TaskQueryset.top_level()."""
+
+    SubTaskFactory(parent_task=task)
+    SubTaskFactory(parent_task=task_workflow_single_task_item.get_tasks().get())
+
+    top_level_tasks = Task.objects.top_level()
+
+    # 1 x standalone task + 1 summary task + 1 x workflow task + 2 x subtasks
+    assert Task.objects.count() == 5
+    assert top_level_tasks.count() == 2
+    assert task_workflow_single_task_item.summary_task in top_level_tasks
+    assert task in top_level_tasks
+    assert task_workflow_single_task_item.get_tasks().get() not in top_level_tasks
+
+
+def test_create_task_log_task_assigned():
+    task = TaskFactory.create()
+    instigator = task.creator
+    action = TaskLog.AuditActionType.TASK_ASSIGNED
+    task_log = TaskLog.objects.create(
+        task=task,
+        action=action,
+        instigator=instigator,
+        assignee=instigator,
+    )
+
+    assert task_log.task == task
+    assert task_log.instigator == instigator
+    assert task_log.action == action
+    assert task_log.description == f"{instigator} assigned {instigator}"
+
+
+def test_create_task_log_task_unassigned():
+    task = TaskFactory.create()
+    instigator = task.creator
+    action = TaskLog.AuditActionType.TASK_UNASSIGNED
+    task_log = TaskLog.objects.create(
+        task=task,
+        action=action,
+        instigator=instigator,
+        assignee=instigator,
+    )
+
+    assert task_log.task == task
+    assert task_log.instigator == instigator
+    assert task_log.action == action
+    assert task_log.description == f"{instigator} unassigned {instigator}"
+
+
+def test_create_task_log_progress_state_updated():
+    task = TaskFactory.create()
+    instigator = task.creator
+    action = TaskLog.AuditActionType.PROGRESS_STATE_UPDATED
+    progress_state = ProgressStateFactory.create()
+    task_log = TaskLog.objects.create(
+        task=task,
+        action=action,
+        instigator=instigator,
+        progress_state=progress_state,
+    )
+
+    assert task_log.task == task
+    assert task_log.instigator == instigator
+    assert task_log.action == action
+    assert (
+        task_log.description == f"{instigator} changed the status to {progress_state}"
+    )
+
+
+def test_create_task_log_invalid_audit_action():
+    task = TaskFactory.create()
+    instigator = task.creator
+    action = "INVALID_AUDIT_ACTION"
+
+    with pytest.raises(ValueError) as error:
+        TaskLog.objects.create(task=task, action=action, instigator=instigator)
+    assert f"The action '{action}' is an invalid TaskLog.AuditActionType value." in str(
+        error,
+    )
+
+
+def test_create_task_log_missing_kwargs():
+    task = TaskFactory.create()
+    instigator = task.creator
+    action = TaskLog.AuditActionType.TASK_ASSIGNED
+
+    with pytest.raises(ValueError) as error:
+        TaskLog.objects.create(task=task, action=action, instigator=instigator)
+    assert f"Missing 'assignee' in kwargs for action '{action}'." in str(
+        error,
+    )
+
+
+@pytest.mark.parametrize(
+    ("task_factory"),
+    [TaskFactory, SubTaskFactory],
+    ids=("task test", "subtask test"),
+)
+def test_task_is_subtask_property(task_factory):
+    task = task_factory.create()
+
+    assert bool(task.parent_task) == task.is_subtask
+
+
+@pytest.mark.parametrize(
+    ("create_task_fn"),
+    (
+        lambda: TaskFactory.create(),
+        lambda: TaskWorkflowFactory.create().summary_task,
+    ),
+    ids=("standalone task test", "summary task test"),
+)
+def test_task_is_summary_task_property(create_task_fn):
+    task = create_task_fn()
+    assert bool(hasattr(task, "taskworkflow")) == task.is_summary_task
diff --git a/tasks/tests/test_queue/__init__.py b/tasks/tests/test_queue/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tasks/tests/test_queue/models.py b/tasks/tests/test_queue/models.py
new file mode 100644
index 000000000..1e53ca973
--- /dev/null
+++ b/tasks/tests/test_queue/models.py
@@ -0,0 +1,24 @@
+from django.db import models
+
+from tasks.models import Queue
+from tasks.models import QueueItem
+
+
+class TestQueue(Queue):
+    """Concrete subclass of Queue."""
+
+    class Meta:
+        abstract = False
+
+
+class TestQueueItem(QueueItem):
+    """Concrete subclass of QueueItem."""
+
+    class Meta:
+        abstract = False
+
+    queue = models.ForeignKey(
+        TestQueue,
+        related_name="queue_items",
+        on_delete=models.CASCADE,
+    )
diff --git a/tasks/tests/test_queue_models.py b/tasks/tests/test_queue_models.py
new file mode 100644
index 000000000..0021fe2d3
--- /dev/null
+++ b/tasks/tests/test_queue_models.py
@@ -0,0 +1,395 @@
+import threading
+from functools import wraps
+
+import pytest
+from django.db import OperationalError
+from django.db.models import CASCADE
+from django.db.models import ForeignKey
+from django.db.models import QuerySet
+from factory import SubFactory
+from factory.django import DjangoModelFactory
+
+from tasks.models import QueueItem
+from tasks.models import RequiredFieldError
+from tasks.tests.test_queue.models import TestQueue
+from tasks.tests.test_queue.models import TestQueueItem
+
+pytestmark = pytest.mark.django_db
+
+
+class TestQueueFactory(DjangoModelFactory):
+    """Factory for TestQueue."""
+
+    class Meta:
+        abstract = False
+        model = TestQueue
+
+
+class TestQueueItemFactory(DjangoModelFactory):
+    """Factory for TestQueueItem."""
+
+    class Meta:
+        model = TestQueueItem
+        abstract = False
+
+    queue = SubFactory(TestQueueFactory)
+
+
+@pytest.fixture()
+def queue() -> TestQueue:
+    """Return an instance of TestQueue that contains no TestQueueItems."""
+    queue = TestQueueFactory.create()
+
+    assert not queue.get_items().exists()
+
+    return queue
+
+
+@pytest.fixture()
+def single_item_queue(queue) -> TestQueue:
+    """Return an instance of TestQueue containing a single TestQueueItem."""
+    TestQueueItemFactory.create(queue=queue)
+
+    assert queue.get_items().count() == 1
+
+    return queue
+
+
+@pytest.fixture()
+def three_item_queue(queue) -> TestQueue:
+    """Return an instance of TestQueue containing three TestQueueItem
+    instances."""
+    TestQueueItemFactory.create(queue=queue)
+    TestQueueItemFactory.create(queue=queue)
+    TestQueueItemFactory.create(queue=queue)
+
+    assert queue.get_items().count() == 3
+
+    return queue
+
+
+def test_queueitem_metaclass_validation_missing_queue_field():
+    """Tests that a concrete sublass of `QueueItem` must provide a queue field
+    on the model."""
+    with pytest.raises(RequiredFieldError) as error:
+
+        class TestQueueItemSubclass(QueueItem):
+            class Meta:
+                abstract = False
+
+        TestQueueItemSubclass()
+
+    assert (
+        "must have a 'queue' ForeignKey field. The name of the field must match the value given to the 'queue_field' attribute on the model."
+        in str(error.value)
+    )
+
+
+def test_queueitem_metaclass_validation_mismatched_queue_field():
+    """Tests that the `QueueItem.queue_field` attribute on a concrete subclass
+    must match its queue ForeignKey field."""
+    with pytest.raises(RequiredFieldError) as error:
+
+        class TestQueueItemSubclass(QueueItem):
+            class Meta:
+                abstract = False
+
+            queue_field = "test_queue"
+            queue = ForeignKey(TestQueue, on_delete=CASCADE)
+
+        TestQueueItemSubclass()
+
+    assert (
+        "The name of the field must match the value given to the 'queue_field' attribute on the model."
+        in str(error.value)
+    )
+
+
+def test_queueitem_metaclass_validation_invalid_model():
+    """Tests that a concrete subclass of `QueueItem` must have a ForeignKey
+    field to a subclass of `Queue`."""
+    with pytest.raises(RequiredFieldError) as error:
+
+        class TestQueueItemSubclass(QueueItem):
+            class Meta:
+                abstract = False
+
+            queue_field = "test_queue"
+            test_queue = ForeignKey(QueueItem, on_delete=CASCADE)
+
+        TestQueueItemSubclass()
+
+    assert "must be a ForeignKey field to a subclass of 'Queue' model" in str(
+        error.value,
+    )
+
+
+def test_empty_queue(queue):
+    assert queue.max_position == 0
+    assert queue.get_first() == None
+    assert queue.get_item(1) == None
+    assert queue.get_last() == None
+
+
+def test_non_empty_queue(queue):
+    first_item = TestQueueItemFactory.create(queue=queue)
+    second_item = TestQueueItemFactory.create(queue=queue)
+    third_item = TestQueueItemFactory.create(queue=queue)
+
+    assert first_item.position == 1
+    assert second_item.position == 2
+    assert third_item.position == 3
+    assert {first_item, second_item, third_item} == set(queue.get_items())
+    assert queue.max_position == 3
+    assert queue.get_items().count() == 3
+    assert queue.get_first() == first_item
+    assert queue.get_last() == third_item
+    assert queue.get_item(2) == second_item
+
+
+def test_item_delete(three_item_queue):
+    three_item_queue.get_first().delete()
+
+    assert three_item_queue.get_items().count() == 2
+
+    three_item_queue.get_item(1).delete()
+    three_item_queue.get_last().delete()
+
+    assert three_item_queue.get_items().count() == 0
+
+
+def test_item_promote(three_item_queue):
+    item = three_item_queue.get_last()
+
+    assert item.position == 3
+
+    item = item.promote()
+    item = item.promote()
+
+    assert item.position == 1
+
+    item = item.promote()
+
+    assert item.position == 1
+
+
+def test_item_demote(three_item_queue):
+    item = three_item_queue.get_first()
+
+    assert item.position == 1
+
+    item = item.demote()
+    item = item.demote()
+
+    assert item.position == 3
+
+    item = item.demote()
+
+    assert item.position == 3
+
+
+def test_item_demote_to_last(three_item_queue):
+    item = three_item_queue.get_first()
+
+    assert item.position == 1
+
+    item = item.demote_to_last()
+
+    assert item.position == 3
+
+    item = item.demote_to_last()
+
+    assert item.position == 3
+
+
+def test_item_promote_to_first(three_item_queue):
+    item = three_item_queue.get_last()
+
+    assert item.position == 3
+
+    item = item.promote_to_first()
+
+    assert item.position == 1
+
+    item = item.promote_to_first()
+
+    assert item.position == 1
+
+
+@pytest.mark.django_db(transaction=True)
+class TestQueueRaceConditions:
+    """Tests that concurrent requests to reorder queue items don't result in
+    duplicate or non-consecutive positions."""
+
+    NUM_THREADS: int = 2
+    """The number of threads each test uses."""
+
+    THREAD_TIMEOUT: int = 5
+    """The duration in seconds to wait for a thread to complete before timing
+    out."""
+
+    NUM_QUEUE_ITEMS: int = 5
+    """The number of queue items to create for each test."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self, queue):
+        """Initialises a barrier to synchronise threads and creates queue items
+        anew for each test."""
+
+        self.unexpected_exceptions: list[Exception] = []
+
+        self.barrier: threading.Barrier = threading.Barrier(
+            parties=self.NUM_THREADS,
+            timeout=self.THREAD_TIMEOUT,
+        )
+
+        self.queue: TestQueue = queue
+        self.queue_items: QuerySet[TestQueueItem] = TestQueueItemFactory.create_batch(
+            self.NUM_QUEUE_ITEMS,
+            queue=queue,
+        )
+
+    def assert_no_unexpected_exceptions(self):
+        """Asserts that no threads raised an unexpected exception."""
+        assert (
+            not self.unexpected_exceptions
+        ), f"Unexpected exception(s) raised: {self.unexpected_exceptions}"
+
+    def assert_expected_positions(self):
+        """Asserts that queue item positions remain both unique and in
+        consecutive sequence."""
+        positions = list(
+            TestQueueItem.objects.filter(
+                queue=self.queue,
+            )
+            .order_by("position")
+            .values_list("position", flat=True),
+        )
+
+        assert len(set(positions)) == len(positions), "Duplicate positions found!"
+
+        assert positions == list(
+            range(min(positions), max(positions) + 1),
+        ), "Non-consecutive positions found!"
+
+    def synchronised(func):
+        """
+        Decorator that ensures all threads wait until they can call their target
+        function in a synchronised fashion.
+
+        Any unexpected exceptions raised during the execution of the decorated
+        function are stored for the individual test to re-raise.
+        """
+
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            try:
+                self.barrier.wait()
+                func(self, *args, **kwargs)
+            except OperationalError:
+                # A conflicting lock is already acquired
+                pass
+            except Exception as error:
+                self.unexpected_exceptions.append(error)
+
+        return wrapper
+
+    @synchronised
+    def synchronised_call(
+        self,
+        method_name: str,
+        queue_item: TestQueueItem,
+    ):
+        """
+        Thread-synchronised wrapper for the following `QueueItem` instance
+        methods:
+
+        - delete
+        - promote
+        - demote
+        - promote_to_first
+        - demote_to_last
+        """
+        getattr(queue_item, method_name)()
+
+    @synchronised
+    def synchronised_create_queue_item(self):
+        """Thread-synchronised wrapper to create a new queue item instance."""
+        TestQueueItemFactory.create(queue=self.queue)
+
+    def execute_threads(self, threads: list[threading.Thread]):
+        """Starts a list of threads and waits for them to complete or
+        timeout."""
+        for thread in threads:
+            thread.start()
+
+        for thread in threads:
+            thread.join(timeout=self.THREAD_TIMEOUT)
+            if thread.is_alive():
+                raise RuntimeError(f"Thread {thread.name} timed out.")
+
+    def test_demote_and_promote_queue_items(self):
+        """Demotes and promotes the same queue item."""
+        thread1 = threading.Thread(
+            target=self.synchronised_call,
+            kwargs={
+                "method_name": "demote",
+                "queue_item": self.queue_items[2],
+            },
+            name="DemoteItemThread1",
+        )
+        thread2 = threading.Thread(
+            target=self.synchronised_call,
+            kwargs={
+                "method_name": "promote",
+                "queue_item": self.queue_items[2],
+            },
+            name="PromoteItemThread2",
+        )
+
+        self.execute_threads([thread1, thread2])
+        self.assert_no_unexpected_exceptions()
+        self.assert_expected_positions()
+
+    def test_delete_and_create_queue_items(self):
+        """Deletes the first item while creating a new one."""
+        thread1 = threading.Thread(
+            target=self.synchronised_call,
+            kwargs={
+                "method_name": "delete",
+                "queue_item": self.queue_items[0],
+            },
+            name="DeleteItemThread1",
+        )
+        thread2 = threading.Thread(
+            target=self.synchronised_create_queue_item,
+            name="CreateItemThread2",
+        )
+
+        self.execute_threads([thread1, thread2])
+        self.assert_no_unexpected_exceptions()
+        self.assert_expected_positions()
+
+    def test_promote_and_promote_to_first_queue_items(self):
+        """Promotes to first the last-placed item while promoting the one before
+        it."""
+        thread1 = threading.Thread(
+            target=self.synchronised_call,
+            kwargs={
+                "method_name": "promote_to_first",
+                "queue_item": self.queue_items[4],
+            },
+            name="PromoteItemToFirstThread1",
+        )
+        thread2 = threading.Thread(
+            target=self.synchronised_call,
+            kwargs={
+                "method_name": "promote",
+                "queue_item": self.queue_items[3],
+            },
+            name="PromoteItemThread2",
+        )
+
+        self.execute_threads([thread1, thread2])
+        self.assert_no_unexpected_exceptions()
+        self.assert_expected_positions()
diff --git a/tasks/tests/test_views.py b/tasks/tests/test_views.py
new file mode 100644
index 000000000..6a1a77155
--- /dev/null
+++ b/tasks/tests/test_views.py
@@ -0,0 +1,817 @@
+import factory
+import pytest
+from bs4 import BeautifulSoup
+from django.urls import reverse
+
+import settings
+from common.tests.factories import ProgressStateFactory
+from common.tests.factories import SubTaskFactory
+from common.tests.factories import TaskFactory
+from tasks.forms import TaskWorkflowCreateForm
+from tasks.models import ProgressState
+from tasks.models import Task
+from tasks.models import TaskItem
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskLog
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+from tasks.tests.factories import TaskItemTemplateFactory
+from tasks.tests.factories import TaskWorkflowTemplateFactory
+
+pytestmark = pytest.mark.django_db
+
+pytestmark = pytest.mark.django_db
+
+
+def test_task_update_view_update_progress_state(valid_user_client):
+    """Tests that `TaskUpdateView` updates `Task.progress_state` and that a
+    related `TaskLog` entry is also created."""
+    instance = TaskFactory.create(progress_state__name=ProgressState.State.TO_DO)
+    new_progress_state = ProgressStateFactory.create(
+        name=ProgressState.State.IN_PROGRESS,
+    )
+    form_data = {
+        "progress_state": new_progress_state.pk,
+        "title": instance.title,
+        "description": instance.description,
+    }
+    url = reverse(
+        "workflow:task-ui-update",
+        kwargs={"pk": instance.pk},
+    )
+    response = valid_user_client.post(url, form_data)
+    assert response.status_code == 302
+
+    instance.refresh_from_db()
+
+    assert instance.progress_state == new_progress_state
+    assert TaskLog.objects.get(
+        task=instance,
+        action=TaskLog.AuditActionType.PROGRESS_STATE_UPDATED,
+        instigator=response.wsgi_request.user,
+    )
+
+
+@pytest.mark.parametrize(
+    ("object_type", "success_url"),
+    [
+        ("Task", "workflow:task-ui-confirm-create"),
+        ("Subtask", "workflow:subtask-ui-confirm-create"),
+    ],
+    ids=("task test", "subtask test"),
+)
+def test_confirm_create_template_shows_task_or_subtask(
+    valid_user_client,
+    object_type,
+    success_url,
+):
+    """Test the confirm create template distinguishes between subtask or task's
+    creation."""
+
+    parent_task_instance = TaskFactory.create(
+        progress_state__name=ProgressState.State.TO_DO,
+    )
+
+    url = reverse(
+        success_url,
+        kwargs={
+            "pk": parent_task_instance.pk,
+        },
+    )
+    response = valid_user_client.get(url)
+
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+    expected_h1_text = f"{object_type}: {parent_task_instance.title}"
+
+    assert expected_h1_text in page.find("h1").text
+
+
+@pytest.mark.parametrize(
+    ("task_factory", "update_url"),
+    [
+        (TaskFactory, "workflow:task-ui-update"),
+        (SubTaskFactory, "workflow:subtask-ui-update"),
+    ],
+    ids=("task test", "subtask test"),
+)
+def test_update_link_changes_for_task_and_subtask(
+    superuser_client,
+    task_factory,
+    update_url,
+):
+    task = task_factory.create()
+
+    url = reverse(
+        "workflow:task-ui-detail",
+        kwargs={
+            "pk": task.pk,
+        },
+    )
+    response = superuser_client.get(url)
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+
+    update_link = reverse(
+        update_url,
+        kwargs={
+            "pk": task.pk,
+        },
+    )
+    assert page.find("a", href=update_link)
+
+
+@pytest.mark.parametrize(
+    ("task_factory"),
+    [TaskFactory, SubTaskFactory],
+    ids=("task test", "subtask test"),
+)
+def test_create_subtask_button_shows_only_for_non_parent_tasks(
+    superuser_client,
+    task_factory,
+):
+    task = task_factory.create()
+
+    url = reverse(
+        "workflow:task-ui-detail",
+        kwargs={
+            "pk": task.pk,
+        },
+    )
+    response = superuser_client.get(url)
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+
+    create_subtask_url = reverse(
+        "workflow:subtask-ui-create",
+        kwargs={"parent_task_pk": task.pk},
+    )
+
+    assert bool(page.find("a", href=create_subtask_url)) != task.is_subtask
+
+
+def test_create_subtask_form_errors_when_parent_is_subtask(valid_user_client):
+    """Tests that the SubtaskCreateForm errors when a form is submitted that has
+    a subtask as a parent."""
+
+    subtask_parent = SubTaskFactory.create()
+    progress_state = ProgressStateFactory.create()
+
+    subtask_form_data = {
+        "progress_state": progress_state.pk,
+        "title": "subtask test title",
+        "description": "subtask test description",
+    }
+
+    url = reverse(
+        "workflow:subtask-ui-create",
+        kwargs={
+            "parent_task_pk": subtask_parent.pk,
+        },
+    )
+
+    response = valid_user_client.post(url, subtask_form_data)
+
+    assert response.status_code == 200
+    assert not response.context_data["form"].is_valid()
+    soup = BeautifulSoup(str(response.content), "html.parser")
+    assert (
+        "You cannot make a subtask from a subtask."
+        in soup.find("div", class_="govuk-error-summary").text
+    )
+
+
+@pytest.mark.parametrize(
+    ("client_type", "expected_status_code_get", "expected_status_code_post"),
+    [
+        ("valid_user_client", 200, 302),
+        ("client_with_current_workbasket_no_permissions", 403, 403),
+    ],
+)
+def test_delete_subtask_missing_user_permissions(
+    client_type,
+    expected_status_code_get,
+    expected_status_code_post,
+    request,
+):
+    """Tests that attempting to delete a subtask fails for users without the
+    necessary permissions."""
+    client_type = request.getfixturevalue(client_type)
+    subtask_instance = SubTaskFactory.create(
+        progress_state__name=ProgressState.State.TO_DO,
+    )
+
+    url = reverse(
+        "workflow:subtask-ui-delete",
+        kwargs={"pk": subtask_instance.pk},
+    )
+
+    get_response = client_type.get(url)
+    assert get_response.status_code == expected_status_code_get
+
+    response = client_type.post(url)
+    assert response.status_code == expected_status_code_post
+
+
+def test_workflow_template_detail_view_displays_task_templates(valid_user_client):
+    task_item_template = TaskItemTemplateFactory.create()
+    task_template = task_item_template.task_template
+    workflow_template = task_item_template.workflow_template
+
+    url = reverse(
+        "workflow:task-workflow-template-ui-detail",
+        kwargs={"pk": workflow_template.pk},
+    )
+    response = valid_user_client.get(url)
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+    assert page.find("h1", text=f"Workflow template: {workflow_template.title}")
+    assert page.find("a", text=task_template.title)
+
+
+@pytest.mark.parametrize(
+    ("action", "item_position", "expected_item_order"),
+    [
+        ("promote", 1, [1, 2, 3]),
+        ("promote", 2, [2, 1, 3]),
+        ("demote", 2, [1, 3, 2]),
+        ("demote", 3, [1, 2, 3]),
+        ("promote_to_first", 3, [3, 1, 2]),
+        ("demote_to_last", 1, [2, 3, 1]),
+    ],
+)
+def test_workflow_template_detail_view_reorder_items(
+    action,
+    item_position,
+    expected_item_order,
+    valid_user_client,
+    task_workflow_template_three_task_template_items,
+):
+    """Tests that `TaskWorkflowTemplateDetailView` handles POST requests to
+    promote or demote task templates."""
+
+    def convert_to_index(position: int) -> int:
+        """Converts a 1-based item position to a 0-based index for items array
+        access."""
+        return position - 1
+
+    items = list(task_workflow_template_three_task_template_items.get_task_templates())
+    item_to_move = items[convert_to_index(item_position)]
+
+    url = reverse(
+        "workflow:task-workflow-template-ui-detail",
+        kwargs={"pk": task_workflow_template_three_task_template_items.pk},
+    )
+    form_data = {
+        action: item_to_move.id,
+    }
+
+    response = valid_user_client.post(url, form_data)
+    assert response.status_code == 302
+
+    reordered_items = (
+        task_workflow_template_three_task_template_items.get_task_templates()
+    )
+    for i, reordered_item in enumerate(reordered_items):
+        expected_position = convert_to_index(expected_item_order[i])
+        expected_item = items[expected_position]
+        assert reordered_item.id == expected_item.id
+
+
+def test_workflow_template_create_view(valid_user_client):
+    """Tests that a new workflow template can be created and that the
+    corresponding confirmation view returns a HTTP 200 response."""
+
+    assert not TaskWorkflowTemplate.objects.exists()
+
+    create_url = reverse("workflow:task-workflow-template-ui-create")
+    form_data = {
+        "title": "Test workflow template",
+        "description": "Test description",
+    }
+    create_response = valid_user_client.post(create_url, form_data)
+
+    created_workflow_template = TaskWorkflowTemplate.objects.get(
+        title=form_data["title"],
+        description=form_data["description"],
+    )
+    confirmation_url = reverse(
+        "workflow:task-workflow-template-ui-confirm-create",
+        kwargs={"pk": created_workflow_template.pk},
+    )
+    assert create_response.status_code == 302
+    assert create_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+
+    assert confirmation_response.status_code == 200
+    assert (
+        created_workflow_template.title in soup.select("h1.govuk-panel__title")[0].text
+    )
+
+
+def test_workflow_template_update_view(
+    valid_user_client,
+    task_workflow_template,
+):
+    """Tests that a workflow template can be updated and that the corresponding
+    confirmation view returns a HTTP 200 response."""
+
+    update_url = reverse(
+        "workflow:task-workflow-template-ui-update",
+        kwargs={"pk": task_workflow_template.pk},
+    )
+    form_data = {
+        "title": "Updated test title",
+        "description": "Updated test title",
+    }
+
+    update_response = valid_user_client.post(update_url, form_data)
+    assert update_response.status_code == 302
+
+    task_workflow_template.refresh_from_db()
+    assert task_workflow_template.title == form_data["title"]
+    assert task_workflow_template.description == form_data["description"]
+
+    confirmation_url = reverse(
+        "workflow:task-workflow-template-ui-confirm-update",
+        kwargs={"pk": task_workflow_template.pk},
+    )
+    assert update_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+    assert confirmation_response.status_code == 200
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+    assert task_workflow_template.title in soup.select("h1.govuk-panel__title")[0].text
+
+
+def test_workflow_template_delete_view(
+    valid_user_client,
+    task_workflow_template_single_task_template_item,
+):
+    """Tests that a workflow template can be deleted (along with related
+    TaskItemTemplate and TaskTemplate objects) and that the corresponding
+    confirmation view returns a HTTP 200 response."""
+
+    task_workflow_template_pk = task_workflow_template_single_task_template_item.pk
+    task_template_pk = (
+        task_workflow_template_single_task_template_item.get_task_templates().get().pk
+    )
+
+    delete_url = task_workflow_template_single_task_template_item.get_url("delete")
+    delete_response = valid_user_client.post(delete_url)
+    assert delete_response.status_code == 302
+
+    assert not TaskWorkflowTemplate.objects.filter(
+        pk=task_workflow_template_pk,
+    ).exists()
+    assert not TaskItemTemplate.objects.filter(
+        workflow_template_id=task_workflow_template_pk,
+    ).exists()
+    assert not TaskTemplate.objects.filter(pk=task_template_pk).exists()
+
+    confirmation_url = reverse(
+        "workflow:task-workflow-template-ui-confirm-delete",
+        kwargs={"pk": task_workflow_template_pk},
+    )
+    assert delete_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+    assert confirmation_response.status_code == 200
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+    assert (
+        f"Workflow template ID: {task_workflow_template_pk}"
+        in soup.select(".govuk-panel__title")[0].text
+    )
+
+
+def test_create_task_template_view(valid_user_client, task_workflow_template):
+    """Test the view for creating new TaskTemplates and the confirmation view
+    that a successful creation redirects to."""
+
+    assert task_workflow_template.get_task_templates().count() == 0
+
+    create_url = reverse(
+        "workflow:task-template-ui-create",
+        kwargs={"workflow_template_pk": task_workflow_template.pk},
+    )
+    form_data = {
+        "title": factory.Faker("sentence"),
+        "description": factory.Faker("sentence"),
+    }
+    create_response = valid_user_client.post(create_url, form_data)
+    created_task_template = task_workflow_template.get_task_templates().get()
+    confirmation_url = reverse(
+        "workflow:task-template-ui-confirm-create",
+        kwargs={"pk": created_task_template.pk},
+    )
+
+    assert create_response.status_code == 302
+    assert task_workflow_template.get_task_templates().count() == 1
+    assert create_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+
+    assert confirmation_response.status_code == 200
+    assert created_task_template.title in soup.select("h1.govuk-panel__title")[0].text
+
+
+def test_task_template_detail_view(
+    valid_user_client,
+    task_workflow_template_single_task_template_item,
+):
+    task_template = (
+        task_workflow_template_single_task_template_item.get_task_templates().get()
+    )
+    url = reverse("workflow:task-template-ui-detail", kwargs={"pk": task_template.pk})
+    response = valid_user_client.get(url)
+
+    soup = BeautifulSoup(str(response.content), "html.parser")
+
+    assert response.status_code == 200
+    assert (
+        task_template.title
+        in soup.select("div.govuk-summary-list__row:nth-child(2) > dd:nth-child(2)")[
+            0
+        ].text
+    )
+
+
+def test_update_task_template_view(
+    valid_user_client,
+    task_workflow_template_single_task_template_item,
+):
+    """Test the view for updating TaskTemplates and the confirmation view that a
+    successful update redirects to."""
+
+    assert (
+        task_workflow_template_single_task_template_item.get_task_templates().count()
+        == 1
+    )
+
+    task_template = (
+        task_workflow_template_single_task_template_item.get_task_templates().get()
+    )
+    update_url = reverse(
+        "workflow:task-template-ui-update",
+        kwargs={"pk": task_template.pk},
+    )
+    appended_text = "updated"
+    form_data = {
+        "title": f"{task_template.title} {appended_text}",
+        "description": f"{task_template.description} {appended_text}",
+    }
+    update_response = valid_user_client.post(update_url, form_data)
+    updated_task_template = (
+        task_workflow_template_single_task_template_item.get_task_templates().get()
+    )
+    confirmation_url = reverse(
+        "workflow:task-template-ui-confirm-update",
+        kwargs={"pk": updated_task_template.pk},
+    )
+
+    assert update_response.status_code == 302
+    assert update_response.url == confirmation_url
+    assert (
+        task_workflow_template_single_task_template_item.get_task_templates().count()
+        == 1
+    )
+    assert updated_task_template.title.endswith(appended_text)
+    assert updated_task_template.description.endswith(appended_text)
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+
+    assert confirmation_response.status_code == 200
+    assert updated_task_template.title in soup.select("h1.govuk-panel__title")[0].text
+
+
+def test_delete_task_template_view(
+    valid_user_client,
+    task_workflow_template_single_task_template_item,
+):
+    """Test the view for deleting TaskTemplates and the confirmation view that a
+    successful deletion redirects to."""
+
+    assert (
+        task_workflow_template_single_task_template_item.get_task_templates().count()
+        == 1
+    )
+    assert task_workflow_template_single_task_template_item.get_items().count() == 1
+
+    task_template_pk = (
+        task_workflow_template_single_task_template_item.get_task_templates().get().pk
+    )
+    task_item_template_pk = (
+        task_workflow_template_single_task_template_item.get_items().get().pk
+    )
+    delete_url = reverse(
+        "workflow:task-template-ui-delete",
+        kwargs={
+            "workflow_template_pk": task_workflow_template_single_task_template_item.pk,
+            "pk": task_template_pk,
+        },
+    )
+
+    delete_response = valid_user_client.post(delete_url)
+    task_workflow_template_after = TaskWorkflowTemplate.objects.get(
+        pk=task_workflow_template_single_task_template_item.pk,
+    )
+
+    confirmation_url = reverse(
+        "workflow:task-template-ui-confirm-delete",
+        kwargs={
+            "workflow_template_pk": task_workflow_template_single_task_template_item.pk,
+            "pk": task_template_pk,
+        },
+    )
+
+    assert delete_response.status_code == 302
+    assert delete_response.url == confirmation_url
+    assert task_workflow_template_after.get_task_templates().count() == 0
+    assert not TaskTemplate.objects.filter(pk=task_template_pk)
+    assert not TaskItemTemplate.objects.filter(pk=task_item_template_pk)
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+
+    assert confirmation_response.status_code == 200
+    assert (
+        f"Task template ID: {task_template_pk}"
+        in soup.select(".govuk-panel__title")[0].text
+    )
+
+
+def test_workflow_template_list_view(valid_user_client, valid_user):
+    """Test that valid user receives a 200 on GET for TaskWorkflowList view and
+    values display in table."""
+
+    template_instance = TaskWorkflowTemplateFactory.create(creator=valid_user)
+    response = valid_user_client.get(reverse("workflow:task-workflow-template-ui-list"))
+
+    assert response.status_code == 200
+
+    soup = BeautifulSoup(str(response.content), "html.parser")
+    row_text = [td.text for td in soup.select("table tr:nth-child(1) > td")]
+
+    assert str(template_instance.id) in row_text
+    assert template_instance.title in row_text
+    assert template_instance.description in row_text
+    assert template_instance.creator.get_displayname() in row_text
+    assert (
+        f"{template_instance.updated_at.strftime(settings.DATETIME_FORMAT)}" in row_text
+    )
+    assert (
+        f"{template_instance.created_at.strftime(settings.DATETIME_FORMAT)}" in row_text
+    )
+
+
+def test_workflow_detail_view_displays_tasks(
+    valid_user_client,
+    task_workflow_single_task_item,
+):
+    workflow = task_workflow_single_task_item
+    task = task_workflow_single_task_item.get_tasks().get()
+
+    url = reverse(
+        "workflow:task-workflow-ui-detail",
+        kwargs={"pk": workflow.pk},
+    )
+    response = valid_user_client.get(url)
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+    assert page.find("h1", text=f"Workflow: {workflow.title}")
+    assert page.find("a", text=task.title)
+
+
+@pytest.mark.parametrize(
+    ("action", "item_position", "expected_item_order"),
+    [
+        ("promote", 1, [1, 2, 3]),
+        ("promote", 2, [2, 1, 3]),
+        ("demote", 2, [1, 3, 2]),
+        ("demote", 3, [1, 2, 3]),
+        ("promote_to_first", 3, [3, 1, 2]),
+        ("demote_to_last", 1, [2, 3, 1]),
+    ],
+)
+def test_workflow_detail_view_reorder_items(
+    action,
+    item_position,
+    expected_item_order,
+    valid_user_client,
+    task_workflow_three_task_items,
+):
+    """Tests that `TaskWorkflowDetailView` handles POST requests to promote or
+    demote tasks."""
+
+    def convert_to_index(position: int) -> int:
+        """Converts a 1-based item position to a 0-based index for items array
+        access."""
+        return position - 1
+
+    items = list(task_workflow_three_task_items.get_tasks())
+    item_to_move = items[convert_to_index(item_position)]
+
+    url = reverse(
+        "workflow:task-workflow-ui-detail",
+        kwargs={"pk": task_workflow_three_task_items.pk},
+    )
+    form_data = {
+        action: item_to_move.id,
+    }
+
+    response = valid_user_client.post(url, form_data)
+    assert response.status_code == 302
+
+    reordered_items = task_workflow_three_task_items.get_tasks()
+    for i, reordered_item in enumerate(reordered_items):
+        expected_position = convert_to_index(expected_item_order[i])
+        expected_item = items[expected_position]
+        assert reordered_item.id == expected_item.id
+
+
+@pytest.mark.parametrize(
+    "form_data",
+    [
+        {
+            "title": "Test workflow 1",
+            "description": "Workflow created without using template",
+            "create_type": TaskWorkflowCreateForm.CreateType.WITHOUT_TEMPLATE,
+        },
+        {
+            "title": "Test workflow 2",
+            "description": "Workflow created using template",
+            "create_type": TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE,
+        },
+    ],
+    ids=(
+        "without_template",
+        "with_template",
+    ),
+)
+def test_workflow_create_view(
+    form_data,
+    valid_user,
+    valid_user_client,
+    task_workflow_template_single_task_template_item,
+):
+    """Tests that a new workflow can be created (with or without workflow
+    template) and that the corresponding confirmation view returns a HTTP 200
+    response."""
+
+    with_template = (
+        form_data["create_type"] == TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE
+    )
+
+    if with_template:
+        form_data["workflow_template"] = (
+            task_workflow_template_single_task_template_item.pk
+        )
+
+    assert not TaskWorkflow.objects.exists()
+
+    create_url = reverse("workflow:task-workflow-ui-create")
+    create_response = valid_user_client.post(create_url, form_data)
+    assert create_response.status_code == 302
+
+    created_workflow = TaskWorkflow.objects.get(
+        summary_task__title=form_data["title"],
+        summary_task__description=form_data["description"],
+        summary_task__creator=valid_user,
+    )
+
+    if with_template:
+        assert (
+            created_workflow.get_tasks().count()
+            == task_workflow_template_single_task_template_item.get_task_templates().count()
+        )
+    else:
+        assert created_workflow.get_tasks().count() == 0
+
+    confirmation_url = reverse(
+        "workflow:task-workflow-ui-confirm-create",
+        kwargs={"pk": created_workflow.pk},
+    )
+    assert create_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+    assert confirmation_response.status_code == 200
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+    assert str(created_workflow) in soup.select("h1.govuk-panel__title")[0].text
+
+
+def test_workflow_update_view(
+    valid_user_client,
+    task_workflow,
+):
+    """Tests that a workflow can be updated and that the corresponding
+    confirmation view returns a HTTP 200 response."""
+
+    form_data = {
+        "title": "Updated workflow title",
+        "description": "Updated workflow description",
+    }
+    update_url = task_workflow.get_url("edit")
+
+    update_response = valid_user_client.post(update_url, form_data)
+    assert update_response.status_code == 302
+
+    task_workflow.refresh_from_db()
+    assert task_workflow.summary_task.title == form_data["title"]
+    assert task_workflow.summary_task.description == form_data["description"]
+
+    confirmation_url = reverse(
+        "workflow:task-workflow-ui-confirm-update",
+        kwargs={"pk": task_workflow.pk},
+    )
+    assert update_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+    assert confirmation_response.status_code == 200
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+    assert str(task_workflow) in soup.select("h1.govuk-panel__title")[0].text
+
+
+def test_workflow_delete_view(
+    valid_user_client,
+    task_workflow_single_task_item,
+):
+    """Tests that a workflow can be deleted (along with related TaskItem and
+    Task objects) and that the corresponding confirmation view returns a HTTP
+    200 response."""
+
+    workflow_pk = task_workflow_single_task_item.pk
+    summary_task_pk = task_workflow_single_task_item.summary_task.pk
+    task_pk = task_workflow_single_task_item.get_tasks().get().pk
+
+    delete_url = task_workflow_single_task_item.get_url("delete")
+    delete_response = valid_user_client.post(delete_url)
+    assert delete_response.status_code == 302
+
+    assert not TaskWorkflow.objects.filter(
+        pk=workflow_pk,
+    ).exists()
+    assert not TaskItem.objects.filter(
+        workflow_id=workflow_pk,
+    ).exists()
+    assert not Task.objects.filter(pk__in=[summary_task_pk, task_pk]).exists()
+
+    confirmation_url = reverse(
+        "workflow:task-workflow-ui-confirm-delete",
+        kwargs={"pk": workflow_pk},
+    )
+    assert delete_response.url == confirmation_url
+
+    confirmation_response = valid_user_client.get(confirmation_url)
+    assert confirmation_response.status_code == 200
+
+    soup = BeautifulSoup(str(confirmation_response.content), "html.parser")
+    assert f"Workflow ID: {workflow_pk}" in soup.select(".govuk-panel__title")[0].text
+
+
+def test_workflow_list_view(valid_user_client, task_workflow):
+    response = valid_user_client.get(reverse("workflow:task-workflow-ui-list"))
+
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+    table = page.select("table")[0]
+
+    assert len(table.select("tbody tr")) == 1
+    assert table.select("tr:nth-child(1) > td:nth-child(1) > a:nth-child(1)")[
+        0
+    ].text == str(task_workflow.pk)
+
+
+def test_task_and_workflow_list_view(valid_user_client, task, task_workflow):
+    response = valid_user_client.get(reverse("workflow:task-and-workflow-ui-list"))
+
+    assert response.status_code == 200
+
+    page = BeautifulSoup(response.content.decode(response.charset), "html.parser")
+    table = page.select("table")[0]
+
+    assert len(table.select("tbody tr")) == 2
+    assert table.select("tr:nth-child(1) > td:nth-child(1) > a:nth-child(1)")[
+        0
+    ].text == str(task.pk)
+    assert table.select("tr:nth-child(2) > td:nth-child(1) > a:nth-child(1)")[
+        0
+    ].text == str(task_workflow.summary_task.pk)
diff --git a/tasks/tests/test_workflow_models.py b/tasks/tests/test_workflow_models.py
new file mode 100644
index 000000000..26d81cb93
--- /dev/null
+++ b/tasks/tests/test_workflow_models.py
@@ -0,0 +1,107 @@
+import pytest
+from django.core.exceptions import ObjectDoesNotExist
+
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskTemplate
+from tasks.tests import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_create_task_workflow_from_task_workflow_template(
+    valid_user,
+    task_workflow_template_three_task_template_items,
+):
+    """Test creation of TaskWorkflow instances from TaskWorkflowTemplates using
+    its `create_task_workflow()` method."""
+
+    title = "Workflow title"
+    description = "Workflow description"
+    creator = valid_user
+    task_workflow = (
+        task_workflow_template_three_task_template_items.create_task_workflow(
+            title=title,
+            description=description,
+            creator=creator,
+        )
+    )
+
+    # Test that workflow values are valid.
+    assert (
+        task_workflow.creator_template
+        == task_workflow_template_three_task_template_items
+    )
+    assert task_workflow.summary_task.title == title
+    assert task_workflow.summary_task.description == description
+    assert task_workflow.summary_task.creator == creator
+    assert task_workflow.get_items().count() == 3
+
+    # Validate that item positions are equivalent.
+    zipped_items = zip(
+        task_workflow_template_three_task_template_items.get_items(),
+        task_workflow.get_items(),
+    )
+    for item_template, item in zipped_items:
+        assert item_template.position == item.position
+
+    # Validate that object values are equivalent.
+    zipped_objs = zip(
+        task_workflow_template_three_task_template_items.get_task_templates(),
+        task_workflow.get_tasks(),
+    )
+    for task_template, task in zipped_objs:
+        assert task_template.title == task.title
+        assert task_template.description == task.description
+        assert task_template.category == task.category
+
+
+def test_delete_task_item_template():
+    task_item_template = factories.TaskItemTemplateFactory.create()
+    task_item_template_id = task_item_template.id
+    task_template_id = task_item_template.task_template.id
+
+    assert TaskItemTemplate.objects.get(id=task_item_template_id)
+    assert TaskTemplate.objects.get(id=task_template_id)
+
+    task_item_template.delete()
+
+    with pytest.raises(ObjectDoesNotExist):
+        TaskItemTemplate.objects.get(id=task_item_template_id)
+    assert TaskTemplate.objects.get(id=task_template_id)
+
+
+def test_delete_task_template():
+    task_item_template = factories.TaskItemTemplateFactory.create()
+    task_item_template_id = task_item_template.id
+    task_template = task_item_template.task_template
+    task_template_id = task_item_template.task_template.id
+
+    assert TaskItemTemplate.objects.get(id=task_item_template_id)
+    assert TaskTemplate.objects.get(id=task_template_id)
+
+    task_template.delete()
+
+    with pytest.raises(ObjectDoesNotExist):
+        TaskItemTemplate.objects.get(id=task_item_template_id)
+    with pytest.raises(ObjectDoesNotExist):
+        assert TaskTemplate.objects.get(id=task_template_id)
+
+
+def test_delete_task_workflow_template(
+    task_workflow_template_three_task_template_items,
+):
+    task_item_template_ids = [
+        item.id for item in task_workflow_template_three_task_template_items.get_items()
+    ]
+    task_template_ids = [
+        task.id
+        for task in task_workflow_template_three_task_template_items.get_task_templates()
+    ]
+
+    assert len(task_item_template_ids) == 3
+    assert len(task_template_ids) == 3
+
+    task_workflow_template_three_task_template_items.delete()
+
+    assert not TaskItemTemplate.objects.filter(id__in=task_item_template_ids).exists()
+    assert TaskTemplate.objects.filter(id__in=task_template_ids).count() == 3
diff --git a/tasks/urls.py b/tasks/urls.py
new file mode 100644
index 000000000..ad00db22f
--- /dev/null
+++ b/tasks/urls.py
@@ -0,0 +1,207 @@
+from django.urls import include
+from django.urls import path
+
+from tasks import views
+
+app_name = "workflow"
+
+task_ui_patterns = [
+    # Task urls
+    path("", views.TaskListView.as_view(), name="task-ui-list"),
+    path("<int:pk>/", views.TaskDetailView.as_view(), name="task-ui-detail"),
+    path("create/", views.TaskCreateView.as_view(), name="task-ui-create"),
+    path(
+        "<int:pk>/confirm-create/",
+        views.TaskConfirmCreateView.as_view(),
+        name="task-ui-confirm-create",
+    ),
+    path("<int:pk>/update/", views.TaskUpdateView.as_view(), name="task-ui-update"),
+    path(
+        "<int:pk>/confirm-update/",
+        views.TaskConfirmUpdateView.as_view(),
+        name="task-ui-confirm-update",
+    ),
+    path("<int:pk>/delete/", views.TaskDeleteView.as_view(), name="task-ui-delete"),
+    path(
+        "<int:pk>/confirm-delete/",
+        views.TaskConfirmDeleteView.as_view(),
+        name="task-ui-confirm-delete",
+    ),
+    # Subtask urls
+    path(
+        "<int:parent_task_pk>/subtasks/create/",
+        views.SubTaskCreateView.as_view(),
+        name="subtask-ui-create",
+    ),
+    path(
+        "subtasks/<int:pk>/delete",
+        views.SubTaskDeleteView.as_view(),
+        name="subtask-ui-delete",
+    ),
+    path(
+        "subtasks/<int:pk>/confirm-delete",
+        views.SubTaskConfirmDeleteView.as_view(),
+        name="subtask-ui-confirm-delete",
+    ),
+    path(
+        "subtasks/<int:pk>/confirm-create/",
+        views.SubTaskConfirmCreateView.as_view(),
+        name="subtask-ui-confirm-create",
+    ),
+    path(
+        "subtasks/<int:pk>/delete",
+        views.SubTaskDeleteView.as_view(),
+        name="subtask-ui-delete",
+    ),
+    path(
+        "subtasks/<int:pk>/confirm-delete",
+        views.SubTaskConfirmDeleteView.as_view(),
+        name="subtask-ui-confirm-delete",
+    ),
+    path(
+        "subtasks/<int:pk>/update/",
+        views.SubTaskUpdateView.as_view(),
+        name="subtask-ui-update",
+    ),
+    path(
+        "subtasks/confirm-update/<int:pk>/",
+        views.SubTaskConfirmUpdateView.as_view(),
+        name="subtask-ui-confirm-update",
+    ),
+]
+
+workflow_ui_patterns = [
+    path(
+        "",
+        views.TaskWorkflowListView.as_view(),
+        name="task-workflow-ui-list",
+    ),
+    path(
+        "<int:pk>/",
+        views.TaskWorkflowDetailView.as_view(),
+        name="task-workflow-ui-detail",
+    ),
+    path(
+        "create/",
+        views.TaskWorkflowCreateView.as_view(),
+        name="task-workflow-ui-create",
+    ),
+    path(
+        "<int:pk>/confirm-create/",
+        views.TaskWorkflowConfirmCreateView.as_view(),
+        name="task-workflow-ui-confirm-create",
+    ),
+    path(
+        "<int:pk>/update/",
+        views.TaskWorkflowUpdateView.as_view(),
+        name="task-workflow-ui-update",
+    ),
+    path(
+        "<int:pk>/confirm-update/",
+        views.TaskWorkflowConfirmUpdateView.as_view(),
+        name="task-workflow-ui-confirm-update",
+    ),
+    path(
+        "<int:pk>/delete/",
+        views.TaskWorkflowDeleteView.as_view(),
+        name="task-workflow-ui-delete",
+    ),
+    path(
+        "<int:pk>/confirm-delete/",
+        views.TaskWorkflowConfirmDeleteView.as_view(),
+        name="task-workflow-ui-confirm-delete",
+    ),
+]
+
+task_and_workflow_ui_patterns = [
+    path(
+        "",
+        views.TaskAndWorkflowListView.as_view(),
+        name="task-and-workflow-ui-list",
+    ),
+]
+
+workflow_template_ui_patterns = [
+    path(
+        "",
+        views.TaskWorkflowTemplateListView.as_view(),
+        name="task-workflow-template-ui-list",
+    ),
+    path(
+        "<int:pk>/",
+        views.TaskWorkflowTemplateDetailView.as_view(),
+        name="task-workflow-template-ui-detail",
+    ),
+    path(
+        "create/",
+        views.TaskWorkflowTemplateCreateView.as_view(),
+        name="task-workflow-template-ui-create",
+    ),
+    path(
+        "<int:pk>/confirm-create/",
+        views.TaskWorkflowTemplateConfirmCreateView.as_view(),
+        name="task-workflow-template-ui-confirm-create",
+    ),
+    path(
+        "<int:pk>/update/",
+        views.TaskWorkflowTemplateUpdateView.as_view(),
+        name="task-workflow-template-ui-update",
+    ),
+    path(
+        "<int:pk>/confirm-update/",
+        views.TaskWorkflowTemplateConfirmUpdateView.as_view(),
+        name="task-workflow-template-ui-confirm-update",
+    ),
+    path(
+        "<int:pk>/delete/",
+        views.TaskWorkflowTemplateDeleteView.as_view(),
+        name="task-workflow-template-ui-delete",
+    ),
+    path(
+        "<int:pk>/confirm-delete/",
+        views.TaskWorkflowTemplateConfirmDeleteView.as_view(),
+        name="task-workflow-template-ui-confirm-delete",
+    ),
+    path(
+        "task-templates/<int:pk>/",
+        views.TaskTemplateDetailView.as_view(),
+        name="task-template-ui-detail",
+    ),
+    path(
+        "<int:workflow_template_pk>/task-templates/create/",
+        views.TaskTemplateCreateView.as_view(),
+        name="task-template-ui-create",
+    ),
+    path(
+        "task-templates/confirm-create/<int:pk>/",
+        views.TaskTemplateConfirmCreateView.as_view(),
+        name="task-template-ui-confirm-create",
+    ),
+    path(
+        "task-templates/<int:pk>/update/",
+        views.TaskTemplateUpdateView.as_view(),
+        name="task-template-ui-update",
+    ),
+    path(
+        "task-templates/confirm-update/<int:pk>/",
+        views.TaskTemplateConfirmUpdateView.as_view(),
+        name="task-template-ui-confirm-update",
+    ),
+    path(
+        "<int:workflow_template_pk>/task-templates/<int:pk>/delete/",
+        views.TaskTemplateDeleteView.as_view(),
+        name="task-template-ui-delete",
+    ),
+    path(
+        "<int:workflow_template_pk>/task-templates/<int:pk>/confirm-delete/",
+        views.TaskTemplateConfirmDeleteView.as_view(),
+        name="task-template-ui-confirm-delete",
+    ),
+]
+
+urlpatterns = [
+    path("tasks/", include(task_ui_patterns)),
+    path("workflows/", include(workflow_ui_patterns)),
+    path("tasks-and-workflows/", include(task_and_workflow_ui_patterns)),
+    path("workflow-templates/", include(workflow_template_ui_patterns)),
+]
diff --git a/tasks/views.py b/tasks/views.py
new file mode 100644
index 000000000..4df9a8517
--- /dev/null
+++ b/tasks/views.py
@@ -0,0 +1,833 @@
+from django.conf import settings
+from django.contrib.auth.mixins import PermissionRequiredMixin
+from django.db import OperationalError
+from django.db import transaction
+from django.http import HttpResponseRedirect
+from django.shortcuts import get_object_or_404
+from django.urls import reverse
+from django.utils.functional import cached_property
+from django.views.generic.base import TemplateView
+from django.views.generic.detail import DetailView
+from django.views.generic.edit import CreateView
+from django.views.generic.edit import DeleteView
+from django.views.generic.edit import FormView
+from django.views.generic.edit import UpdateView
+
+from common.views import SortingMixin
+from common.views import WithPaginationListView
+from tasks.filters import TaskAndWorkflowFilter
+from tasks.filters import TaskFilter
+from tasks.filters import TaskWorkflowFilter
+from tasks.filters import WorkflowTemplateFilter
+from tasks.forms import SubTaskCreateForm
+from tasks.forms import TaskCreateForm
+from tasks.forms import TaskDeleteForm
+from tasks.forms import TaskTemplateCreateForm
+from tasks.forms import TaskTemplateDeleteForm
+from tasks.forms import TaskTemplateUpdateForm
+from tasks.forms import TaskUpdateForm
+from tasks.forms import TaskWorkflowCreateForm
+from tasks.forms import TaskWorkflowDeleteForm
+from tasks.forms import TaskWorkflowTemplateCreateForm
+from tasks.forms import TaskWorkflowTemplateDeleteForm
+from tasks.forms import TaskWorkflowTemplateUpdateForm
+from tasks.forms import TaskWorkflowUpdateForm
+from tasks.models import Queue
+from tasks.models import QueueItem
+from tasks.models import Task
+from tasks.models import TaskItem
+from tasks.models import TaskItemTemplate
+from tasks.models import TaskTemplate
+from tasks.models import TaskWorkflow
+from tasks.models import TaskWorkflowTemplate
+from tasks.signals import set_current_instigator
+
+
+class TaskListView(PermissionRequiredMixin, SortingMixin, WithPaginationListView):
+    model = Task
+    template_name = "tasks/list.jinja"
+    permission_required = "tasks.view_task"
+    paginate_by = 20
+    filterset_class = TaskFilter
+    sort_by_fields = ["created_at"]
+
+    def get_queryset(self):
+        queryset = Task.objects.all()
+        ordering = self.get_ordering()
+        if ordering:
+            ordering = (ordering,)
+            queryset = queryset.order_by(*ordering)
+        return queryset
+
+
+class TaskDetailView(PermissionRequiredMixin, DetailView):
+    model = Task
+    template_name = "tasks/detail.jinja"
+    permission_required = "tasks.view_task"
+
+
+class TaskCreateView(PermissionRequiredMixin, CreateView):
+    model = Task
+    template_name = "layouts/create.jinja"
+    permission_required = "tasks.add_task"
+    form_class = TaskCreateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = "Create a task"
+        return context
+
+    def form_valid(self, form):
+        self.object = form.save(user=self.request.user)
+        return HttpResponseRedirect(self.get_success_url())
+
+    def get_success_url(self):
+        return reverse("workflow:task-ui-confirm-create", kwargs={"pk": self.object.pk})
+
+
+class TaskConfirmCreateView(PermissionRequiredMixin, DetailView):
+    model = Task
+    template_name = "tasks/confirm_create.jinja"
+    permission_required = "tasks.add_task"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["verbose_name"] = "task"
+        return context
+
+
+class TaskUpdateView(PermissionRequiredMixin, UpdateView):
+    model = Task
+    template_name = "tasks/edit.jinja"
+    permission_required = "tasks.change_task"
+    form_class = TaskUpdateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = "Edit task details"
+        return context
+
+    def form_valid(self, form):
+        set_current_instigator(self.request.user)
+        with transaction.atomic():
+            self.object = form.save()
+        return HttpResponseRedirect(self.get_success_url())
+
+    def get_success_url(self):
+        return reverse("workflow:task-ui-confirm-update", kwargs={"pk": self.object.pk})
+
+
+class TaskConfirmUpdateView(PermissionRequiredMixin, DetailView):
+    model = Task
+    template_name = "tasks/confirm_update.jinja"
+    permission_required = "tasks.change_task"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = "Task updated"
+        context["object_type"] = "Task"
+        return context
+
+
+class TaskDeleteView(PermissionRequiredMixin, DeleteView):
+    model = Task
+    template_name = "tasks/delete.jinja"
+    permission_required = "tasks.delete_task"
+    form_class = TaskDeleteForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["instance"] = self.object
+        return kwargs
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["verbose_name"] = "task"
+        return context_data
+
+    def get_success_url(self):
+        return reverse("workflow:task-ui-confirm-delete", kwargs={"pk": self.object.pk})
+
+
+class TaskConfirmDeleteView(PermissionRequiredMixin, TemplateView):
+    model = Task
+    template_name = "tasks/confirm_delete.jinja"
+    permission_required = "tasks.delete_task"
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["deleted_pk"] = self.kwargs["pk"]
+        context_data["verbose_name"] = "task"
+        return context_data
+
+
+class SubTaskCreateView(PermissionRequiredMixin, CreateView):
+    model = Task
+    template_name = "layouts/create.jinja"
+    permission_required = "tasks.add_task"
+    form_class = SubTaskCreateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = (
+            f"Create a subtask for task {self.kwargs['parent_task_pk']}"
+        )
+        return context
+
+    def form_valid(self, form):
+        parent_task = Task.objects.filter(pk=self.kwargs["parent_task_pk"]).first()
+        if parent_task.parent_task:
+            form.add_error(
+                None,
+                "You cannot make a subtask from a subtask.",
+            )
+            return self.form_invalid(form)
+        else:
+            self.object = form.save(parent_task, user=self.request.user)
+            return HttpResponseRedirect(self.get_success_url())
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:subtask-ui-confirm-create",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class SubTaskConfirmCreateView(DetailView):
+    model = Task
+    template_name = "tasks/confirm_create.jinja"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["verbose_name"] = "subtask"
+        return context
+
+
+class SubTaskUpdateView(PermissionRequiredMixin, UpdateView):
+    model = Task
+    template_name = "tasks/edit.jinja"
+    permission_required = "tasks.change_task"
+    form_class = TaskUpdateForm
+
+    def form_valid(self, form):
+        set_current_instigator(self.request.user)
+        with transaction.atomic():
+            self.object = form.save()
+        return HttpResponseRedirect(self.get_success_url())
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = f"Edit subtask {self.object.pk}"
+        return context
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:subtask-ui-confirm-update",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class SubTaskConfirmUpdateView(PermissionRequiredMixin, DetailView):
+    model = Task
+    template_name = "tasks/confirm_update.jinja"
+    permission_required = "tasks.change_task"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["page_title"] = "Subtask updated"
+        context["object_type"] = "Subtask"
+        return context
+
+
+class SubTaskDeleteView(PermissionRequiredMixin, DeleteView):
+    model = Task
+    template_name = "tasks/delete.jinja"
+    permission_required = "tasks.delete_task"
+    form_class = TaskDeleteForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["instance"] = self.object
+        return kwargs
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["verbose_name"] = "subtask"
+        return context_data
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:subtask-ui-confirm-delete",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class SubTaskConfirmDeleteView(PermissionRequiredMixin, TemplateView):
+    model = Task
+    template_name = "tasks/confirm_delete.jinja"
+    permission_required = "tasks.delete_task"
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["verbose_name"] = "subtask"
+        context_data["deleted_pk"] = self.kwargs["pk"]
+        return context_data
+
+
+class TaskWorkflowListView(
+    PermissionRequiredMixin,
+    SortingMixin,
+    WithPaginationListView,
+):
+    model = Task
+    template_name = "tasks/workflows/list.jinja"
+    permission_required = "tasks.view_task"
+    paginate_by = settings.DEFAULT_PAGINATOR_PER_PAGE_MAX
+    filterset_class = TaskWorkflowFilter
+    sort_by_fields = ["created_at"]
+
+    def get_queryset(self):
+        queryset = Task.objects.all()
+        ordering = self.get_ordering()
+        if ordering:
+            ordering = (ordering,)
+            queryset = queryset.order_by(*ordering)
+        return queryset
+
+
+class TaskAndWorkflowListView(
+    PermissionRequiredMixin,
+    SortingMixin,
+    WithPaginationListView,
+):
+    model = Task
+    template_name = "tasks/workflows/task-and-workflow-list.jinja"
+    permission_required = "tasks.view_task"
+    paginate_by = settings.DEFAULT_PAGINATOR_PER_PAGE_MAX
+    filterset_class = TaskAndWorkflowFilter
+    sort_by_fields = ["created_at"]
+
+    def get_queryset(self):
+        queryset = Task.objects.all()
+        ordering = self.get_ordering()
+        if ordering:
+            ordering = (ordering,)
+            queryset = queryset.order_by(*ordering)
+        return queryset
+
+
+class TaskWorkflowTemplateListView(
+    PermissionRequiredMixin,
+    SortingMixin,
+    WithPaginationListView,
+):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/template_list.jinja"
+    permission_required = "tasks.view_taskworkflowtemplate"
+    paginate_by = 20
+    filterset_class = WorkflowTemplateFilter
+    sort_by_fields = ["created_at", "updated_at"]
+
+    def get_context_data(self, **kwargs) -> dict:
+        context_data = super().get_context_data(**kwargs)
+
+        context_data["datetime_format"] = settings.DATETIME_FORMAT
+
+        return context_data
+
+    def get_queryset(self):
+        queryset = TaskWorkflowTemplate.objects.all()
+        ordering = self.get_ordering()
+        if ordering:
+            ordering = (ordering,)
+            queryset = queryset.order_by(*ordering)
+        return queryset
+
+
+class QueuedItemManagementMixin:
+    """A view mixin providing helper functions to manage queued items."""
+
+    queued_item_model: type[QueueItem] = None
+    """The model responsible for managing members of a queue."""
+
+    item_lookup_field: str = ""
+    """The lookup field of the instance managed by a queued item."""
+
+    queue_field: str = ""
+    """The name of the ForeignKey field relating a queued item to a queue."""
+
+    @cached_property
+    def queue(self) -> type[Queue]:
+        """The queue instance that is the object of the view."""
+        return self.get_object()
+
+    def promote(self, lookup_id: int) -> None:
+        queued_item = get_object_or_404(
+            self.queued_item_model,
+            **{
+                self.item_lookup_field: lookup_id,
+                self.queue_field: self.queue,
+            },
+        )
+        try:
+            queued_item.promote()
+        except OperationalError:
+            pass
+
+    def demote(self, lookup_id: int) -> None:
+        queued_item = get_object_or_404(
+            self.queued_item_model,
+            **{
+                self.item_lookup_field: lookup_id,
+                self.queue_field: self.queue,
+            },
+        )
+        try:
+            queued_item.demote()
+        except OperationalError:
+            pass
+
+    def promote_to_first(self, lookup_id: int) -> None:
+        queued_item = get_object_or_404(
+            self.queued_item_model,
+            **{
+                self.item_lookup_field: lookup_id,
+                self.queue_field: self.queue,
+            },
+        )
+        try:
+            queued_item.promote_to_first()
+        except OperationalError:
+            pass
+
+    def demote_to_last(self, lookup_id: int) -> None:
+        queued_item = get_object_or_404(
+            self.queued_item_model,
+            **{
+                self.item_lookup_field: lookup_id,
+                self.queue_field: self.queue,
+            },
+        )
+        try:
+            queued_item.demote_to_last()
+        except OperationalError:
+            pass
+
+
+class TaskWorkflowDetailView(
+    PermissionRequiredMixin,
+    QueuedItemManagementMixin,
+    DetailView,
+):
+    template_name = "tasks/workflows/detail.jinja"
+    permission_required = "tasks.view_taskworkflow"
+    model = TaskWorkflow
+    queued_item_model = TaskItem
+    item_lookup_field = "task_id"
+    queue_field = queued_item_model.queue_field
+
+    @property
+    def view_url(self) -> str:
+        return reverse(
+            "workflow:task-workflow-ui-detail",
+            kwargs={"pk": self.queue.pk},
+        )
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["object_list"] = self.queue.get_tasks()
+        return context_data
+
+    def post(self, request, *args, **kwargs):
+        if "promote" in request.POST:
+            self.promote(request.POST.get("promote"))
+        elif "demote" in request.POST:
+            self.demote(request.POST.get("demote"))
+        elif "promote_to_first" in request.POST:
+            self.promote_to_first(request.POST.get("promote_to_first"))
+        elif "demote_to_last" in request.POST:
+            self.demote_to_last(request.POST.get("demote_to_last"))
+
+        return HttpResponseRedirect(self.view_url)
+
+
+class TaskWorkflowCreateView(PermissionRequiredMixin, FormView):
+    permission_required = "tasks.add_taskworkflow"
+    template_name = "tasks/workflows/create.jinja"
+    form_class = TaskWorkflowCreateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["verbose_name"] = "workflow"
+        context["list_url"] = "#NOT-IMPLEMENTED"
+        return context
+
+    def form_valid(self, form):
+        summary_data = {
+            "title": form.cleaned_data["title"],
+            "description": form.cleaned_data["description"],
+            "creator": self.request.user,
+        }
+        create_type = form.cleaned_data["create_type"]
+
+        if create_type == TaskWorkflowCreateForm.CreateType.WITH_TEMPLATE:
+            template = form.cleaned_data["workflow_template"]
+            self.object = template.create_task_workflow(**summary_data)
+        elif create_type == TaskWorkflowCreateForm.CreateType.WITHOUT_TEMPLATE:
+            with transaction.atomic():
+                summary_task = Task.objects.create(**summary_data)
+                self.object = TaskWorkflow.objects.create(
+                    summary_task=summary_task,
+                )
+
+        return super().form_valid(form)
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-ui-confirm-create",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowConfirmCreateView(PermissionRequiredMixin, DetailView):
+    model = TaskWorkflow
+    template_name = "tasks/workflows/confirm_create.jinja"
+    permission_required = "tasks.add_taskworkflow"
+
+
+class TaskWorkflowUpdateView(PermissionRequiredMixin, UpdateView):
+    model = TaskWorkflow
+    template_name = "tasks/workflows/edit.jinja"
+    permission_required = "tasks.change_taskworkflow"
+    form_class = TaskWorkflowUpdateForm
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-ui-confirm-update",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowConfirmUpdateView(PermissionRequiredMixin, DetailView):
+    model = TaskWorkflow
+    template_name = "tasks/workflows/confirm_update.jinja"
+    permission_required = "tasks.change_taskworkflow"
+
+
+class TaskWorkflowDeleteView(PermissionRequiredMixin, DeleteView):
+    model = TaskWorkflow
+    template_name = "tasks/workflows/delete.jinja"
+    permission_required = "tasks.delete_taskworkflow"
+    form_class = TaskWorkflowDeleteForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["instance"] = self.object
+        return kwargs
+
+    @transaction.atomic
+    def form_valid(self, form):
+        summary_task = self.object.summary_task
+        self.object.get_tasks().delete()
+        result = super().form_valid(form)
+        summary_task.delete()
+        return result
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-ui-confirm-delete",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowConfirmDeleteView(PermissionRequiredMixin, TemplateView):
+    model = TaskWorkflow
+    template_name = "tasks/workflows/confirm_delete.jinja"
+    permission_required = "tasks.change_taskworkflow"
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data.update(
+            {
+                "verbose_name": "workflow",
+                "deleted_pk": self.kwargs["pk"],
+                "create_url": reverse("workflow:task-workflow-ui-create"),
+                "list_url": "#NOT-IMPLEMENTED",
+            },
+        )
+        return context_data
+
+
+class TaskWorkflowTemplateDetailView(
+    PermissionRequiredMixin,
+    QueuedItemManagementMixin,
+    DetailView,
+):
+    template_name = "tasks/workflows/detail.jinja"
+    permission_required = "tasks.view_taskworkflowtemplate"
+    model = TaskWorkflowTemplate
+    queued_item_model = TaskItemTemplate
+    item_lookup_field = "task_template_id"
+    queue_field = queued_item_model.queue_field
+
+    @property
+    def view_url(self) -> str:
+        return reverse(
+            "workflow:task-workflow-template-ui-detail",
+            kwargs={"pk": self.queue.pk},
+        )
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data["object_list"] = self.queue.get_task_templates()
+        return context_data
+
+    def post(self, request, *args, **kwargs):
+        if "promote" in request.POST:
+            self.promote(request.POST.get("promote"))
+        elif "demote" in request.POST:
+            self.demote(request.POST.get("demote"))
+        elif "promote_to_first" in request.POST:
+            self.promote_to_first(request.POST.get("promote_to_first"))
+        elif "demote_to_last" in request.POST:
+            self.demote_to_last(request.POST.get("demote_to_last"))
+
+        return HttpResponseRedirect(self.view_url)
+
+
+class TaskWorkflowTemplateCreateView(PermissionRequiredMixin, CreateView):
+    model = TaskWorkflowTemplate
+    permission_required = "tasks.add_taskworkflowtemplate"
+    template_name = "tasks/workflows/create.jinja"
+    form_class = TaskWorkflowTemplateCreateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["verbose_name"] = "workflow template"
+        context["list_url"] = reverse("workflow:task-workflow-template-ui-list")
+        return context
+
+    def form_valid(self, form):
+        self.object = form.save(user=self.request.user)
+        return HttpResponseRedirect(self.get_success_url())
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-template-ui-confirm-create",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowTemplateConfirmCreateView(PermissionRequiredMixin, DetailView):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/confirm_create.jinja"
+    permission_required = "tasks.add_taskworkflowtemplate"
+
+
+class TaskWorkflowTemplateUpdateView(PermissionRequiredMixin, UpdateView):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/edit.jinja"
+    permission_required = "tasks.change_taskworkflowtemplate"
+    form_class = TaskWorkflowTemplateUpdateForm
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-template-ui-confirm-update",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowTemplateConfirmUpdateView(PermissionRequiredMixin, DetailView):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/confirm_update.jinja"
+    permission_required = "tasks.change_taskworkflowtemplate"
+
+
+class TaskWorkflowTemplateDeleteView(PermissionRequiredMixin, DeleteView):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/delete.jinja"
+    permission_required = "tasks.delete_taskworkflowtemplate"
+    form_class = TaskWorkflowTemplateDeleteForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["instance"] = self.object
+        return kwargs
+
+    @transaction.atomic
+    def form_valid(self, form):
+        self.object.get_task_templates().delete()
+        return super().form_valid(form)
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-workflow-template-ui-confirm-delete",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskWorkflowTemplateConfirmDeleteView(PermissionRequiredMixin, TemplateView):
+    model = TaskWorkflowTemplate
+    template_name = "tasks/workflows/confirm_delete.jinja"
+    permission_required = "tasks.change_taskworkflowtemplate"
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data.update(
+            {
+                "verbose_name": "workflow template",
+                "deleted_pk": self.kwargs["pk"],
+                "create_url": reverse("workflow:task-workflow-template-ui-create"),
+                "list_url": reverse("workflow:task-workflow-template-ui-list"),
+            },
+        )
+        return context_data
+
+
+class TaskTemplateDetailView(PermissionRequiredMixin, DetailView):
+    model = TaskTemplate
+    template_name = "tasks/workflows/task_template_detail.jinja"
+    permission_required = "tasks.view_tasktemplate"
+
+    def get_context_data(self, **kwargs) -> dict:
+        context = super().get_context_data(**kwargs)
+
+        context["task_workflow_template"] = (
+            self.get_object().taskitemtemplate.workflow_template
+        )
+
+        return context
+
+
+class TaskTemplateCreateView(PermissionRequiredMixin, CreateView):
+    template_name = "tasks/workflows/task_template_save.jinja"
+    form_class = TaskTemplateCreateForm
+    permission_required = "tasks.add_tasktemplate"
+
+    def get_task_workflow_template(self) -> TaskWorkflowTemplate:
+        """Get the TaskWorkflowTemplate identified by the pk in the URL."""
+        return TaskWorkflowTemplate.objects.get(
+            pk=self.kwargs["workflow_template_pk"],
+        )
+
+    def get_context_data(self, **kwargs) -> dict:
+        context = super().get_context_data(**kwargs)
+
+        context["page_title"] = "Create a task template"
+        context["task_workflow_template"] = self.get_task_workflow_template()
+
+        return context
+
+    def form_valid(self, form) -> HttpResponseRedirect:
+        with transaction.atomic():
+            self.object = form.save()
+            TaskItemTemplate.objects.create(
+                workflow_template=self.get_task_workflow_template(),
+                task_template=self.object,
+            )
+
+        return HttpResponseRedirect(self.get_success_url(), self.object.pk)
+
+    def get_success_url(self) -> str:
+        return reverse(
+            "workflow:task-template-ui-confirm-create",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskTemplateConfirmCreateView(PermissionRequiredMixin, DetailView):
+    model = TaskTemplate
+    template_name = "tasks/workflows/task_template_confirm_create.jinja"
+    permission_required = "tasks.add_tasktemplate"
+
+    def get_context_data(self, **kwargs) -> dict:
+        context = super().get_context_data(**kwargs)
+
+        context["task_workflow_template"] = (
+            self.get_object().taskitemtemplate.workflow_template
+        )
+
+        return context
+
+
+class TaskTemplateUpdateView(PermissionRequiredMixin, UpdateView):
+    model = TaskTemplate
+    template_name = "tasks/workflows/task_template_save.jinja"
+    permission_required = "tasks.change_tasktemplate"
+    form_class = TaskTemplateUpdateForm
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+
+        context["page_title"] = f"Update task template: {self.get_object().title}"
+        context["task_workflow_template"] = (
+            self.get_object().taskitemtemplate.workflow_template
+        )
+
+        return context
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-template-ui-confirm-update",
+            kwargs={"pk": self.object.pk},
+        )
+
+
+class TaskTemplateConfirmUpdateView(PermissionRequiredMixin, DetailView):
+    model = TaskTemplate
+    template_name = "tasks/workflows/task_template_confirm_update.jinja"
+    permission_required = "tasks.add_tasktemplate"
+
+    def get_context_data(self, **kwargs) -> dict:
+        context = super().get_context_data(**kwargs)
+
+        context["task_workflow_template"] = (
+            self.get_object().taskitemtemplate.workflow_template
+        )
+
+        return context
+
+
+class TaskTemplateDeleteView(PermissionRequiredMixin, DeleteView):
+    model = TaskTemplate
+    template_name = "tasks/workflows/task_template_delete.jinja"
+    permission_required = "tasks.delete_tasktemplate"
+    form_class = TaskTemplateDeleteForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["instance"] = self.object
+        return kwargs
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+
+        context["task_workflow_template"] = (
+            self.get_object().taskitemtemplate.workflow_template
+        )
+
+        return context
+
+    def get_success_url(self):
+        return reverse(
+            "workflow:task-template-ui-confirm-delete",
+            kwargs={
+                "workflow_template_pk": self.kwargs["workflow_template_pk"],
+                "pk": self.object.pk,
+            },
+        )
+
+
+class TaskTemplateConfirmDeleteView(PermissionRequiredMixin, TemplateView):
+    template_name = "tasks/workflows/task_template_confirm_delete.jinja"
+    permission_required = "tasks.delete_tasktemplate"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+
+        context["deleted_pk"] = self.kwargs["pk"]
+        context["task_workflow_template"] = TaskWorkflowTemplate.objects.get(
+            pk=self.kwargs["workflow_template_pk"],
+        )
+
+        return context
diff --git a/urls.py b/urls.py
index 61e6aca58..d82888efc 100644
--- a/urls.py
+++ b/urls.py
@@ -37,6 +37,7 @@
     path("", include("regulations.urls")),
     path("", include("reports.urls")),
     path("", include("taric_parsers.urls")),
+    path("", include("tasks.urls", namespace="workflow")),
     path("", include("workbaskets.urls", namespace="workbaskets")),
     path("", include("reference_documents.urls", namespace="reference_documents")),
 ]
diff --git a/webpack.config.js b/webpack.config.js
index 5c98a53be..8dbf2b028 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -81,6 +81,7 @@ module.exports = {
                   "regulations/static/regulations/scss",
                   "workbaskets/static/workbaskets/scss",
                   "reference_documents/static/reference_documents/scss",
+                  "tasks/static/tasks/scss",
                 ],
               },
             },
diff --git a/workbaskets/forms.py b/workbaskets/forms.py
index 54730606f..5d17aaf43 100644
--- a/workbaskets/forms.py
+++ b/workbaskets/forms.py
@@ -11,6 +11,7 @@
 from crispy_forms_gds.layout import Submit
 from django import forms
 from django.contrib.auth import get_user_model
+from django.db import transaction
 from django.db.models import Q
 from django.urls import reverse
 from django.utils.timezone import make_aware
@@ -20,7 +21,8 @@
 from common.validators import markdown_tags_allowlist
 from tasks.models import Comment
 from tasks.models import Task
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
+from tasks.signals import set_current_instigator
 from workbaskets import models
 from workbaskets import validators
 from workbaskets.util import serialize_uploaded_data
@@ -209,7 +211,7 @@ class WorkBasketAssignUsersForm(forms.Form):
         error_messages={"required": "Select one or more users to assign"},
     )
     assignment_type = forms.ChoiceField(
-        choices=UserAssignment.AssignmentType.choices,
+        choices=TaskAssignee.AssignmentType.choices,
         widget=forms.RadioSelect,
         error_messages={"required": "Select an assignment type"},
     )
@@ -249,18 +251,20 @@ def init_layout(self):
             ),
         )
 
+    @transaction.atomic
     def assign_users(self, task):
+        set_current_instigator(self.request.user)
+
         assignment_type = self.cleaned_data["assignment_type"]
 
-        objs = [
-            UserAssignment(
+        assignees = [
+            TaskAssignee(
                 user=user,
-                assigned_by=self.request.user,
                 assignment_type=assignment_type,
                 task=task,
             )
             for user in self.cleaned_data["users"]
-            if not UserAssignment.objects.filter(
+            if not TaskAssignee.objects.filter(
                 user=user,
                 assignment_type=assignment_type,
                 task__workbasket=self.workbasket,
@@ -268,17 +272,15 @@ def assign_users(self, task):
             .assigned()
             .exists()
         ]
-        user_assignments = UserAssignment.objects.bulk_create(objs)
-
-        return user_assignments
+        return TaskAssignee.objects.bulk_create(assignees)
 
 
 class WorkBasketUnassignUsersForm(forms.Form):
-    assignments = forms.ModelMultipleChoiceField(
+    assignees = forms.ModelMultipleChoiceField(
         label="Users",
         help_text="Select users to unassign",
         widget=forms.CheckboxSelectMultiple,
-        queryset=UserAssignment.objects.all(),
+        queryset=TaskAssignee.objects.all(),
         error_messages={"required": "Select one or more users to unassign"},
     )
 
@@ -290,12 +292,12 @@ def __init__(self, *args, **kwargs):
         self.init_layout()
 
     def init_fields(self):
-        self.fields["assignments"].queryset = self.workbasket.user_assignments.order_by(
+        self.fields["assignees"].queryset = self.workbasket.user_assignments.order_by(
             "user__first_name",
             "user__last_name",
         )
 
-        self.fields["assignments"].label_from_instance = (
+        self.fields["assignees"].label_from_instance = (
             lambda obj: f"{obj.user.get_full_name()} ({obj.get_assignment_type_display().lower()})"
         )
 
@@ -304,7 +306,7 @@ def init_layout(self):
         self.helper.label_size = Size.SMALL
         self.helper.legend_size = Size.SMALL
         self.helper.layout = Layout(
-            "assignments",
+            "assignees",
             Submit(
                 "submit",
                 "Save",
@@ -313,16 +315,18 @@ def init_layout(self):
             ),
         )
 
+    @transaction.atomic
     def unassign_users(self):
-        assignments = self.cleaned_data["assignments"]
-        for assignment in assignments:
-            assignment.unassigned_at = make_aware(datetime.now())
+        set_current_instigator(self.request.user)
+
+        assignees = self.cleaned_data["assignees"]
+        for assignee in assignees:
+            assignee.unassigned_at = make_aware(datetime.now())
 
-        user_assignments = UserAssignment.objects.bulk_update(
-            assignments,
+        return TaskAssignee.objects.bulk_update(
+            assignees,
             fields=["unassigned_at"],
         )
-        return user_assignments
 
 
 class WorkBasketCommentForm(forms.ModelForm):
diff --git a/workbaskets/models.py b/workbaskets/models.py
index 9c1e06b39..f9a007e20 100644
--- a/workbaskets/models.py
+++ b/workbaskets/models.py
@@ -707,36 +707,43 @@ def unchecked_or_errored_transactions(self):
 
     @property
     def worker_assignments(self):
-        from tasks.models import UserAssignment
+        """Returns a queryset of associated `TaskAssignee` instances filtered to
+        match `AssignmentType.WORKBASKET_WORKER`."""
+        from tasks.models import TaskAssignee
 
         return (
-            UserAssignment.objects.filter(task__workbasket=self)
+            TaskAssignee.objects.filter(task__workbasket=self)
             .workbasket_workers()
             .assigned()
         )
 
     @property
     def reviewer_assignments(self):
-        from tasks.models import UserAssignment
+        """Returns a queryset of associated `TaskAssignee` instances filtered to
+        match `AssignmentType.WORKBASKET_REVIEWER`."""
+        from tasks.models import TaskAssignee
 
         return (
-            UserAssignment.objects.filter(task__workbasket=self)
+            TaskAssignee.objects.filter(task__workbasket=self)
             .workbasket_reviewers()
             .assigned()
         )
 
     @property
     def user_assignments(self):
+        """Returns a queryset of associated `TaskAssignee` instances."""
         assignments = self.worker_assignments | self.reviewer_assignments
         return assignments
 
     @property
     def assigned_workers(self):
+        """Returns a queryset of `User` instances assigned as workers."""
         user_ids = self.worker_assignments.values_list("user_id", flat=True)
         return User.objects.filter(id__in=user_ids)
 
     @property
     def assigned_reviewers(self):
+        """Returns a queryset of `User` instances assigned as reviewers."""
         user_ids = self.reviewer_assignments.values_list("user_id", flat=True)
         return User.objects.filter(id__in=user_ids)
 
diff --git a/workbaskets/tests/test_forms.py b/workbaskets/tests/test_forms.py
index 4fb80a28a..4fca07d67 100644
--- a/workbaskets/tests/test_forms.py
+++ b/workbaskets/tests/test_forms.py
@@ -1,7 +1,7 @@
 import pytest
 
 from common.tests import factories
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets import forms
 from workbaskets.validators import tops_jira_number_validator
 
@@ -129,7 +129,7 @@ def test_workbasket_assign_users_form_assigns_users(rf, valid_user, user_workbas
     users = factories.UserFactory.create_batch(2, is_superuser=True)
     data = {
         "users": users,
-        "assignment_type": UserAssignment.AssignmentType.WORKBASKET_WORKER,
+        "assignment_type": TaskAssignee.AssignmentType.WORKBASKET_WORKER,
     }
 
     form = forms.WorkBasketAssignUsersForm(
@@ -142,7 +142,7 @@ def test_workbasket_assign_users_form_assigns_users(rf, valid_user, user_workbas
     task = factories.TaskFactory.create(workbasket=user_workbasket)
     form.assign_users(task=task)
     for user in users:
-        assert UserAssignment.objects.get(user=user, task=task, assigned_by=valid_user)
+        assert TaskAssignee.objects.get(user=user, task=task)
 
 
 def test_workbasket_assign_users_form_required_fields(rf, valid_user, user_workbasket):
@@ -166,13 +166,13 @@ def test_workbasket_unassign_users_form_unassigns_users(
 ):
     request = rf.request()
     request.user = valid_user
-    assignments = factories.UserAssignmentFactory.create_batch(
+    assignees = factories.TaskAssigneeFactory.create_batch(
         2,
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task__workbasket=user_workbasket,
     )
     data = {
-        "assignments": assignments,
+        "assignees": assignees,
     }
 
     form = forms.WorkBasketUnassignUsersForm(
@@ -183,9 +183,9 @@ def test_workbasket_unassign_users_form_unassigns_users(
     assert form.is_valid()
 
     form.unassign_users()
-    for assignment in assignments:
-        assignment.refresh_from_db()
-        assert not assignment.is_assigned
+    for assignee in assignees:
+        assignee.refresh_from_db()
+        assert not assignee.is_assigned
 
 
 def test_workbasket_unassign_users_form_required_fields(
@@ -202,7 +202,7 @@ def test_workbasket_unassign_users_form_required_fields(
         data={},
     )
     assert not form.is_valid()
-    assert f"Select one or more users to unassign" in form.errors["assignments"]
+    assert f"Select one or more users to unassign" in form.errors["assignees"]
 
 
 def test_workbasket_comment_create_form(assigned_workbasket):
diff --git a/workbaskets/tests/test_models.py b/workbaskets/tests/test_models.py
index c789b5392..e80c99909 100644
--- a/workbaskets/tests/test_models.py
+++ b/workbaskets/tests/test_models.py
@@ -19,7 +19,7 @@
 from common.tests.factories import WorkBasketFactory
 from common.tests.util import assert_transaction_order
 from common.validators import UpdateType
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets import tasks
 from workbaskets.models import REVISION_ONLY
 from workbaskets.models import SEED_FIRST
@@ -367,12 +367,12 @@ def test_queue(valid_user, unapproved_checked_transaction):
     approver and shifting transaction from DRAFT to REVISION partition."""
     wb = unapproved_checked_transaction.workbasket
     task = factories.TaskFactory.create(workbasket=wb)
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
     )
     wb.queue(valid_user.pk, settings.TRANSACTION_SCHEMA)
@@ -453,38 +453,38 @@ def test_unassigned_workbasket_cannot_be_queued():
     with pytest.raises(TransitionNotAllowed):
         workbasket.queue(user=worker.id, scheme_name=settings.TRANSACTION_SCHEMA)
 
-    factories.UserAssignmentFactory.create(
+    factories.TaskAssigneeFactory.create(
         user=worker,
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
     )
     assert workbasket.is_fully_assigned()
 
-    UserAssignment.unassign_user(user=worker, task=task)
+    TaskAssignee.unassign_user(user=worker, task=task, instigator=worker)
     assert not workbasket.is_fully_assigned()
 
 
 def test_workbasket_user_assignments_queryset():
     workbasket = factories.WorkBasketFactory.create()
-    worker_assignment = factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    worker_assignment = factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task__workbasket=workbasket,
     )
-    reviewer_assignment = factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    reviewer_assignment = factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task__workbasket=workbasket,
     )
     # Inactive assignment
-    factories.UserAssignmentFactory.create(
+    factories.TaskAssigneeFactory.create(
         unassigned_at=make_aware(datetime.now()),
         task__workbasket=workbasket,
     )
     # Unrelated assignment
-    factories.UserAssignmentFactory.create()
+    factories.TaskAssigneeFactory.create()
 
     workbasket.refresh_from_db()
     queryset = workbasket.user_assignments
diff --git a/workbaskets/tests/test_views.py b/workbaskets/tests/test_views.py
index fbb28313e..5c0092369 100644
--- a/workbaskets/tests/test_views.py
+++ b/workbaskets/tests/test_views.py
@@ -29,7 +29,8 @@
 from importer.models import ImportBatchStatus
 from measures.models import Measure
 from tasks.models import Comment
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
+from tasks.models import TaskLog
 from workbaskets import models
 from workbaskets.tasks import call_end_measures
 from workbaskets.tasks import check_workbasket_sync
@@ -290,13 +291,13 @@ def test_workbasket_assignments_appear(valid_user_client):
     # Fully assign the workbasket
     task = factories.TaskFactory.create(workbasket=workbasket)
 
-    worker_assignment = factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    worker_assignment = factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
         user=worker,
     )
-    reviewer_assignment = factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    reviewer_assignment = factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
         user=reviewer,
     )
@@ -333,12 +334,12 @@ def test_select_workbasket_filtering(
 
     task = factories.TaskFactory.create(workbasket=fully_assigned_workbasket)
 
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
     )
     # Create an unassigned workbasket
@@ -348,15 +349,15 @@ def test_select_workbasket_filtering(
     reviewer_task = factories.TaskFactory.create(
         workbasket=reviewer_assigned_workbasket,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=reviewer_task,
     )
     # Create a workbasket with only a worker assigned
     worker_assigned_workbasket = factories.WorkBasketFactory.create(id=4)
     worker_task = factories.TaskFactory.create(workbasket=worker_assigned_workbasket)
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=worker_task,
     )
 
@@ -2264,12 +2265,12 @@ def test_disabled_packaging_for_unassigned_workbasket(
 
     # Assign the workbasket so it can now be packaged
     task = factories.TaskFactory.create(workbasket=user_empty_workbasket)
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_WORKER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
         task=task,
     )
-    factories.UserAssignmentFactory.create(
-        assignment_type=UserAssignment.AssignmentType.WORKBASKET_REVIEWER,
+    factories.TaskAssigneeFactory.create(
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_REVIEWER,
         task=task,
     )
 
@@ -2279,18 +2280,36 @@ def test_disabled_packaging_for_unassigned_workbasket(
     assert not packaging_button.has_attr("disabled")
 
 
-def test_workbasket_assign_users_view(valid_user, valid_user_client, user_workbasket):
-    valid_user.user_permissions.add(
-        Permission.objects.get(codename="add_userassignment"),
-    )
-    response = valid_user_client.get(
-        reverse(
-            "workbaskets:workbasket-ui-assign-users",
-            kwargs={"pk": user_workbasket.pk},
-        ),
+def test_workbasket_assign_users_view(valid_user, valid_user_client, new_workbasket):
+    """Tests that a user can be assigned to a workbasket and that a `TaskLog`
+    entry is created together with the `TaskAssignee` instance."""
+    url = reverse(
+        "workbaskets:workbasket-ui-assign-users",
+        kwargs={"pk": new_workbasket.pk},
     )
+
+    form_data = {
+        "users": [valid_user.pk],
+        "assignment_type": TaskAssignee.AssignmentType.WORKBASKET_WORKER,
+    }
+
+    response = valid_user_client.get(url)
     assert response.status_code == 200
-    assert "Assign users to workbasket" in str(response.content)
+
+    response = valid_user_client.post(url, form_data)
+    assert response.status_code == 302
+
+    assert TaskAssignee.objects.get(
+        user=valid_user,
+        assignment_type=TaskAssignee.AssignmentType.WORKBASKET_WORKER,
+        task__workbasket=new_workbasket,
+    )
+
+    assert TaskLog.objects.get(
+        task__workbasket=new_workbasket,
+        action=TaskLog.AuditActionType.TASK_ASSIGNED,
+        instigator=response.wsgi_request.user,
+    )
 
 
 def test_workbasket_assign_users_view_without_permission(client, user_workbasket):
@@ -2305,18 +2324,35 @@ def test_workbasket_assign_users_view_without_permission(client, user_workbasket
     assert response.status_code == 403
 
 
-def test_workbasket_unassign_users_view(valid_user, valid_user_client, user_workbasket):
-    valid_user.user_permissions.add(
-        Permission.objects.get(codename="change_userassignment"),
-    )
-    response = valid_user_client.get(
-        reverse(
-            "workbaskets:workbasket-ui-unassign-users",
-            kwargs={"pk": user_workbasket.pk},
-        ),
+def test_workbasket_unassign_users_view(valid_user, valid_user_client):
+    """Tests that a user can be unassigned from a workbasket and that a
+    `TaskLog` entry is created together with the updated `TaskAssignee`
+    instance."""
+    assignee = factories.TaskAssigneeFactory.create(user=valid_user)
+    workbasket = assignee.task.workbasket
+
+    url = reverse(
+        "workbaskets:workbasket-ui-unassign-users",
+        kwargs={"pk": workbasket.pk},
     )
+    form_data = {
+        "assignees": [assignee.pk],
+    }
+
+    response = valid_user_client.get(url)
     assert response.status_code == 200
-    assert "Unassign users from workbasket" in str(response.content)
+
+    response = valid_user_client.post(url, form_data)
+    assert response.status_code == 302
+
+    assignee.refresh_from_db()
+
+    assert not assignee.is_assigned
+    assert TaskLog.objects.get(
+        task__workbasket=workbasket,
+        action=TaskLog.AuditActionType.TASK_UNASSIGNED,
+        instigator=response.wsgi_request.user,
+    )
 
 
 def test_workbasket_unassign_users_view_without_permission(client, user_workbasket):
diff --git a/workbaskets/views/ui.py b/workbaskets/views/ui.py
index a0e9b9727..652ec9d24 100644
--- a/workbaskets/views/ui.py
+++ b/workbaskets/views/ui.py
@@ -67,7 +67,7 @@
 from regulations.models import Regulation
 from tasks.models import Comment
 from tasks.models import Task
-from tasks.models import UserAssignment
+from tasks.models import TaskAssignee
 from workbaskets import forms
 from workbaskets.models import DataRow
 from workbaskets.models import DataUpload
@@ -106,12 +106,12 @@ class WorkBasketAssignmentFilter(FilterSet):
 
     def assignment_filter(self, queryset, name, value):
         active_workers = (
-            UserAssignment.objects.workbasket_workers()
+            TaskAssignee.objects.workbasket_workers()
             .assigned()
             .values_list("task__workbasket_id")
         )
         active_reviewers = (
-            UserAssignment.objects.workbasket_reviewers()
+            TaskAssignee.objects.workbasket_reviewers()
             .assigned()
             .values_list("task__workbasket_id")
         )
@@ -1681,7 +1681,7 @@ class NoActiveWorkBasket(TemplateView):
 
 
 class WorkBasketAssignUsersView(PermissionRequiredMixin, FormView):
-    permission_required = "tasks.add_userassignment"
+    permission_required = "tasks.add_taskassignee"
     template_name = "workbaskets/assign_users.jinja"
     form_class = forms.WorkBasketAssignUsersForm
 
@@ -1711,6 +1711,7 @@ def form_valid(self, form):
             defaults={
                 "title": self.workbasket.title,
                 "description": self.workbasket.reason,
+                "creator": self.request.user,
             },
         )
         form.assign_users(task=task)
@@ -1721,7 +1722,7 @@ def get_success_url(self):
 
 
 class WorkBasketUnassignUsersView(PermissionRequiredMixin, FormView):
-    permission_required = "tasks.change_userassignment"
+    permission_required = "tasks.change_taskassignee"
     template_name = "workbaskets/assign_users.jinja"
     form_class = forms.WorkBasketUnassignUsersForm
 
@@ -1744,7 +1745,6 @@ def get_form_kwargs(self):
         )
         return kwargs
 
-    @atomic
     def form_valid(self, form):
         form.unassign_users()
         return redirect(self.get_success_url())