diff --git a/src/dispatch/auth/permissions.py b/src/dispatch/auth/permissions.py
index 51342ef91ab3..b10642f0ce50 100644
--- a/src/dispatch/auth/permissions.py
+++ b/src/dispatch/auth/permissions.py
@@ -473,6 +473,20 @@ def has_required_permissions(
         return True
 
 
+class CaseEventPermission(BasePermission):
+    def has_required_permissions(
+        self,
+        request: Request,
+    ) -> bool:
+        return any_permission(
+            permissions=[
+                OrganizationAdminPermission,
+                CaseParticipantPermission,
+            ],
+            request=request,
+        )
+
+
 class FeedbackDeletePermission(BasePermission):
     def has_required_permissions(
         self,
diff --git a/src/dispatch/case/service.py b/src/dispatch/case/service.py
index e2ce5ca40ed9..4e5742bb335a 100644
--- a/src/dispatch/case/service.py
+++ b/src/dispatch/case/service.py
@@ -222,6 +222,7 @@ def create(*, db_session, case_in: CaseCreate, current_user: DispatchUser = None
             "visibility": case.visibility,
         },
         case_id=case.id,
+        pinned=True,
     )
 
     assignee_email = None
diff --git a/src/dispatch/case/views.py b/src/dispatch/case/views.py
index 7b57456de8cb..8ac2205a7273 100644
--- a/src/dispatch/case/views.py
+++ b/src/dispatch/case/views.py
@@ -1,5 +1,6 @@
 import json
 import logging
+from datetime import datetime
 from typing import Annotated
 
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, status
@@ -11,6 +12,7 @@
     CaseEditPermission,
     CaseJoinPermission,
     CaseViewPermission,
+    CaseEventPermission,
     PermissionsDependency,
 )
 from dispatch.auth.service import CurrentUser
@@ -18,6 +20,8 @@
 from dispatch.common.utils.views import create_pydantic_include
 from dispatch.database.core import DbSession
 from dispatch.database.service import CommonParameters, search_filter_sort_paginate
+from dispatch.event import flows as event_flows
+from dispatch.event.models import EventCreateMinimal, EventUpdate
 from dispatch.incident import service as incident_service
 from dispatch.incident.models import IncidentCreate, IncidentRead
 from dispatch.individual.models import IndividualContactRead
@@ -39,7 +43,15 @@
     case_update_flow,
     get_case_participants_flow,
 )
-from .models import Case, CaseCreate, CaseExpandedPagination, CasePagination, CasePaginationMinimalWithExtras, CaseRead, CaseUpdate
+from .models import (
+    Case,
+    CaseCreate,
+    CaseExpandedPagination,
+    CasePagination,
+    CasePaginationMinimalWithExtras,
+    CaseRead,
+    CaseUpdate,
+)
 from .service import create, delete, get, get_participants, update
 
 log = logging.getLogger(__name__)
@@ -144,6 +156,7 @@ def get_cases_minimal(
 
     return json.loads(CasePaginationMinimalWithExtras(**pagination).json())
 
+
 @router.post("", response_model=CaseRead, summary="Creates a new case.")
 def create_case(
     db_session: DbSession,
@@ -413,3 +426,113 @@ def join_case(
         case_id=current_case.id,
         organization_slug=organization,
     )
+
+
+@router.post(
+    "/{case_id}/event",
+    summary="Creates a custom event.",
+    dependencies=[Depends(PermissionsDependency([CaseEventPermission]))],
+)
+def create_custom_event(
+    db_session: DbSession,
+    organization: OrganizationSlug,
+    case_id: PrimaryKey,
+    current_case: CurrentCase,
+    event_in: EventCreateMinimal,
+    current_user: CurrentUser,
+    background_tasks: BackgroundTasks,
+):
+    if event_in.details is None:
+        event_in.details = {}
+    event_in.details.update({"created_by": current_user.email, "added_on": str(datetime.utcnow())})
+    """Creates a custom event."""
+    background_tasks.add_task(
+        event_flows.log_case_event,
+        user_email=current_user.email,
+        case_id=current_case.id,
+        event_in=event_in,
+        organization_slug=organization,
+    )
+
+
+@router.patch(
+    "/{case_id}/event",
+    summary="Updates a custom event.",
+    dependencies=[Depends(PermissionsDependency([CaseEventPermission]))],
+)
+def update_custom_event(
+    db_session: DbSession,
+    organization: OrganizationSlug,
+    case_id: PrimaryKey,
+    current_case: CurrentCase,
+    event_in: EventUpdate,
+    current_user: CurrentUser,
+    background_tasks: BackgroundTasks,
+):
+    if event_in.details:
+        event_in.details.update(
+            {
+                **event_in.details,
+                "updated_by": current_user.email,
+                "updated_on": str(datetime.utcnow()),
+            }
+        )
+    else:
+        event_in.details = {"updated_by": current_user.email, "updated_on": str(datetime.utcnow())}
+    """Updates a custom event."""
+    background_tasks.add_task(
+        event_flows.update_case_event,
+        event_in=event_in,
+        organization_slug=organization,
+    )
+
+
+@router.post(
+    "/{case_id}/exportTimeline",
+    summary="Exports timeline events.",
+    dependencies=[Depends(PermissionsDependency([CaseEventPermission]))],
+)
+def export_timeline_event(
+    db_session: DbSession,
+    organization: OrganizationSlug,
+    case_id: PrimaryKey,
+    current_case: CurrentCase,
+    timeline_filters: dict,
+    current_user: CurrentUser,
+    background_tasks: BackgroundTasks,
+):
+    try:
+        event_flows.export_case_timeline(
+            timeline_filters=timeline_filters,
+            case_id=case_id,
+            organization_slug=organization,
+            db_session=db_session,
+        )
+    except Exception as e:
+        log.exception(e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=[{"msg": (f"{str(e)}.",)}],
+        ) from e
+
+
+@router.delete(
+    "/{case_id}/event/{event_uuid}",
+    summary="Deletes a custom event.",
+    dependencies=[Depends(PermissionsDependency([CaseEventPermission]))],
+)
+def delete_custom_event(
+    db_session: DbSession,
+    organization: OrganizationSlug,
+    case_id: PrimaryKey,
+    current_case: CurrentCase,
+    event_uuid: str,
+    current_user: CurrentUser,
+    background_tasks: BackgroundTasks,
+):
+    """Deletes a custom event."""
+    background_tasks.add_task(
+        event_flows.delete_case_event,
+        event_uuid=event_uuid,
+        organization_slug=organization,
+    )
diff --git a/src/dispatch/document/service.py b/src/dispatch/document/service.py
index 21deb5866fe5..df95137d65d0 100644
--- a/src/dispatch/document/service.py
+++ b/src/dispatch/document/service.py
@@ -27,6 +27,19 @@ def get_by_incident_id_and_resource_type(
     )
 
 
+def get_by_case_id_and_resource_type(
+    *, db_session, case_id: int, project_id: int, resource_type: str
+) -> Document | None:
+    """Returns a document based on the given case and id and document resource type."""
+    return (
+        db_session.query(Document)
+        .filter(Document.case_id == case_id)
+        .filter(Document.project_id == project_id)
+        .filter(Document.resource_type == resource_type)
+        .one_or_none()
+    )
+
+
 def get_project_forms_export_template(*, db_session, project_id: int) -> Document | None:
     """Fetches the project forms export template."""
     resource_type = DocumentResourceTemplateTypes.forms
@@ -89,12 +102,14 @@ def create(*, db_session, document_in: DocumentCreate) -> Document:
             .one_or_none()
         )
         if faq_doc:
-            raise ValidationError([
-                {
-                    "msg": "FAQ document already defined for this project.",
-                    "loc": "document",
-                }
-            ])
+            raise ValidationError(
+                [
+                    {
+                        "msg": "FAQ document already defined for this project.",
+                        "loc": "document",
+                    }
+                ]
+            )
 
     if document_in.resource_type == DocumentResourceTemplateTypes.forms:
         forms_doc = (
@@ -104,12 +119,14 @@ def create(*, db_session, document_in: DocumentCreate) -> Document:
             .one_or_none()
         )
         if forms_doc:
-            raise ValidationError([
-                {
-                    "msg": "Forms export template document already defined for this project.",
-                    "loc": "document",
-                }
-            ])
+            raise ValidationError(
+                [
+                    {
+                        "msg": "Forms export template document already defined for this project.",
+                        "loc": "document",
+                    }
+                ]
+            )
 
     filters = [
         search_filter_service.get(db_session=db_session, search_filter_id=f.id)
diff --git a/src/dispatch/event/flows.py b/src/dispatch/event/flows.py
index 83caf1b94fd8..2dd167949d47 100644
--- a/src/dispatch/event/flows.py
+++ b/src/dispatch/event/flows.py
@@ -3,8 +3,10 @@
 from dispatch.decorators import background_task
 from dispatch.event import service as event_service
 from dispatch.incident import service as incident_service
+from dispatch.case import service as case_service
 from dispatch.individual import service as individual_service
 from dispatch.event.models import EventUpdate, EventCreateMinimal
+from dispatch.auth import service as auth_service
 
 log = logging.getLogger(__name__)
 
@@ -71,3 +73,71 @@ def export_timeline(
 
     except Exception:
         raise
+
+
+@background_task
+def log_case_event(
+    user_email: str,
+    case_id: int,
+    event_in: EventCreateMinimal,
+    db_session=None,
+    organization_slug: str = None,
+):
+    case = case_service.get(db_session=db_session, case_id=case_id)
+    individual = individual_service.get_by_email_and_project(
+        db_session=db_session, email=user_email, project_id=case.project.id
+    )
+    event_in.source = f"Custom event created by {individual.name}"
+    event_in.owner = individual.name
+
+    # Get dispatch user by email
+    dispatch_user = auth_service.get_by_email(db_session=db_session, email=user_email)
+    dispatch_user_id = dispatch_user.id if dispatch_user else None
+
+    event_service.log_case_event(
+        db_session=db_session,
+        case_id=case_id,
+        dispatch_user_id=dispatch_user_id,
+        **event_in.__dict__,
+    )
+
+
+@background_task
+def update_case_event(
+    event_in: EventUpdate,
+    db_session=None,
+    organization_slug: str = None,
+):
+    event_service.update_case_event(
+        db_session=db_session,
+        event_in=event_in,
+    )
+
+
+@background_task
+def delete_case_event(
+    event_uuid: str,
+    db_session=None,
+    organization_slug: str = None,
+):
+    event_service.delete_case_event(
+        db_session=db_session,
+        uuid=event_uuid,
+    )
+
+
+def export_case_timeline(
+    timeline_filters: dict,
+    case_id: int,
+    db_session=None,
+    organization_slug: str = None,
+):
+    try:
+        event_service.export_case_timeline(
+            db_session=db_session,
+            timeline_filters=timeline_filters,
+            case_id=case_id,
+        )
+
+    except Exception:
+        raise
diff --git a/src/dispatch/event/models.py b/src/dispatch/event/models.py
index 33c5bf6f44fa..5f7293435197 100644
--- a/src/dispatch/event/models.py
+++ b/src/dispatch/event/models.py
@@ -70,7 +70,7 @@ class EventCreateMinimal(DispatchBase):
     started_at: datetime
     source: str
     description: str
-    details: dict
+    details: dict | None = None
     type: str | None = None
     owner: str | None = None
     pinned: bool | None = False
diff --git a/src/dispatch/event/service.py b/src/dispatch/event/service.py
index aa1d7852843a..88dd5125d610 100644
--- a/src/dispatch/event/service.py
+++ b/src/dispatch/event/service.py
@@ -262,6 +262,27 @@ def delete_incident_event(
     delete(db_session=db_session, event_id=event.id)
 
 
+def update_case_event(
+    db_session,
+    event_in: EventUpdate,
+) -> Event:
+    """Updates an event in the case timeline."""
+    event = get_by_uuid(db_session=db_session, uuid=event_in.uuid)
+    event = update(db_session=db_session, event=event, event_in=event_in)
+
+    return event
+
+
+def delete_case_event(
+    db_session,
+    uuid: str,
+):
+    """Deletes a case event."""
+    event = get_by_uuid(db_session=db_session, uuid=uuid)
+
+    delete(db_session=db_session, event_id=event.id)
+
+
 def export_timeline(
     db_session,
     timeline_filters: str,
@@ -463,9 +484,7 @@ def export_timeline(
             str_len = 0
             row_idx = 0
             insert_data_request = []
-            print("cell indices")
-            print(len(cell_indices))
-            print(len(data_to_insert))
+
             for index, text in zip(cell_indices, data_to_insert, strict=True):
                 # Adjusting index based on string length
                 new_idx = index + str_len
@@ -545,3 +564,275 @@ def export_timeline(
     # raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=[{"msg": "No timeline data to export"}]) from None
 
     return True
+
+
+def export_case_timeline(
+    db_session,
+    timeline_filters: str,
+    case_id: int,
+):
+    case = case_service.get(db_session=db_session, case_id=case_id)
+    plugin = plugin_service.get_active_instance(
+        db_session=db_session, project_id=case.project_id, plugin_type="document"
+    )
+    if not plugin:
+        log.error("Document not created. No storage plugin enabled.")
+        return False
+
+    """gets timeline events for case"""
+    event = get_by_case_id(db_session=db_session, case_id=case_id)
+    table_data = []
+    dates = set()
+    data_inserted = False
+
+    """Filters events based on user filter"""
+    for e in event:
+        time_header = "Time (UTC)"
+        event_timestamp = e.started_at.strftime("%Y-%m-%d %H:%M:%S")
+        if not e.owner:
+            e.owner = "Dispatch"
+        if timeline_filters.get("timezone").strip() == "America/Los_Angeles":
+            time_header = "Time (PST/PDT)"
+            event_timestamp = (
+                pytz.utc.localize(e.started_at)
+                .astimezone(pytz.timezone(timeline_filters.get("timezone").strip()))
+                .replace(tzinfo=None)
+                .strftime("%Y-%m-%d %H:%M:%S")
+            )
+        date, time = str(event_timestamp).split(" ")
+        if e.pinned or timeline_filters.get(e.type):
+            if date in dates:
+                if timeline_filters.get("exportOwner"):
+                    table_data.append(
+                        {time_header: time, "Description": e.description, "Owner": e.owner}
+                    )
+                else:
+                    table_data.append({time_header: time, "Description": e.description})
+
+            else:
+                dates.add(date)
+                if timeline_filters.get("exportOwner"):
+                    table_data.append({time_header: date, "Description": "\t", "Owner": "\t"})
+                    table_data.append(
+                        {time_header: time, "Description": e.description, "Owner": e.owner}
+                    )
+                else:
+                    table_data.append({time_header: date, "Description": "\t"})
+                    table_data.append({time_header: time, "Description": e.description})
+
+    if table_data:
+        table_data = json.loads(json.dumps(table_data))
+        num_columns = len(table_data[0].keys() if table_data else [])
+        column_headers = table_data[0].keys()
+
+        documents_list = []
+        if timeline_filters.get("caseDocument"):
+            documents = document_service.get_by_case_id_and_resource_type(
+                db_session=db_session,
+                case_id=case_id,
+                project_id=case.project.id,
+                resource_type="dispatch-case-document",
+            )
+            if documents:
+                documents_list.append((documents.resource_id, "Case"))
+
+        for doc_id, doc_name in documents_list:
+            # Checks for existing table in the document
+            table_exists, curr_table_start, curr_table_end, _ = plugin.instance.get_table_details(
+                document_id=doc_id, header="Timeline", doc_name=doc_name
+            )
+
+            # Deletes existing table
+            if table_exists:
+                delete_table_request = [
+                    {
+                        "deleteContentRange": {
+                            "range": {
+                                "segmentId": "",
+                                "startIndex": curr_table_start,
+                                "endIndex": curr_table_end,
+                            }
+                        }
+                    }
+                ]
+                if plugin.instance.delete_table(document_id=doc_id, request=delete_table_request):
+                    log.debug("Existing table in the doc has been deleted")
+
+            else:
+                log.debug("Table doesn't exist under header, creating new table")
+                curr_table_start += 1
+
+            # Insert new table with required rows & columns
+            insert_table_request = [
+                {
+                    "insertTable": {
+                        "rows": len(table_data) + 1,
+                        "columns": num_columns,
+                        "location": {"index": curr_table_start - 1},
+                    }
+                }
+            ]
+            if plugin.instance.insert(document_id=doc_id, request=insert_table_request):
+                log.debug("Table skeleton inserted successfully")
+
+            else:
+                log.error(
+                    f"Unable to insert table skeleton in the {doc_name} document with id {doc_id}"
+                )
+                raise Exception(
+                    f"Unable to insert table skeleton for timeline export in the {doc_name} document"
+                )
+
+            # Formatting & inserting empty table
+            insert_data_request = [
+                {
+                    "updateTableCellStyle": {
+                        "tableCellStyle": {
+                            "backgroundColor": {
+                                "color": {"rgbColor": {"green": 0.4, "red": 0.4, "blue": 0.4}}
+                            }
+                        },
+                        "fields": "backgroundColor",
+                        "tableRange": {
+                            "columnSpan": num_columns,
+                            "rowSpan": 1,
+                            "tableCellLocation": {
+                                "columnIndex": 0,
+                                "rowIndex": 0,
+                                "tableStartLocation": {"index": curr_table_start},
+                            },
+                        },
+                    }
+                },
+                {
+                    "updateTableColumnProperties": {
+                        "tableStartLocation": {
+                            "index": curr_table_start,
+                        },
+                        "columnIndices": [0],
+                        "tableColumnProperties": {
+                            "width": {"magnitude": 90, "unit": "PT"},
+                            "widthType": "FIXED_WIDTH",
+                        },
+                        "fields": "width,widthType",
+                    }
+                },
+            ]
+
+            if timeline_filters.get("exportOwner"):
+                insert_data_request.append(
+                    {
+                        "updateTableColumnProperties": {
+                            "tableStartLocation": {
+                                "index": curr_table_start,
+                            },
+                            "columnIndices": [2],
+                            "tableColumnProperties": {
+                                "width": {"magnitude": 105, "unit": "PT"},
+                                "widthType": "FIXED_WIDTH",
+                            },
+                            "fields": "width,widthType",
+                        }
+                    }
+                )
+
+            if plugin.instance.insert(document_id=doc_id, request=insert_data_request):
+                log.debug("Table Formatted successfully")
+
+            else:
+                log.error(
+                    f"Unable to format table for timeline export in {doc_name} document with id {doc_id}"
+                )
+                raise Exception(
+                    f"Unable to format table for timeline export in the {doc_name} document"
+                )
+
+            # Calculating table cell indices
+            _, _, _, cell_indices = plugin.instance.get_table_details(
+                document_id=doc_id, header="Timeline", doc_name=doc_name
+            )
+            data_to_insert = list(column_headers) + [
+                item for row in table_data for item in row.values()
+            ]
+            str_len = 0
+            row_idx = 0
+            insert_data_request = []
+
+            for index, text in zip(cell_indices, data_to_insert, strict=True):
+                # Adjusting index based on string length
+                new_idx = index + str_len
+
+                insert_data_request.append(
+                    {"insertText": {"location": {"index": new_idx}, "text": text}}
+                )
+
+                # Header field formatting
+                if text in column_headers:
+                    insert_data_request.append(
+                        {
+                            "updateTextStyle": {
+                                "range": {"startIndex": new_idx, "endIndex": new_idx + len(text)},
+                                "textStyle": {
+                                    "bold": True,
+                                    "foregroundColor": {
+                                        "color": {"rgbColor": {"red": 1, "green": 1, "blue": 1}}
+                                    },
+                                    "fontSize": {"magnitude": 10, "unit": "PT"},
+                                },
+                                "fields": "bold,foregroundColor",
+                            }
+                        }
+                    )
+
+                # Formating for date rows
+                if text == "\t":
+                    insert_data_request.append(
+                        {
+                            "updateTableCellStyle": {
+                                "tableCellStyle": {
+                                    "backgroundColor": {
+                                        "color": {
+                                            "rgbColor": {"green": 0.8, "red": 0.8, "blue": 0.8}
+                                        }
+                                    }
+                                },
+                                "fields": "backgroundColor",
+                                "tableRange": {
+                                    "columnSpan": num_columns,
+                                    "rowSpan": 1,
+                                    "tableCellLocation": {
+                                        "tableStartLocation": {"index": curr_table_start},
+                                        "columnIndex": 0,
+                                        "rowIndex": row_idx // len(column_headers),
+                                    },
+                                },
+                            }
+                        }
+                    )
+
+                # Formating for time column
+                if row_idx % num_columns == 0:
+                    insert_data_request.append(
+                        {
+                            "updateTextStyle": {
+                                "range": {"startIndex": new_idx, "endIndex": new_idx + len(text)},
+                                "textStyle": {
+                                    "bold": True,
+                                },
+                                "fields": "bold",
+                            }
+                        }
+                    )
+
+                row_idx += 1
+                str_len += len(text) if text else 0
+
+            data_inserted = plugin.instance.insert(document_id=doc_id, request=insert_data_request)
+        if not data_inserted:
+            raise Exception(f"Encountered error while inserting data into the {doc_name} document")
+
+    else:
+        log.error("No data to export")
+        raise Exception("No data to export, please check filter selection")
+
+    return True
diff --git a/src/dispatch/plugins/dispatch_slack/incident/interactive.py b/src/dispatch/plugins/dispatch_slack/incident/interactive.py
index b27ad1c5b57f..8bed0b649b65 100644
--- a/src/dispatch/plugins/dispatch_slack/incident/interactive.py
+++ b/src/dispatch/plugins/dispatch_slack/incident/interactive.py
@@ -141,6 +141,7 @@
 from dispatch.ticket import flows as ticket_flows
 from dispatch.messaging.strings import reminder_select_values
 from dispatch.plugins.dispatch_slack.messaging import build_unexpected_error_message
+from dispatch.auth import service as auth_service
 
 log = logging.getLogger(__file__)
 
@@ -782,30 +783,28 @@ def replace_slack_users_in_message(client: Any, message: str) -> str:
 def handle_timeline_added_event(
     ack: Ack, client: Any, context: BoltContext, payload: Any, db_session: Session
 ) -> None:
-    """Handles an event where the configured timeline reaction is added to a message."""
+    """Handles an event where the configured timeline reaction is added to a message for incidents or cases."""
     ack()
 
     conversation_id = context["channel_id"]
     message_ts = payload["item"]["ts"]
     message_ts_utc = datetime.utcfromtimestamp(float(message_ts))
 
-    # we fetch the message information
     response = dispatch_slack_service.list_conversation_messages(
         client, conversation_id, latest=message_ts, limit=1, inclusive=1
     )
     message_text = replace_slack_users_in_message(client, response["messages"][0]["text"])
     message_sender_id = response["messages"][0]["user"]
 
-    # TODO: (wshel) handle case reactions
-    if context["subject"].type == IncidentSubjects.incident:
-        individual = None
-        # we fetch the incident
+    subject_type = context["subject"].type
+    individual = None
+    source = "Slack message"
+    event_id = None
+
+    if subject_type == IncidentSubjects.incident:
         incident = incident_service.get(
             db_session=db_session, incident_id=int(context["subject"].id)
         )
-
-        # we fetch the individual who sent the message
-        # if user is not found, we default to "Unknown"
         try:
             message_sender_email = get_user_email(client=client, user_id=message_sender_id)
             if message_sender_email:
@@ -814,24 +813,20 @@ def handle_timeline_added_event(
                     email=message_sender_email,
                     project_id=incident.project.id,
                 )
-        except Exception:
+        except Exception as e:
+            log.error(f"Error getting user email: {e}")
             individual = None
-
-        source = "Slack message"
-        # if the individual is not found, see if it is a bot
         if not individual:
-            if bot_user_id := context["bot_user_id"]:
+            if bot_user_id := context.get("bot_user_id"):
                 try:
                     bot = dispatch_slack_service.get_user_info_by_id(client, bot_user_id)
                     bot_name = bot["profile"]["real_name"]
                     source = f"Slack message from {bot_name}"
-                except Exception:
-                    pass
+                except Exception as e:
+                    log.error(f"Error getting bot info: {e}")
         else:
             source = f"Slack message from {individual.name}"
-
-        # we log the event
-        event_service.log_incident_event(
+        event = event_service.log_incident_event(
             db_session=db_session,
             source=source,
             description=message_text,
@@ -841,6 +836,53 @@ def handle_timeline_added_event(
             type=EventType.imported_message,
             owner=individual.name if individual else None,
         )
+        db_session.commit()
+        event_id = event.id
+        log.info(f"Logged incident event with ID: {event_id}")
+    elif subject_type == CaseSubjects.case:
+        case = case_service.get(db_session=db_session, case_id=int(context["subject"].id))
+        try:
+            message_sender_email = dispatch_slack_service.get_user_email(
+                client=client, user_id=message_sender_id
+            )
+            if message_sender_email:
+                individual = individual_service.get_by_email_and_project(
+                    db_session=db_session,
+                    email=message_sender_email,
+                    project_id=case.project.id,
+                )
+        except Exception as e:
+            log.error(f"Error getting user email: {e}")
+            individual = None
+        if not individual:
+            if bot_user_id := context.get("bot_user_id"):
+                try:
+                    bot = dispatch_slack_service.get_user_info_by_id(client, bot_user_id)
+                    bot_name = bot["profile"]["real_name"]
+                    source = f"Slack message from {bot_name}"
+                except Exception as e:
+                    log.error(f"Error getting bot info: {e}")
+        else:
+            source = f"Slack message from {individual.name}"
+        dispatch_user_id = None
+        if individual:
+            dispatch_user = auth_service.get_by_email(db_session=db_session, email=individual.email)
+            dispatch_user_id = dispatch_user.id if dispatch_user else None
+        event = event_service.log_case_event(
+            db_session=db_session,
+            source=source,
+            description=message_text,
+            case_id=int(context["subject"].id),
+            dispatch_user_id=dispatch_user_id,
+            started_at=message_ts_utc,
+            type=EventType.imported_message,
+            owner=individual.name if individual else "Unknown",
+        )
+        db_session.commit()
+        event_id = event.id
+        log.info(f"Logged case event with ID: {event_id}")
+    else:
+        log.info(f"TIMELINE HANDLER: Unknown subject type: {subject_type}")
 
 
 @message_dispatcher.add(
diff --git a/src/dispatch/static/dispatch/src/case/CaseTimelineTabV1.vue b/src/dispatch/static/dispatch/src/case/CaseTimelineTabV1.vue
index b93af58b28c0..0cda2d0ea61e 100644
--- a/src/dispatch/static/dispatch/src/case/CaseTimelineTabV1.vue
+++ b/src/dispatch/static/dispatch/src/case/CaseTimelineTabV1.vue
@@ -1,31 +1,50 @@
 <template>
   <v-container>
-    <v-row justify="end">
-      <v-switch v-model="showDetails" label="Show details" />
-      <v-btn
-        color="secondary"
-        class="ml-2 mr-2 mt-3"
-        @click="exportToCSV()"
-        :loading="exportLoading"
-      >
-        Export
-      </v-btn>
+    <v-row justify="end" class="align-items-baseline">
+      <v-switch v-model="showDetails" label="Show details" class="flex-grow-0" />
+
+      <timeline-export-dialog :showItem="showItem" :extractOwner="extractOwner" />
+      <timeline-filter-dialog ref="filter_dialog" />
+
+      <edit-event-dialog v-if="showEditEventDialog" />
+      <delete-event-dialog />
     </v-row>
     <template v-if="events && events.length">
       <v-timeline density="compact" clipped>
         <v-timeline-item hide-dot>
-          <v-col class="text-right text-caption">(times in UTC)</v-col>
+          <v-row>
+            <v-col class="text-right text-caption time-zone-notice">(times in UTC)</v-col>
+            <div class="add-event" style="--margtop: 0px; --margbot: 5px; --margrule: 20px">
+              <div class="horiz-rule" />
+              <div class="add-button">
+                <v-btn
+                  compact
+                  size="small"
+                  variant="plain"
+                  class="up-button"
+                  @click="showNewPreEventDialog(sortedEvents[0].started_at)"
+                >
+                  <v-icon size="small" class="mr-1">mdi-plus-circle-outline</v-icon>Add event
+                </v-btn>
+              </div>
+            </div>
+          </v-row>
         </v-timeline-item>
         <v-timeline-item
           v-for="event in sortedEvents"
+          v-show="showItem(event)"
+          :icon="iconItem(event)"
           :key="event.id"
           class="mb-4"
+          :class="classType(event)"
           dot-color="blue"
-          size="small"
         >
+          <template #icon>
+            <v-icon color="white" />
+          </template>
           <v-row justify="space-between">
             <v-col cols="7">
-              {{ event.description }}
+              <span class="force-wrap">{{ event.description }}</span>
               <transition-group name="slide" v-if="showDetails">
                 <template v-for="(value, key) in event.details" :key="key">
                   <v-card>
@@ -40,38 +59,131 @@
                 {{ event.source }}
               </div>
             </v-col>
-            <v-col class="text-right" cols="5">
-              <v-tooltip location="bottom">
-                <template #activator="{ props }">
-                  <span v-bind="props" class="wavy-underline">{{
-                    formatToUTC(event.started_at)
-                  }}</span>
-                </template>
-                <span class="pre-formatted">{{ formatToTimeZones(event.started_at) }}</span>
-              </v-tooltip>
+            <v-col cols="1">
+              <div v-if="isEditable(event)" class="custom-event-edit">
+                <v-btn variant="plain" @click="showNewEditEventDialog(event)">
+                  <v-icon>mdi-pencil</v-icon>
+                </v-btn>
+                <br />
+                <v-btn variant="plain" @click="togglePin(event)">
+                  <v-hover v-slot="{ isHovering, props }">
+                    <v-icon v-if="!isPinned(event)" v-bind="props">mdi-pin-outline</v-icon>
+                    <v-icon v-else-if="isHovering && isPinned(event)" v-bind="props">
+                      mdi-pin-off
+                    </v-icon>
+                    <v-icon v-else-if="!isHovering && isPinned(event)" v-bind="props">
+                      mdi-pin
+                    </v-icon>
+                  </v-hover>
+                </v-btn>
+                <br />
+                <v-btn variant="plain" @click="showDeleteEventDialog(event)">
+                  <v-icon>mdi-trash-can</v-icon>
+                </v-btn>
+              </div>
+              <div v-if="isPinned(event) && !isEditable(event)" class="pinned-event">
+                <v-btn variant="plain" @click="togglePin(event)">
+                  <v-hover v-slot="{ isHovering, props }">
+                    <v-icon v-if="isHovering" v-bind="props">mdi-pin-off</v-icon>
+                    <v-icon v-else v-bind="props">mdi-pin</v-icon>
+                  </v-hover>
+                </v-btn>
+              </div>
+              <div v-if="isPinned(event) && isEditable(event)" class="pinned-custom-event">
+                <v-btn variant="plain" @click="togglePin(event)">
+                  <v-icon>mdi-pin</v-icon>
+                </v-btn>
+              </div>
+              <div v-else-if="!isPinned(event) && !isEditable(event)" class="pinned-event">
+                <v-btn variant="plain" @click="togglePin(event)">
+                  <v-icon>mdi-pin-outline</v-icon>
+                </v-btn>
+              </div>
+            </v-col>
+            <v-col class="text-right" cols="4">
+              <v-col>
+                <v-tooltip location="bottom">
+                  <template #activator="{ props }">
+                    <span v-bind="props" class="wavy-underline">{{
+                      formatToUTC(event.started_at)
+                    }}</span>
+                  </template>
+                  <span class="pre-formatted">{{ formatToTimeZones(event.started_at) }}</span>
+                </v-tooltip>
+              </v-col>
             </v-col>
           </v-row>
+          <v-row>
+            <div class="add-event" style="--margtop: -40px; --margbot: 0px; --margrule: 40px">
+              <div class="horiz-rule" />
+              <div class="add-button">
+                <v-btn
+                  compact
+                  size="small"
+                  variant="plain"
+                  class="up-button"
+                  @click="showNewEventDialog(event.started_at)"
+                >
+                  <v-icon size="small" class="mr-1">mdi-plus-circle-outline</v-icon>Add event
+                </v-btn>
+              </div>
+            </div>
+          </v-row>
         </v-timeline-item>
       </v-timeline>
     </template>
     <div v-else>
       <p class="text-center">No timeline data available.</p>
     </div>
+    <div class="text-caption ml-3 mt-10" v-if="countHidden() !== 0">
+      {{ "" + countHidden() }} event(s) are hidden due to current filter
+    </div>
   </v-container>
 </template>
 
 <script>
+import { sum } from "lodash"
 import { mapFields } from "vuex-map-fields"
-import Util from "@/util"
+import { mapActions } from "vuex"
+
 import { snakeToCamel, formatToUTC, formatToTimeZones } from "@/filters"
 
+import TimelineFilterDialog from "@/case/TimelineFilterDialog.vue"
+import TimelineExportDialog from "./TimelineExportDialog.vue"
+import EditEventDialog from "@/case/EditEventDialog.vue"
+import DeleteEventDialog from "@/case/DeleteEventDialog.vue"
+
+const eventTypeToIcon = {
+  Other: "mdi-monitor-star",
+  "Field updated": "mdi-subtitles-outline",
+  "Assessment updated": "mdi-priority-high",
+  "Participant updated": "mdi-account-outline",
+  "Custom event": "mdi-text-account",
+  "Imported message": "mdi-page-next-outline",
+}
+
+const eventTypeToFilter = {
+  Other: "other_events",
+  "Field updated": "field_updates",
+  "Assessment updated": "assessment_updates",
+  "Participant updated": "participant_updates",
+  "Custom event": "user_curated_events",
+  "Imported message": "user_curated_events",
+}
+
 export default {
-  name: "CaseTimelineTabOld",
+  name: "CaseTimelineTabV1",
+
+  components: {
+    TimelineFilterDialog,
+    EditEventDialog,
+    DeleteEventDialog,
+    TimelineExportDialog,
+  },
 
   data() {
     return {
       showDetails: false,
-      exportLoading: false,
     }
   },
 
@@ -80,19 +192,58 @@ export default {
   },
 
   computed: {
-    ...mapFields("case_management", ["selected.events", "selected.name"]),
+    ...mapFields("case_management", [
+      "selected.events",
+      "selected.name",
+      "timeline_filters",
+      "dialogs.showEditEventDialog",
+    ]),
 
     sortedEvents: function () {
       return this.events.slice().sort((a, b) => new Date(a.started_at) - new Date(b.started_at))
     },
   },
-
   methods: {
-    exportToCSV() {
-      this.exportLoading = true
-      let items = this.sortedEvents
-      Util.exportCSV(items, this.name + "-timeline-export.csv")
-      this.exportLoading = false
+    ...mapActions("case_management", [
+      "showNewEventDialog",
+      "showNewEditEventDialog",
+      "showDeleteEventDialog",
+      "showNewPreEventDialog",
+      "togglePin",
+    ]),
+    iconItem(event) {
+      if (event.description == "Case created") return "mdi-flare"
+      return eventTypeToIcon[event.type]
+    },
+    extractOwner(event) {
+      if (event.owner != null && event.owner != "") return event.owner
+      return "Dispatch"
+    },
+    countHidden() {
+      if (!this.events) return 0
+      return sum(
+        this.events.map((e) => {
+          return this.timeline_filters[eventTypeToFilter[e.type]] || false
+        })
+      )
+    },
+    showItem(event) {
+      if (event.pinned) {
+        return true
+      }
+      return !this.timeline_filters[eventTypeToFilter[event.type]]
+    },
+    isEditable(event) {
+      return event.type == "Custom event" || event.type == "Imported message"
+    },
+    classType(event) {
+      if (event.type == "Custom event" || event.type == "Imported message") {
+        return "custom-event"
+      }
+      return "pinned-event"
+    },
+    isPinned(event) {
+      return event.pinned
     },
   },
 }
diff --git a/src/dispatch/static/dispatch/src/case/DeleteEventDialog.vue b/src/dispatch/static/dispatch/src/case/DeleteEventDialog.vue
new file mode 100644
index 000000000000..a2fa8736a7d8
--- /dev/null
+++ b/src/dispatch/static/dispatch/src/case/DeleteEventDialog.vue
@@ -0,0 +1,35 @@
+<template>
+  <v-dialog v-model="showDeleteEventDialog" persistent max-width="800px">
+    <v-card>
+      <v-card-title>
+        <span class="text-h5">Delete Event?</span>
+      </v-card-title>
+      <v-card-text>
+        <v-container>Are you sure you want to delete this event?</v-container>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn color="blue en-1" variant="text" @click="closeDeleteEventDialog()"> Cancel </v-btn>
+        <v-btn color="red en-1" variant="text" @click="deleteEvent()"> Delete </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script>
+import { mapFields } from "vuex-map-fields"
+import { mapActions } from "vuex"
+export default {
+  name: "CaseDeleteEventDialog",
+  data() {
+    return {}
+  },
+  computed: {
+    ...mapFields("case_management", ["dialogs.showDeleteEventDialog"]),
+  },
+
+  methods: {
+    ...mapActions("case_management", ["closeDeleteEventDialog", "deleteEvent"]),
+  },
+}
+</script>
diff --git a/src/dispatch/static/dispatch/src/case/EditEventDialog.vue b/src/dispatch/static/dispatch/src/case/EditEventDialog.vue
new file mode 100644
index 000000000000..5b7a7959f57c
--- /dev/null
+++ b/src/dispatch/static/dispatch/src/case/EditEventDialog.vue
@@ -0,0 +1,152 @@
+<template>
+  <v-dialog v-model="showEditEventDialog" persistent max-width="750px">
+    <v-card>
+      <v-card-title>
+        <span v-if="uuid" class="text-h5">Edit event</span>
+        <span v-else class="text-h5">Create new event</span>
+      </v-card-title>
+      <v-card-text>
+        <v-container class="mt-3">
+          <v-row>
+            <v-col cols="5">
+              <date-time-picker-menu
+                label="Reported At"
+                v-model="local_started_at"
+                class="time-picker"
+                :timezone="timezone"
+                @update:model-value="update_started_at"
+              />
+              <span
+                class="ml-10 time-utc text-caption"
+                style="position: absolute; margin-top: -20px"
+              >
+                Time in UTC is {{ formatToUTC(started_at_in_utc) }}
+              </span>
+            </v-col>
+            <v-col cols="5">
+              <v-select
+                v-model="timezone"
+                label="Time zone"
+                :items="timezones"
+                class="ml-2 time-zone-select"
+              />
+            </v-col>
+            <v-col cols="1">
+              <v-btn color="green en-1" class="ml-10 mt-3" width="100" @click="setTimeToNow()">
+                Now
+              </v-btn>
+            </v-col>
+          </v-row>
+          <v-row>
+            <v-col cols="12">
+              <v-textarea
+                v-model="local_description"
+                class="mt-3"
+                label="Description"
+                hint="Description of the event."
+                clearable
+                required
+              />
+            </v-col>
+          </v-row>
+        </v-container>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn variant="text" @click="closeEditEventDialog()"> Cancel </v-btn>
+        <v-btn v-if="uuid" color="green en-1" variant="text" @click="updateEvent()"> OK </v-btn>
+        <v-btn v-else color="green en-1" variant="text" @click="newEvent()"> OK </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script>
+import { mapFields } from "vuex-map-fields"
+import { mapActions } from "vuex"
+import { formatToUTC } from "@/filters"
+
+import DateTimePickerMenu from "@/components/DateTimePickerMenu.vue"
+import moment from "moment-timezone"
+
+export default {
+  name: "CaseEditEventDialog",
+
+  data() {
+    return {
+      timezones: ["UTC", "America/Los_Angeles"],
+      timezone: "UTC",
+      started_at_in_utc: "",
+      local_started_at: null,
+      local_description: "",
+    }
+  },
+
+  setup() {
+    return { formatToUTC }
+  },
+
+  components: {
+    DateTimePickerMenu,
+  },
+
+  computed: {
+    ...mapFields("case_management", [
+      "dialogs.showEditEventDialog",
+      "selected.currentEvent.started_at",
+      "selected.currentEvent.description",
+      "selected.currentEvent.uuid",
+    ]),
+  },
+
+  methods: {
+    ...mapActions("case_management", [
+      "closeEditEventDialog",
+      "storeNewEvent",
+      "updateExistingEvent",
+    ]),
+    init() {
+      const local_zone_name = moment.tz.guess() || "America/Los_Angeles"
+      if (!this.timezones.includes(local_zone_name)) {
+        this.timezones.push(local_zone_name)
+      }
+      this.timezone = local_zone_name
+    },
+    setTimeToNow() {
+      this.local_started_at = new Date()
+    },
+    update_started_at(val) {
+      this.local_started_at = val
+      this.started_at_in_utc = val
+    },
+    updateEvent() {
+      this.description = this.local_description
+      this.started_at = this.local_started_at
+      this.updateExistingEvent()
+    },
+    newEvent() {
+      this.description = this.local_description
+      this.started_at = this.local_started_at
+      this.storeNewEvent()
+    },
+  },
+  mounted() {
+    this.init()
+    this.local_description = this.description
+    this.local_started_at = this.started_at
+  },
+}
+</script>
+
+<style scoped>
+.time-picker {
+  max-width: 500px;
+}
+.time-zone-select {
+  max-width: 250px;
+}
+
+.time-utc {
+  margin-top: -15px;
+}
+</style>
diff --git a/src/dispatch/static/dispatch/src/case/TimelineExportDialog.vue b/src/dispatch/static/dispatch/src/case/TimelineExportDialog.vue
new file mode 100644
index 000000000000..f3e65c139806
--- /dev/null
+++ b/src/dispatch/static/dispatch/src/case/TimelineExportDialog.vue
@@ -0,0 +1,162 @@
+<template>
+  <div class="d-flex justify-space-around">
+    <v-menu>
+      <template #activator="{ props }">
+        <v-btn color="secondary" class="ml-2 mr-2 mt-3" v-bind="props"> Export </v-btn>
+      </template>
+      <v-list>
+        <v-list-item @click="exportAsCSV()">Export to CSV </v-list-item>
+        <v-list-item @click="showExportDialog = true">Export to Doc </v-list-item>
+      </v-list>
+    </v-menu>
+
+    <v-dialog v-model="showExportDialog" persistent max-width="800px">
+      <v-card>
+        <v-card-title>
+          <span class="text-h5" style="margin-bottom: 10px">Export Timeline Events</span>
+        </v-card-title>
+
+        <v-card-subtitle class="subtitle_top">
+          Exports the current filtered timeline events directly into a document
+        </v-card-subtitle>
+
+        <v-card-text>
+          <v-checkbox class="mt-3" label="Also export Owner field" v-model="exportOwner" />
+          <v-select
+            v-model="timezone"
+            label="Time zone"
+            style="margin-top: -20px"
+            :items="timezones"
+            class="ml-2 time-zone-select"
+          />
+        </v-card-text>
+
+        <div class="note-message font-weight-bold">
+          Note: Exporting events will overwrite the table under Timeline in the document.
+        </div>
+
+        <v-card-actions>
+          <v-spacer />
+          <v-btn color="red en-1" variant="text" @click="cancel()"> Cancel </v-btn>
+          <v-btn color="blue en-1" variant="text" @click="handleDocExport()"> Submit </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+  </div>
+</template>
+
+<script>
+import { mapActions } from "vuex"
+import { mapFields } from "vuex-map-fields"
+import Util from "@/util"
+import moment from "moment-timezone"
+const eventTypeToFilter = {
+  Other: "other_events",
+  "Field updated": "field_updates",
+  "Assessment updated": "assessment_updates",
+  "Participant updated": "participant_updates",
+  "Custom event": "user_curated_events",
+  "Imported message": "user_curated_events",
+}
+
+export default {
+  name: "CaseTimelineExportDialog",
+  props: {
+    showItem: Function,
+    extractOwner: Function,
+  },
+
+  data() {
+    return {
+      showExportDialog: false,
+      timezones: ["UTC", "America/Los_Angeles"],
+      timezone: "UTC",
+      user_timeline_filters: {},
+      exportOwner: false,
+    }
+  },
+  computed: {
+    ...mapFields("case_management", [
+      "selected.events",
+      "selected.name",
+      "timeline_filters",
+      "selected.status",
+    ]),
+
+    sortedEvents: function () {
+      return this.events.slice().sort((a, b) => new Date(a.started_at) - new Date(b.started_at))
+    },
+  },
+
+  methods: {
+    ...mapActions("case_management", ["getAll"]),
+    cancel() {
+      this.showExportDialog = false
+    },
+    exportAsCSV() {
+      const selected_items = []
+      let items = this.sortedEvents
+
+      items.forEach((item) => {
+        if (this.showItem(item)) {
+          selected_items.push(item)
+        }
+      })
+      Util.exportCSV(
+        selected_items.map((item) => ({
+          "Time (in UTC)": item.started_at,
+          Description: item.description,
+          Owner: this.extractOwner(item),
+        })),
+        this.name + "-timeline-export.csv"
+      )
+    },
+    init() {
+      const local_zone_name = moment.tz.guess() || "America/Los_Angeles"
+      if (!this.timezones.includes(local_zone_name)) {
+        this.timezones.push(local_zone_name)
+      }
+      this.timezone = local_zone_name
+    },
+    mounted() {
+      this.init()
+    },
+    isActive() {
+      if (this.status == "Active") {
+        return true
+      }
+      return false
+    },
+    handleDocExport() {
+      let user_timeline_filters = this.getUserFilters()
+      user_timeline_filters["caseDocument"] = true
+      user_timeline_filters["timezone"] = this.timezone
+      user_timeline_filters["exportOwner"] = this.exportOwner
+      this.$store.dispatch("case_management/exportDoc", user_timeline_filters)
+      this.showExportDialog = false
+    },
+
+    getUserFilters() {
+      for (const key in eventTypeToFilter) {
+        if (this.timeline_filters[eventTypeToFilter[key]] === true) {
+          this.user_timeline_filters[key] = false
+        } else {
+          this.user_timeline_filters[key] = true
+        }
+      }
+      return this.user_timeline_filters
+    },
+  },
+}
+</script>
+<style>
+.note-message {
+  color: rgb(243, 89, 89);
+  margin-left: 30px;
+  margin-bottom: 10px;
+}
+.error {
+  color: rgb(243, 89, 89);
+  margin-top: -30px;
+}
+</style>
diff --git a/src/dispatch/static/dispatch/src/case/TimelineFilterDialog.vue b/src/dispatch/static/dispatch/src/case/TimelineFilterDialog.vue
new file mode 100644
index 000000000000..1c91587abedd
--- /dev/null
+++ b/src/dispatch/static/dispatch/src/case/TimelineFilterDialog.vue
@@ -0,0 +1,153 @@
+<template>
+  <v-dialog v-model="display" max-width="350px">
+    <template #activator="{ props }">
+      <v-badge
+        :model-value="numFilters"
+        bordered
+        color="info"
+        :content="numFilters"
+        class="mt-3 mr-3"
+      >
+        <v-btn color="secondary" v-bind="props">
+          <v-icon start class="mr-1">mdi-filter</v-icon> Filter
+        </v-btn>
+      </v-badge>
+    </template>
+    <v-card>
+      <v-card-title>
+        <span class="text-h5">Timeline Filters</span>
+      </v-card-title>
+      <v-card-subtitle class="subtitle_top">
+        Only show the following types of events
+      </v-card-subtitle>
+      <v-list density="compact">
+        <v-list-item>
+          <template #prepend>
+            <v-checkbox-btn v-model="local_filters.assessment_updates" color="#e50815" />
+          </template>
+          <v-list-item-title>
+            <v-icon start class="mr-2">mdi-priority-high</v-icon>
+            Assessment updates
+          </v-list-item-title>
+          <v-list-item-subtitle>Priority, severity, and status</v-list-item-subtitle>
+        </v-list-item>
+        <v-list-item>
+          <template #prepend>
+            <v-checkbox-btn v-model="local_filters.user_curated_events" color="#e50815" />
+          </template>
+          <v-list-item-title>
+            <v-icon start class="mr-2">mdi-text-account</v-icon>
+            User-curated events
+          </v-list-item-title>
+          <v-list-item-subtitle>Custom events and imported messages</v-list-item-subtitle>
+        </v-list-item>
+        <v-list-item>
+          <template #prepend>
+            <v-checkbox-btn v-model="local_filters.field_updates" color="#e50815" />
+          </template>
+          <v-list-item-title>
+            <v-icon start class="mr-2">mdi-subtitles-outline</v-icon>
+            Field updates
+          </v-list-item-title>
+          <v-list-item-subtitle>
+            Fields like title, description, tags, type, etc.
+          </v-list-item-subtitle>
+        </v-list-item>
+        <v-list-item>
+          <template #prepend>
+            <v-checkbox-btn v-model="local_filters.participant_updates" color="#e50815" />
+          </template>
+          <v-list-item-title>
+            <v-icon start class="mr-2">mdi-account-outline</v-icon>
+            Participant updates
+          </v-list-item-title>
+          <v-list-item-subtitle>Added/removed participants and role changes</v-list-item-subtitle>
+        </v-list-item>
+        <v-list-item>
+          <template #prepend>
+            <v-checkbox-btn v-model="local_filters.other_events" color="#e50815" />
+          </template>
+          <v-list-item-title>
+            <v-icon start class="mr-2">mdi-monitor-star</v-icon>
+            Other events
+          </v-list-item-title>
+          <v-list-item-subtitle>System events, resource creation, etc.</v-list-item-subtitle>
+        </v-list-item>
+      </v-list>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn color="info" variant="text" @click="applyFilters()"> Apply Filters </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script>
+import { sum } from "lodash"
+import { mapFields } from "vuex-map-fields"
+
+function invertBooleanValues(obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[key] = !obj[key]
+    return acc
+  }, {})
+}
+
+export default {
+  name: "CaseTimelineFilterDialog",
+
+  props: {
+    projects: {
+      type: Array,
+      default: function () {
+        return []
+      },
+    },
+  },
+
+  data() {
+    return {
+      display: false,
+      local_filters: {
+        field_updates: false,
+        assessment_updates: true,
+        user_curated_events: true,
+        participant_updates: false,
+        other_events: false,
+      },
+    }
+  },
+
+  computed: {
+    ...mapFields("case_management", ["timeline_filters"]),
+    numFilters: function () {
+      return sum(Object.values(this.timeline_filters))
+    },
+  },
+
+  methods: {
+    applyFilters() {
+      this.timeline_filters = invertBooleanValues(this.local_filters)
+      this.display = false
+    },
+  },
+
+  created() {
+    this.$watch(
+      (vm) => [vm.display],
+      () => {
+        if (this.display) {
+          // copy actual to local on dialog show
+          this.local_filters = invertBooleanValues(this.timeline_filters)
+        }
+      }
+    )
+  },
+}
+</script>
+
+<style scoped lang="scss">
+.subtitle_top {
+  margin-top: -10px;
+}
+</style>
diff --git a/src/dispatch/static/dispatch/src/case/api.js b/src/dispatch/static/dispatch/src/case/api.js
index baa5ce97cb11..a1216735df4d 100644
--- a/src/dispatch/static/dispatch/src/case/api.js
+++ b/src/dispatch/static/dispatch/src/case/api.js
@@ -62,4 +62,20 @@ export default {
   createCaseChannel(caseId, payload) {
     return API.post(`/${resource}/${caseId}/resources/conversation`, payload)
   },
+
+  createNewEvent(caseId, payload) {
+    return API.post(`/${resource}/${caseId}/event`, payload)
+  },
+
+  updateEvent(caseId, payload) {
+    return API.patch(`/${resource}/${caseId}/event`, payload)
+  },
+
+  deleteEvent(caseId, event_uuid) {
+    return API.delete(`/${resource}/${caseId}/event/${event_uuid}`)
+  },
+
+  exportTimeline(caseId, timeline_filters) {
+    return API.post(`/${resource}/${caseId}/exportTimeline`, timeline_filters)
+  },
 }
diff --git a/src/dispatch/static/dispatch/src/case/store.js b/src/dispatch/static/dispatch/src/case/store.js
index 5eff0a806e6c..5aabed8339c5 100644
--- a/src/dispatch/static/dispatch/src/case/store.js
+++ b/src/dispatch/static/dispatch/src/case/store.js
@@ -48,6 +48,17 @@ const getDefaultSelectedState = () => {
     visibility: null,
     workflow_instances: null,
     event: false,
+    currentEvent: {
+      uuid: null,
+      source: "",
+      description: "",
+      started_at: null,
+      ended_at: null,
+      type: "Custom event",
+      details: {},
+      owner: "",
+      pinned: false,
+    },
   }
 }
 
@@ -67,6 +78,8 @@ const state = {
     showHandoffDialog: false,
     showClosedDialog: false,
     showNewSheet: false,
+    showEditEventDialog: false,
+    showDeleteEventDialog: false,
   },
   report: {
     ...getDefaultReportState(),
@@ -107,6 +120,13 @@ const state = {
     loading: false,
     bulkEditLoading: false,
   },
+  timeline_filters: {
+    field_updates: true,
+    assessment_updates: false,
+    user_curated_events: false,
+    participant_updates: true,
+    other_events: true,
+  },
   default_project: null,
   current_user_role: null,
 }
@@ -471,6 +491,169 @@ const actions = {
       }, [])
     })
   },
+  // Timeline event actions
+  showNewEventDialog({ commit }, started_at) {
+    commit("SET_SELECTED_CURRENT_EVENT", {
+      uuid: null,
+      source: "Case Participant",
+      description: "",
+      started_at: started_at,
+      ended_at: started_at,
+      type: "Custom event",
+      details: {},
+      owner: "",
+      pinned: false,
+    })
+    commit("SET_DIALOG_EDIT_EVENT", true)
+  },
+  showNewEditEventDialog({ commit }, event) {
+    commit("SET_SELECTED_CURRENT_EVENT", {
+      uuid: event.uuid,
+      source: event.source,
+      description: event.description,
+      started_at: event.started_at,
+      ended_at: event.started_at,
+      type: event.type,
+      details: event.details,
+      owner: event.owner,
+      pinned: event.pinned,
+    })
+    commit("SET_DIALOG_EDIT_EVENT", true)
+  },
+  showDeleteEventDialog({ commit }, event) {
+    commit("SET_SELECTED_CURRENT_EVENT", {
+      started_at: event.started_at,
+      description: event.description,
+      uuid: event.uuid,
+    })
+    commit("SET_DIALOG_DELETE_EVENT", true)
+  },
+  showNewPreEventDialog({ commit }, started_at) {
+    commit("SET_SELECTED_CURRENT_EVENT", {
+      uuid: null,
+      source: "Case Participant",
+      description: "",
+      started_at: started_at,
+      ended_at: started_at,
+      type: "Custom event",
+      details: {},
+      owner: "",
+      pinned: false,
+    })
+    commit("SET_DIALOG_EDIT_EVENT", true)
+  },
+  closeEditEventDialog({ commit }) {
+    commit("SET_DIALOG_EDIT_EVENT", false)
+  },
+  closeDeleteEventDialog({ commit }) {
+    commit("SET_DIALOG_DELETE_EVENT", false)
+  },
+  storeNewEvent({ commit, dispatch }) {
+    commit("SET_SELECTED_LOADING", true)
+    return CaseApi.createNewEvent(state.selected.id, {
+      source: "Case Participant",
+      description: state.selected.currentEvent.description,
+      started_at: state.selected.currentEvent.started_at,
+      type: "Custom event",
+      details: {},
+    })
+      .then(() => {
+        dispatch("getDetails", { id: state.selected.id })
+        commit("SET_DIALOG_EDIT_EVENT", false)
+        commit(
+          "notification_backend/addBeNotification",
+          { text: "Event created successfully.", type: "success" },
+          { root: true }
+        )
+        commit("SET_SELECTED_LOADING", false)
+      })
+      .catch(() => {
+        commit("SET_SELECTED_LOADING", false)
+      })
+  },
+  updateExistingEvent({ commit, dispatch }) {
+    commit("SET_SELECTED_LOADING", true)
+    return CaseApi.updateEvent(state.selected.id, {
+      uuid: state.selected.currentEvent.uuid,
+      source: state.selected.currentEvent.source,
+      description: state.selected.currentEvent.description,
+      started_at: state.selected.currentEvent.started_at,
+      ended_at: state.selected.currentEvent.ended_at,
+      type: state.selected.currentEvent.type || "Custom event",
+      details: state.selected.currentEvent.details || {},
+      owner: state.selected.currentEvent.owner || "",
+      pinned: state.selected.currentEvent.pinned || false,
+    })
+      .then(() => {
+        dispatch("getDetails", { id: state.selected.id })
+        commit("SET_DIALOG_EDIT_EVENT", false)
+        commit(
+          "notification_backend/addBeNotification",
+          { text: "Event updated successfully.", type: "success" },
+          { root: true }
+        )
+        commit("SET_SELECTED_LOADING", false)
+      })
+      .catch(() => {
+        commit("SET_SELECTED_LOADING", false)
+      })
+  },
+  deleteEvent({ commit, dispatch }) {
+    commit("SET_SELECTED_LOADING", true)
+    return CaseApi.deleteEvent(state.selected.id, state.selected.currentEvent.uuid)
+      .then(() => {
+        dispatch("getDetails", { id: state.selected.id })
+        commit("SET_DIALOG_DELETE_EVENT", false)
+        commit(
+          "notification_backend/addBeNotification",
+          { text: "Event deleted successfully.", type: "success" },
+          { root: true }
+        )
+        commit("SET_SELECTED_LOADING", false)
+      })
+      .catch(() => {
+        commit("SET_SELECTED_LOADING", false)
+      })
+  },
+  togglePin({ commit, dispatch }, event) {
+    commit("SET_SELECTED_LOADING", true)
+    return CaseApi.updateEvent(state.selected.id, {
+      uuid: event.uuid,
+      source: event.source,
+      description: event.description,
+      started_at: event.started_at,
+      ended_at: event.started_at,
+      type: event.type || "Custom event",
+      details: event.details || {},
+      owner: event.owner || "",
+      pinned: !event.pinned,
+    })
+      .then(() => {
+        dispatch("getDetails", { id: state.selected.id })
+        commit("SET_SELECTED_LOADING", false)
+      })
+      .catch(() => {
+        commit("SET_SELECTED_LOADING", false)
+      })
+  },
+  exportDoc({ commit }, timeline_filters) {
+    commit(
+      "notification_backend/addBeNotification",
+      { text: "Timeline export initiated. This may take a few minutes.", type: "success" },
+      { root: true }
+    ),
+      CaseApi.exportTimeline(state.selected.id, timeline_filters)
+        .then(() => {
+          commit(
+            "notification_backend/addBeNotification",
+            { text: "Timeline exported successfully.", type: "success" },
+            { root: true }
+          )
+        })
+        .catch(() => {
+          commit("SET_DIALOG_EDIT_EVENT", false)
+        })
+  },
 }
 
 const mutations = {
@@ -534,6 +717,15 @@ const mutations = {
   SET_CURRENT_USER_ROLE(state, value) {
     state.current_user_role = value
   },
+  SET_SELECTED_CURRENT_EVENT(state, value) {
+    state.selected.currentEvent = value
+  },
+  SET_DIALOG_EDIT_EVENT(state, value) {
+    state.dialogs.showEditEventDialog = value
+  },
+  SET_DIALOG_DELETE_EVENT(state, value) {
+    state.dialogs.showDeleteEventDialog = value
+  },
 }
 
 export default {
diff --git a/tests/case/test_case_event_views.py b/tests/case/test_case_event_views.py
new file mode 100644
index 000000000000..b790ed789f5e
--- /dev/null
+++ b/tests/case/test_case_event_views.py
@@ -0,0 +1,246 @@
+from datetime import datetime
+
+from dispatch.case.models import Case
+from dispatch.auth.models import DispatchUser
+from dispatch.event.models import EventCreateMinimal, EventUpdate
+
+
+def test_create_custom_event(
+    session,
+    case: Case,
+    user: DispatchUser,
+    organization,
+):
+    """Tests the creation of a custom case event."""
+    # Ensure the case is associated with the organization
+    case.project.organization = organization
+    session.add(case.project)
+    session.commit()
+
+    # Add user as a participant to the case so they have permissions
+    from dispatch.participant import flows as participant_flows
+    from dispatch.participant_role.models import ParticipantRoleType
+
+    participant_flows.add_participant(
+        user.email,
+        case,
+        session,
+        roles=[ParticipantRoleType.assignee],
+    )
+
+    # Import the view function directly
+    from dispatch.case.views import create_custom_event
+    from starlette.background import BackgroundTasks
+
+    now = datetime.utcnow()
+    event_in = EventCreateMinimal(
+        source="Case Participant",
+        description="This is a test event",
+        started_at=now,
+        type="Custom event",
+        details={},
+    )
+
+    # Call the view function directly
+    background_tasks = BackgroundTasks()
+    create_custom_event(
+        db_session=session,
+        organization=organization.slug,
+        case_id=case.id,
+        current_case=case,
+        event_in=event_in,
+        current_user=user,
+        background_tasks=background_tasks,
+    )
+
+    # The function should complete without error
+    assert True
+
+
+def test_update_custom_event(
+    session,
+    case: Case,
+    user: DispatchUser,
+    organization,
+):
+    """Tests updating a custom case event."""
+    # Ensure the case is associated with the organization
+    case.project.organization = organization
+    session.add(case.project)
+    session.commit()
+
+    # Add user as a participant to the case so they have permissions
+    from dispatch.participant import flows as participant_flows
+    from dispatch.participant_role.models import ParticipantRoleType
+
+    participant_flows.add_participant(
+        user.email,
+        case,
+        session,
+        roles=[ParticipantRoleType.assignee],
+    )
+
+    # First create an event via the service to get a UUID
+    from dispatch.event.service import log_case_event
+
+    event = log_case_event(
+        db_session=session,
+        source="Case Participant",
+        description="Initial description",
+        case_id=case.id,
+        started_at=datetime.utcnow(),
+        type="Custom event",
+    )
+
+    # Import the view function directly
+    from dispatch.case.views import update_custom_event
+    from starlette.background import BackgroundTasks
+
+    now = datetime.utcnow()
+    update_data = EventUpdate(
+        uuid=event.uuid,
+        source="Case Participant",  # Should preserve the source
+        description="Updated description",
+        started_at=now,
+        ended_at=now,
+        type="Custom event",
+        details={},
+        owner="",
+        pinned=False,
+    )
+
+    # Call the view function directly
+    background_tasks = BackgroundTasks()
+    update_custom_event(
+        db_session=session,
+        organization=organization.slug,
+        case_id=case.id,
+        current_case=case,
+        event_in=update_data,
+        current_user=user,
+        background_tasks=background_tasks,
+    )
+
+    # The function should complete without error
+    assert True
+
+
+def test_update_custom_event_preserves_source(
+    session,
+    case: Case,
+    user: DispatchUser,
+    organization,
+):
+    """Tests that updating a case event preserves the original source."""
+    # Ensure the case is associated with the organization
+    case.project.organization = organization
+    session.add(case.project)
+    session.commit()
+
+    # Add user as a participant to the case so they have permissions
+    from dispatch.participant import flows as participant_flows
+    from dispatch.participant_role.models import ParticipantRoleType
+
+    participant_flows.add_participant(
+        user.email,
+        case,
+        session,
+        roles=[ParticipantRoleType.assignee],
+    )
+
+    # Create an event with a specific source
+    from dispatch.event.service import log_case_event
+
+    original_source = "Slack message from John Doe"
+    event = log_case_event(
+        db_session=session,
+        source=original_source,
+        description="Initial description",
+        case_id=case.id,
+        started_at=datetime.utcnow(),
+        type="Custom event",
+    )
+
+    # Test the service function directly instead of the view function
+    from dispatch.event.service import update_case_event
+
+    now = datetime.utcnow()
+    update_data = EventUpdate(
+        uuid=event.uuid,
+        source=original_source,  # Preserve the original source
+        description="Updated description",
+        started_at=now,
+        ended_at=now,
+        type="Custom event",
+        details={},
+        owner="",
+        pinned=False,
+    )
+
+    # Call the service function directly
+    update_case_event(
+        db_session=session,
+        event_in=update_data,
+    )
+
+    # Verify the source was preserved by checking the event in the database
+    from dispatch.event.service import get_by_uuid
+
+    updated_event = get_by_uuid(db_session=session, uuid=event.uuid)
+    assert updated_event.source == original_source
+    assert updated_event.description == "Updated description"
+
+
+def test_delete_custom_event(
+    session,
+    case: Case,
+    user: DispatchUser,
+    organization,
+):
+    """Tests deleting a custom case event."""
+    # Ensure the case is associated with the organization
+    case.project.organization = organization
+    session.add(case.project)
+    session.commit()
+
+    # Add user as a participant to the case so they have permissions
+    from dispatch.participant import flows as participant_flows
+    from dispatch.participant_role.models import ParticipantRoleType
+
+    participant_flows.add_participant(
+        user.email,
+        case,
+        session,
+        roles=[ParticipantRoleType.assignee],
+    )
+
+    # First create an event via the service to get a UUID
+    from dispatch.event.service import log_case_event
+
+    event = log_case_event(
+        db_session=session,
+        source="Case Participant",
+        description="Event to delete",
+        case_id=case.id,
+        started_at=datetime.utcnow(),
+        type="Custom event",
+    )
+
+    # Import the view function directly
+    from dispatch.case.views import delete_custom_event
+    from starlette.background import BackgroundTasks
+
+    # Call the view function directly
+    background_tasks = BackgroundTasks()
+    delete_custom_event(
+        db_session=session,
+        organization=organization.slug,
+        case_id=case.id,
+        current_case=case,
+        event_uuid=str(event.uuid),
+        current_user=user,
+        background_tasks=background_tasks,
+    )
+
+    # The function should complete without error
+    assert True
diff --git a/tests/case/test_case_service.py b/tests/case/test_case_service.py
index c06ada6a175a..f3c0054d8cbc 100644
--- a/tests/case/test_case_service.py
+++ b/tests/case/test_case_service.py
@@ -10,13 +10,13 @@
 def test_get(session, case: Case):
     from dispatch.case.service import get
 
-    case_id = getattr(case, 'id', None)
+    case_id = getattr(case, "id", None)
     if case_id is None:
         raise AssertionError("case.id is None; cannot run test_get.")
-    if hasattr(case_id, '__int__'):
+    if hasattr(case_id, "__int__"):
         case_id = int(case_id)
     t_case = get(db_session=session, case_id=case_id)
-    if t_case is not None and getattr(t_case, 'id', None) is not None:
+    if t_case is not None and getattr(t_case, "id", None) is not None:
         assert isinstance(t_case.id, int)
         assert t_case.id == case_id
     else:
@@ -26,13 +26,13 @@ def test_get(session, case: Case):
 def test_get_by_name(session, case: Case):
     from dispatch.case.service import get_by_name
 
-    case_name = getattr(case, 'name', None)
+    case_name = getattr(case, "name", None)
     if case_name is None:
         raise AssertionError("case.name is None; cannot run test_get_by_name.")
-    if hasattr(case_name, '__str__'):
+    if hasattr(case_name, "__str__"):
         case_name = str(case_name)
     t_case = get_by_name(db_session=session, project_id=case.project.id, name=case_name)
-    if t_case is not None and getattr(t_case, 'name', None) is not None:
+    if t_case is not None and getattr(t_case, "name", None) is not None:
         assert isinstance(t_case.name, str)
         assert t_case.name == case_name
     else:
@@ -71,6 +71,7 @@ def test_create(session, participant, case_type, case_severity, case_priority, p
     from dispatch.case.service import create as create_case
 
     case_type.project = project
+    case_type.oncall_service = None  # Ensure fallback to current_user
     case_severity.project = project
     case_priority.project = project
     session.add(case_type)
@@ -92,7 +93,6 @@ def test_create(session, participant, case_type, case_severity, case_priority, p
         case_priority=case_priority,
         reporter=participant,
         project=project,
-        assignee=participant,
         dedicated_channel=True,
         tags=[],
         event=False,
@@ -131,7 +131,6 @@ def test_create__no_conversation_target(
         case_priority=case_priority,
         reporter=participant,
         project=project,
-        assignee=participant,
         dedicated_channel=True,
         tags=[],
         event=False,
@@ -169,7 +168,6 @@ def test_create__fails_with_no_conversation_target(
         case_priority=case_priority,
         reporter=participant,
         project=project,
-        assignee=participant,
         dedicated_channel=False,
         tags=[],
         event=False,
@@ -210,21 +208,21 @@ def test_update(session, case: Case, project):
         db_session=session, case=case, case_in=case_in, current_user=current_user
     )
     if case_out is not None:
-        assert getattr(case_out, 'title', None) == "XXX"
-        assert getattr(case_out, 'description', None) == "YYY"
-        assert getattr(case_out, 'resolution', None) == "True Positive"
-        assert getattr(case_out, 'status', None) == CaseStatus.closed
-        assert getattr(case_out, 'visibility', None) == Visibility.restricted
+        assert getattr(case_out, "title", None) == "XXX"
+        assert getattr(case_out, "description", None) == "YYY"
+        assert getattr(case_out, "resolution", None) == "True Positive"
+        assert getattr(case_out, "status", None) == CaseStatus.closed
+        assert getattr(case_out, "visibility", None) == Visibility.restricted
 
 
 def test_delete(session, case: Case):
     from dispatch.case.service import delete as case_delete
     from dispatch.case.service import get as case_get
 
-    case_id = getattr(case, 'id', None)
+    case_id = getattr(case, "id", None)
     if case_id is None:
         raise AssertionError("case.id is None; cannot run test_delete.")
-    if hasattr(case_id, '__int__'):
+    if hasattr(case_id, "__int__"):
         case_id = int(case_id)
     case_delete(
         db_session=session,