From d7cc9200563b4e1391d220fd4bc2827bd5baa245 Mon Sep 17 00:00:00 2001
From: Aki Kuivas <91662678+asku1990@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:03:53 +0300
Subject: [PATCH] feat(admin-trials): add event creation and empty-event
 lifecycle

  Implement BEJ-103 Gate E2 with full-page trial event creation
  and explicit management of empty events.

  - add contracts, Server Actions, mutations, and persistence use cases
    for creating and deleting trial events
  - require a positive SKL event ID, date, and place during creation
  - default new events to the current Helsinki business date
  - resolve active rule windows through the shared DB repository
  - preserve an event when its final result is deleted
  - allow explicit deletion only for events without results
  - add localized confirmation and toast feedback for event deletion
  - reuse event form fields without changing existing edit behavior
  - retain empty events in admin views while excluding them publicly
  - add focused web, server, DB, and integration coverage
  - update trial-management documentation and the changelog

  Refs: BEJ-103
---
 CHANGELOG.md                                  |   4 +
 .../admin/trials/new/__tests__/page.test.tsx  |  32 +++
 .../web/app/(admin)/admin/trials/new/page.tsx |  10 +
 .../create-admin-trial-event.test.ts          |  84 ++++++++
 .../delete-admin-trial-event.test.ts          |  60 ++++++
 .../trials/manage/create-admin-trial-event.ts |  62 ++++++
 .../trials/manage/delete-admin-trial-event.ts |  62 ++++++
 .../app/actions/admin/trials/manage/index.ts  |   2 +
 ...in-trial-event-create-page-client.test.tsx | 203 ++++++++++++++++++
 .../admin-trial-event-delete-action.test.tsx  | 148 +++++++++++++
 ...trial-event-workspace-page-client.test.tsx |   1 +
 .../admin-trial-selected-event-panel.test.tsx |  34 +++
 .../admin-trials-page-client.test.tsx         |   2 +
 .../admin-trial-event-create-page-client.tsx  |  84 ++++++++
 .../admin-trial-event-delete-action.tsx       |  77 +++++++
 .../admin-trial-event-edit-dialog-helpers.ts  |  31 ++-
 .../trials/admin-trial-event-edit-dialog.tsx  | 137 +-----------
 .../trials/admin-trial-event-form-fields.tsx  | 120 +++++++++++
 ...dmin-trial-event-workspace-page-client.tsx |   2 +
 .../admin-trial-selected-event-panel.tsx      |  12 ++
 .../admin/trials/admin-trials-page-client.tsx |  28 ++-
 apps/web/components/admin/trials/index.ts     |   1 +
 .../trials/__tests__/trial-route.test.ts      |  10 +-
 apps/web/lib/admin/trials/index.ts            |   1 +
 .../submit-admin-trial-event-creation.ts      | 106 +++++++++
 apps/web/lib/admin/trials/trial-route.ts      |   4 +
 .../admin/trials/__tests__/index.test.ts      |   6 +
 .../lib/i18n/messages/admin/trials/manage.ts  |  48 ++++-
 ...-create-admin-trial-event-mutation.test.ts |  66 ++++++
 ...-delete-admin-trial-event-mutation.test.ts |  52 +++++
 apps/web/queries/admin/trials/manage/index.ts |   2 +
 .../use-create-admin-trial-event-mutation.ts  |  42 ++++
 .../use-delete-admin-trial-event-mutation.ts  |  42 ++++
 docs/features/admin-trial-management.md       |  25 ++-
 .../trials/manage/create-admin-trial-event.ts |  15 ++
 .../trials/manage/delete-admin-trial-event.ts |   7 +
 .../contracts/admin/trials/manage/index.ts    |   8 +
 packages/contracts/index.ts                   |   4 +
 .../__tests__/create-trial-event.test.ts      |  68 ++++++
 .../__tests__/delete-trial-entry.test.ts      |  49 +----
 .../__tests__/delete-trial-event.test.ts      |  65 ++++++
 .../admin/trials/manage/create-trial-event.ts |  43 ++++
 .../admin/trials/manage/delete-trial-entry.ts |  22 +-
 .../admin/trials/manage/delete-trial-event.ts |  39 ++++
 packages/db/admin/trials/manage/index.ts      |  10 +
 packages/db/index.ts                          |   8 +
 .../list-active-trial-rule-windows.test.ts    |  32 +++
 packages/db/trials/index.ts                   |   4 +
 .../trials/list-active-trial-rule-windows.ts  |  22 ++
 packages/server/admin/index.ts                |   2 +
 .../create-trial-event.integration.test.ts    |  92 ++++++++
 .../__tests__/create-trial-event.test.ts      | 109 ++++++++++
 .../__tests__/delete-trial-entry.test.ts      |   4 +-
 .../__tests__/delete-trial-event.test.ts      |  64 ++++++
 .../admin/trials/manage/create-trial-event.ts | 155 +++++++++++++
 .../admin/trials/manage/delete-trial-event.ts | 124 +++++++++++
 packages/server/admin/trials/manage/index.ts  |   2 +
 .../parse-admin-trial-event-write-input.ts    | 108 ++++++++++
 .../admin/trials/manage/update-trial-event.ts |  88 ++------
 packages/server/index.ts                      |   2 +
 .../__tests__/upsert-ajok-result.test.ts      |  14 +-
 .../koiratietokanta/upsert-ajok-result.ts     |  10 +-
 62 files changed, 2458 insertions(+), 312 deletions(-)
 create mode 100644 apps/web/app/(admin)/admin/trials/new/__tests__/page.test.tsx
 create mode 100644 apps/web/app/(admin)/admin/trials/new/page.tsx
 create mode 100644 apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-event.test.ts
 create mode 100644 apps/web/app/actions/admin/trials/manage/__tests__/delete-admin-trial-event.test.ts
 create mode 100644 apps/web/app/actions/admin/trials/manage/create-admin-trial-event.ts
 create mode 100644 apps/web/app/actions/admin/trials/manage/delete-admin-trial-event.ts
 create mode 100644 apps/web/components/admin/trials/__tests__/admin-trial-event-create-page-client.test.tsx
 create mode 100644 apps/web/components/admin/trials/__tests__/admin-trial-event-delete-action.test.tsx
 create mode 100644 apps/web/components/admin/trials/admin-trial-event-create-page-client.tsx
 create mode 100644 apps/web/components/admin/trials/admin-trial-event-delete-action.tsx
 create mode 100644 apps/web/components/admin/trials/admin-trial-event-form-fields.tsx
 create mode 100644 apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts
 create mode 100644 apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-event-mutation.test.ts
 create mode 100644 apps/web/queries/admin/trials/manage/__tests__/use-delete-admin-trial-event-mutation.test.ts
 create mode 100644 apps/web/queries/admin/trials/manage/use-create-admin-trial-event-mutation.ts
 create mode 100644 apps/web/queries/admin/trials/manage/use-delete-admin-trial-event-mutation.ts
 create mode 100644 packages/contracts/admin/trials/manage/create-admin-trial-event.ts
 create mode 100644 packages/contracts/admin/trials/manage/delete-admin-trial-event.ts
 create mode 100644 packages/db/admin/trials/manage/__tests__/create-trial-event.test.ts
 create mode 100644 packages/db/admin/trials/manage/__tests__/delete-trial-event.test.ts
 create mode 100644 packages/db/admin/trials/manage/create-trial-event.ts
 create mode 100644 packages/db/admin/trials/manage/delete-trial-event.ts
 create mode 100644 packages/db/trials/__tests__/list-active-trial-rule-windows.test.ts
 create mode 100644 packages/db/trials/list-active-trial-rule-windows.ts
 create mode 100644 packages/server/admin/trials/manage/__tests__/create-trial-event.integration.test.ts
 create mode 100644 packages/server/admin/trials/manage/__tests__/create-trial-event.test.ts
 create mode 100644 packages/server/admin/trials/manage/__tests__/delete-trial-event.test.ts
 create mode 100644 packages/server/admin/trials/manage/create-trial-event.ts
 create mode 100644 packages/server/admin/trials/manage/delete-trial-event.ts
 create mode 100644 packages/server/admin/trials/manage/internal/parse-admin-trial-event-write-input.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f9c7860..c3daad43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,9 +15,13 @@ This project uses a user-facing changelog format.
 ### Added
 
 - Ylläpitäjä voi avata ajokoetapahtuman omalle sivulleen tarkastelua ja nykyisiä muokkaustoimintoja varten.
+- Ylläpitäjä voi luoda ajokoetapahtuman perustietoineen ja avata sen omalle sivulleen ennen koetulosten lisäämistä.
+- Ylläpitäjä voi poistaa tyhjän ajokoetapahtuman sen omalta sivulta.
 
 ### Changed
 
+- Viimeisen koetuloksen poistaminen säilyttää ajokoetapahtuman tyhjänä, kunnes ylläpitäjä poistaa tapahtuman erikseen.
+
 ### Fixed
 
 ### Removed
diff --git a/apps/web/app/(admin)/admin/trials/new/__tests__/page.test.tsx b/apps/web/app/(admin)/admin/trials/new/__tests__/page.test.tsx
new file mode 100644
index 00000000..c48701b1
--- /dev/null
+++ b/apps/web/app/(admin)/admin/trials/new/__tests__/page.test.tsx
@@ -0,0 +1,32 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+import AdminTrialEventCreatePage from "../page";
+
+const { clientPropsRef, toBusinessDateInputValueMock } = vi.hoisted(() => ({
+  clientPropsRef: { current: null as { initialEventDate: string } | null },
+  toBusinessDateInputValueMock: vi.fn(() => "2026-07-21"),
+}));
+
+vi.mock("@/components/admin/trials", () => ({
+  AdminTrialEventCreatePageClient: (props: { initialEventDate: string }) => {
+    clientPropsRef.current = props;
+    return React.createElement("div", null, "create-trial-event");
+  },
+}));
+
+vi.mock("@/lib/admin/core/date", () => ({
+  toBusinessDateInputValue: toBusinessDateInputValueMock,
+}));
+
+describe("AdminTrialEventCreatePage", () => {
+  it("renders the event creation client", () => {
+    expect(renderToStaticMarkup(<AdminTrialEventCreatePage />)).toContain(
+      "create-trial-event",
+    );
+    expect(toBusinessDateInputValueMock).toHaveBeenCalledWith(expect.any(Date));
+    expect(clientPropsRef.current).toEqual({
+      initialEventDate: "2026-07-21",
+    });
+  });
+});
diff --git a/apps/web/app/(admin)/admin/trials/new/page.tsx b/apps/web/app/(admin)/admin/trials/new/page.tsx
new file mode 100644
index 00000000..651a4ae3
--- /dev/null
+++ b/apps/web/app/(admin)/admin/trials/new/page.tsx
@@ -0,0 +1,10 @@
+import { AdminTrialEventCreatePageClient } from "@/components/admin/trials";
+import { toBusinessDateInputValue } from "@/lib/admin/core/date";
+
+export default function AdminTrialEventCreatePage() {
+  return (
+    <AdminTrialEventCreatePageClient
+      initialEventDate={toBusinessDateInputValue(new Date())}
+    />
+  );
+}
diff --git a/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-event.test.ts b/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-event.test.ts
new file mode 100644
index 00000000..df1dc044
--- /dev/null
+++ b/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-event.test.ts
@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminTrialEventAction } from "../create-admin-trial-event";
+
+const { guardMock, userMock, createMock } = vi.hoisted(() => ({
+  guardMock: vi.fn(),
+  userMock: vi.fn(),
+  createMock: vi.fn(),
+}));
+
+vi.mock("@/lib/server/admin-guard", () => ({
+  requireAdminLayoutAccess: guardMock,
+}));
+vi.mock("@/lib/server/current-user", () => ({
+  getSessionCurrentUser: userMock,
+}));
+vi.mock("@beagle/server", () => ({ createAdminTrialEvent: createMock }));
+
+const input = {
+  eventDate: "2026-07-21",
+  eventPlace: "Helsinki",
+  jarjestaja: null,
+  ylituomari: null,
+  ylituomariNumero: null,
+  ytKertomus: null,
+  kennelpiiri: null,
+  kennelpiirinro: null,
+  sklKoeId: 123,
+};
+
+describe("createAdminTrialEventAction", () => {
+  beforeEach(() => {
+    guardMock.mockReset();
+    userMock.mockReset();
+    createMock.mockReset();
+  });
+
+  it("rejects missing admin access", async () => {
+    guardMock.mockResolvedValue({ ok: false, status: 403 });
+
+    await expect(createAdminTrialEventAction(input)).resolves.toMatchObject({
+      hasError: true,
+      errorCode: "FORBIDDEN",
+    });
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it("propagates service errors", async () => {
+    guardMock.mockResolvedValue({ ok: true });
+    userMock.mockResolvedValue({
+      id: "u_1",
+      email: "admin@example.com",
+      role: "ADMIN",
+    });
+    createMock.mockResolvedValue({
+      status: 409,
+      body: { ok: false, code: "SKL_KOE_ID_CONFLICT", error: "Conflict" },
+    });
+
+    await expect(createAdminTrialEventAction(input)).resolves.toEqual({
+      data: null,
+      hasError: true,
+      errorCode: "SKL_KOE_ID_CONFLICT",
+      message: "Conflict",
+    });
+  });
+
+  it("returns navigation data", async () => {
+    guardMock.mockResolvedValue({ ok: true });
+    userMock.mockResolvedValue({
+      id: "u_1",
+      email: "admin@example.com",
+      role: "ADMIN",
+    });
+    createMock.mockResolvedValue({
+      status: 201,
+      body: { ok: true, data: { trialEventId: "event-1" } },
+    });
+
+    await expect(createAdminTrialEventAction(input)).resolves.toEqual({
+      data: { trialEventId: "event-1" },
+      hasError: false,
+    });
+  });
+});
diff --git a/apps/web/app/actions/admin/trials/manage/__tests__/delete-admin-trial-event.test.ts b/apps/web/app/actions/admin/trials/manage/__tests__/delete-admin-trial-event.test.ts
new file mode 100644
index 00000000..4028ac1f
--- /dev/null
+++ b/apps/web/app/actions/admin/trials/manage/__tests__/delete-admin-trial-event.test.ts
@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { deleteAdminTrialEventAction } from "../delete-admin-trial-event";
+
+const { guardMock, userMock, deleteMock } = vi.hoisted(() => ({
+  guardMock: vi.fn(),
+  userMock: vi.fn(),
+  deleteMock: vi.fn(),
+}));
+
+vi.mock("@/lib/server/admin-guard", () => ({
+  requireAdminLayoutAccess: guardMock,
+}));
+vi.mock("@/lib/server/current-user", () => ({
+  getSessionCurrentUser: userMock,
+}));
+vi.mock("@beagle/server", () => ({ deleteAdminTrialEvent: deleteMock }));
+
+describe("deleteAdminTrialEventAction", () => {
+  beforeEach(() => {
+    guardMock.mockReset();
+    userMock.mockReset();
+    deleteMock.mockReset();
+    guardMock.mockResolvedValue({ ok: true });
+    userMock.mockResolvedValue({
+      id: "u_1",
+      email: "admin@example.com",
+      role: "ADMIN",
+    });
+  });
+
+  it("propagates the non-empty conflict", async () => {
+    deleteMock.mockResolvedValue({
+      status: 409,
+      body: { ok: false, code: "TRIAL_EVENT_NOT_EMPTY", error: "Not empty" },
+    });
+
+    await expect(
+      deleteAdminTrialEventAction({ trialEventId: "event-1" }),
+    ).resolves.toEqual({
+      data: null,
+      hasError: true,
+      errorCode: "TRIAL_EVENT_NOT_EMPTY",
+      message: "Not empty",
+    });
+  });
+
+  it("returns the deleted event id", async () => {
+    deleteMock.mockResolvedValue({
+      status: 200,
+      body: { ok: true, data: { deletedTrialEventId: "event-1" } },
+    });
+
+    await expect(
+      deleteAdminTrialEventAction({ trialEventId: "event-1" }),
+    ).resolves.toEqual({
+      data: { deletedTrialEventId: "event-1" },
+      hasError: false,
+    });
+  });
+});
diff --git a/apps/web/app/actions/admin/trials/manage/create-admin-trial-event.ts b/apps/web/app/actions/admin/trials/manage/create-admin-trial-event.ts
new file mode 100644
index 00000000..e8cf4d9d
--- /dev/null
+++ b/apps/web/app/actions/admin/trials/manage/create-admin-trial-event.ts
@@ -0,0 +1,62 @@
+"use server";
+
+import type {
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { createAdminTrialEvent } from "@beagle/server";
+import { requireAdminLayoutAccess } from "@/lib/server/admin-guard";
+import { getSessionCurrentUser } from "@/lib/server/current-user";
+
+export type CreateAdminTrialEventActionResult = {
+  data: CreateAdminTrialEventResponse | null;
+  hasError: boolean;
+  errorCode?: string;
+  message?: string;
+};
+
+export async function createAdminTrialEventAction(
+  input: CreateAdminTrialEventRequest,
+): Promise<CreateAdminTrialEventActionResult> {
+  const adminAccess = await requireAdminLayoutAccess();
+  if (!adminAccess.ok) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: adminAccess.status === 401 ? "UNAUTHENTICATED" : "FORBIDDEN",
+      message: "Admin access required.",
+    };
+  }
+
+  const currentUser = await getSessionCurrentUser();
+  if (!currentUser) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: "UNAUTHENTICATED",
+      message: "Admin access required.",
+    };
+  }
+
+  const result = await createAdminTrialEvent(
+    input,
+    {
+      id: currentUser.id,
+      email: currentUser.email,
+      username: null,
+      role: currentUser.role,
+    },
+    { actorUserId: currentUser.id },
+  );
+
+  if (!result.body.ok) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: result.body.code,
+      message: result.body.error,
+    };
+  }
+
+  return { data: result.body.data, hasError: false };
+}
diff --git a/apps/web/app/actions/admin/trials/manage/delete-admin-trial-event.ts b/apps/web/app/actions/admin/trials/manage/delete-admin-trial-event.ts
new file mode 100644
index 00000000..eb184920
--- /dev/null
+++ b/apps/web/app/actions/admin/trials/manage/delete-admin-trial-event.ts
@@ -0,0 +1,62 @@
+"use server";
+
+import type {
+  DeleteAdminTrialEventRequest,
+  DeleteAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { deleteAdminTrialEvent } from "@beagle/server";
+import { requireAdminLayoutAccess } from "@/lib/server/admin-guard";
+import { getSessionCurrentUser } from "@/lib/server/current-user";
+
+export type DeleteAdminTrialEventActionResult = {
+  data: DeleteAdminTrialEventResponse | null;
+  hasError: boolean;
+  errorCode?: string;
+  message?: string;
+};
+
+export async function deleteAdminTrialEventAction(
+  input: DeleteAdminTrialEventRequest,
+): Promise<DeleteAdminTrialEventActionResult> {
+  const adminAccess = await requireAdminLayoutAccess();
+  if (!adminAccess.ok) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: adminAccess.status === 401 ? "UNAUTHENTICATED" : "FORBIDDEN",
+      message: "Admin access required.",
+    };
+  }
+
+  const currentUser = await getSessionCurrentUser();
+  if (!currentUser) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: "UNAUTHENTICATED",
+      message: "Admin access required.",
+    };
+  }
+
+  const result = await deleteAdminTrialEvent(
+    input,
+    {
+      id: currentUser.id,
+      email: currentUser.email,
+      username: null,
+      role: currentUser.role,
+    },
+    { actorUserId: currentUser.id },
+  );
+
+  if (!result.body.ok) {
+    return {
+      data: null,
+      hasError: true,
+      errorCode: result.body.code,
+      message: result.body.error,
+    };
+  }
+
+  return { data: result.body.data, hasError: false };
+}
diff --git a/apps/web/app/actions/admin/trials/manage/index.ts b/apps/web/app/actions/admin/trials/manage/index.ts
index 5bbd9528..d31db353 100644
--- a/apps/web/app/actions/admin/trials/manage/index.ts
+++ b/apps/web/app/actions/admin/trials/manage/index.ts
@@ -1,3 +1,5 @@
+export { createAdminTrialEventAction } from "./create-admin-trial-event";
+export { deleteAdminTrialEventAction } from "./delete-admin-trial-event";
 export { deleteAdminTrialEntryAction } from "./delete-admin-trial-entry";
 export { updateAdminTrialEventAction } from "./update-admin-trial-event";
 export { updateAdminTrialEntryAction } from "./update-admin-trial-entry";
diff --git a/apps/web/components/admin/trials/__tests__/admin-trial-event-create-page-client.test.tsx b/apps/web/components/admin/trials/__tests__/admin-trial-event-create-page-client.test.tsx
new file mode 100644
index 00000000..9b492494
--- /dev/null
+++ b/apps/web/components/admin/trials/__tests__/admin-trial-event-create-page-client.test.tsx
@@ -0,0 +1,203 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { submitAdminTrialEventCreation } from "@/lib/admin/trials";
+import { AdminTrialEventCreatePageClient } from "../admin-trial-event-create-page-client";
+
+const { formDraftRef, mutationState, mutateAsyncMock, replaceMock } =
+  vi.hoisted(() => ({
+    formDraftRef: {
+      current: null as { eventDate: string } | null,
+    },
+    mutationState: { isPending: false },
+    mutateAsyncMock: vi.fn(),
+    replaceMock: vi.fn(),
+  }));
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ replace: replaceMock }),
+}));
+vi.mock("@/hooks/i18n", () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}));
+vi.mock("@/queries/admin/trials", () => ({
+  useCreateAdminTrialEventMutation: () => ({
+    mutateAsync: mutateAsyncMock,
+    isPending: mutationState.isPending,
+  }),
+}));
+vi.mock("../admin-trial-event-form-fields", () => ({
+  AdminTrialEventFormFields: (props: { draft: { eventDate: string } }) => {
+    formDraftRef.current = props.draft;
+    return React.createElement("div", null, "event-form-fields");
+  },
+}));
+vi.mock("@/components/ui/card", () => ({
+  Card: ({ children }: { children: React.ReactNode }) =>
+    React.createElement("section", null, children),
+  CardContent: ({ children }: { children: React.ReactNode }) =>
+    React.createElement("div", null, children),
+}));
+
+describe("AdminTrialEventCreatePageClient", () => {
+  beforeEach(() => {
+    mutationState.isPending = false;
+    formDraftRef.current = null;
+    mutateAsyncMock.mockReset();
+    replaceMock.mockReset();
+  });
+
+  it("renders the full-page form and cancel destination", () => {
+    const html = renderToStaticMarkup(
+      <AdminTrialEventCreatePageClient initialEventDate="2026-07-21" />,
+    );
+
+    expect(html).toContain("admin.trials.manage.create.title");
+    expect(html).toContain("event-form-fields");
+    expect(html).toContain('href="/admin/trials"');
+    expect(html).toContain("admin.trials.manage.create.save");
+    expect(formDraftRef.current?.eventDate).toBe("2026-07-21");
+  });
+
+  it("disables submission while the create mutation is pending", () => {
+    mutationState.isPending = true;
+
+    const html = renderToStaticMarkup(
+      <AdminTrialEventCreatePageClient initialEventDate="2026-07-21" />,
+    );
+
+    expect(html).toContain("admin.trials.manage.create.saving");
+    expect(html).toContain('type="submit" disabled=""');
+  });
+
+  const validDraft = {
+    eventDate: " 2026-07-21 ",
+    eventPlace: " Helsinki ",
+    jarjestaja: " Club ",
+    ylituomari: " Judge ",
+    ylituomariNumero: " 123 ",
+    ytKertomus: " Report ",
+    kennelpiiri: " District ",
+    kennelpiirinro: " 10 ",
+    sklKoeId: " 456 ",
+  };
+  const t = (key: string) => key;
+
+  it.each([
+    [
+      "event date",
+      { eventDate: " " },
+      "admin.trials.manage.eventModal.validation.invalidDate",
+    ],
+    [
+      "event place",
+      { eventPlace: " " },
+      "admin.trials.manage.eventModal.validation.requiredPlace",
+    ],
+    [
+      "SKL id",
+      { sklKoeId: "0" },
+      "admin.trials.manage.eventModal.validation.invalidSklKoeId",
+    ],
+  ])(
+    "validates the required %s before mutation",
+    async (_label, override, error) => {
+      const setErrorText = vi.fn();
+
+      await submitAdminTrialEventCreation({
+        draft: { ...validDraft, ...override },
+        isPending: false,
+        mutateAsync: mutateAsyncMock,
+        replace: replaceMock,
+        setErrorText,
+        t,
+      });
+
+      expect(mutateAsyncMock).not.toHaveBeenCalled();
+      expect(setErrorText).toHaveBeenLastCalledWith(error);
+    },
+  );
+
+  it("normalizes the request and navigates to the exact workspace", async () => {
+    mutateAsyncMock.mockResolvedValue({ trialEventId: "event/with spaces" });
+
+    await submitAdminTrialEventCreation({
+      draft: validDraft,
+      isPending: false,
+      mutateAsync: mutateAsyncMock,
+      replace: replaceMock,
+      setErrorText: vi.fn(),
+      t,
+    });
+
+    expect(mutateAsyncMock).toHaveBeenCalledWith({
+      eventDate: "2026-07-21",
+      eventPlace: "Helsinki",
+      jarjestaja: "Club",
+      ylituomari: "Judge",
+      ylituomariNumero: "123",
+      ytKertomus: "Report",
+      kennelpiiri: "District",
+      kennelpiirinro: "10",
+      sklKoeId: 456,
+    });
+    expect(replaceMock).toHaveBeenCalledWith(
+      "/admin/trials/event%2Fwith%20spaces",
+    );
+  });
+
+  it("preserves the draft and shows localized duplicate feedback", async () => {
+    const draft = { ...validDraft };
+    const originalDraft = { ...draft };
+    const setErrorText = vi.fn();
+    mutateAsyncMock.mockRejectedValue(
+      new AdminMutationError("Conflict", "SKL_KOE_ID_CONFLICT"),
+    );
+
+    await submitAdminTrialEventCreation({
+      draft,
+      isPending: false,
+      mutateAsync: mutateAsyncMock,
+      replace: replaceMock,
+      setErrorText,
+      t,
+    });
+
+    expect(draft).toEqual(originalDraft);
+    expect(setErrorText).toHaveBeenLastCalledWith(
+      "admin.trials.manage.create.conflict",
+    );
+    expect(replaceMock).not.toHaveBeenCalled();
+  });
+
+  it("maps unexpected failures and blocks duplicate pending submissions", async () => {
+    const setErrorText = vi.fn();
+    mutateAsyncMock.mockRejectedValue(new Error("boom"));
+
+    await submitAdminTrialEventCreation({
+      draft: validDraft,
+      isPending: false,
+      mutateAsync: mutateAsyncMock,
+      replace: replaceMock,
+      setErrorText,
+      t,
+    });
+    expect(setErrorText).toHaveBeenLastCalledWith(
+      "admin.trials.manage.create.error",
+    );
+
+    mutateAsyncMock.mockClear();
+    setErrorText.mockClear();
+    await submitAdminTrialEventCreation({
+      draft: validDraft,
+      isPending: true,
+      mutateAsync: mutateAsyncMock,
+      replace: replaceMock,
+      setErrorText,
+      t,
+    });
+    expect(mutateAsyncMock).not.toHaveBeenCalled();
+    expect(setErrorText).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/web/components/admin/trials/__tests__/admin-trial-event-delete-action.test.tsx b/apps/web/components/admin/trials/__tests__/admin-trial-event-delete-action.test.tsx
new file mode 100644
index 00000000..72e0bb7a
--- /dev/null
+++ b/apps/web/components/admin/trials/__tests__/admin-trial-event-delete-action.test.tsx
@@ -0,0 +1,148 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { AdminTrialEventDeleteAction } from "../admin-trial-event-delete-action";
+
+const {
+  confirmModalPropsRef,
+  mutationState,
+  mutateAsyncMock,
+  toastErrorMock,
+  toastSuccessMock,
+} = vi.hoisted(() => ({
+  confirmModalPropsRef: { current: null as Record<string, unknown> | null },
+  mutationState: { isPending: false },
+  mutateAsyncMock: vi.fn(),
+  toastErrorMock: vi.fn(),
+  toastSuccessMock: vi.fn(),
+}));
+
+vi.mock("@/hooks/i18n", () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock("@/queries/admin/trials", () => ({
+  useDeleteAdminTrialEventMutation: () => ({
+    mutateAsync: mutateAsyncMock,
+    isPending: mutationState.isPending,
+  }),
+}));
+
+vi.mock("@/components/ui/sonner", () => ({
+  toast: {
+    error: toastErrorMock,
+    success: toastSuccessMock,
+  },
+}));
+
+vi.mock("@/components/ui/confirm-modal", () => ({
+  ConfirmModal: (props: Record<string, unknown>) => {
+    confirmModalPropsRef.current = props;
+    return React.createElement("div", null, String(props.description));
+  },
+}));
+
+vi.mock("@/components/ui/button", () => ({
+  Button: ({
+    children,
+    ...props
+  }: React.ButtonHTMLAttributes<HTMLButtonElement>) =>
+    React.createElement("button", props, children),
+}));
+
+function renderAction(overrides?: {
+  onDeleted?: (trialEventId: string) => void;
+  onNotEmpty?: () => void;
+}) {
+  const onDeleted = overrides?.onDeleted ?? vi.fn();
+  const onNotEmpty = overrides?.onNotEmpty ?? vi.fn();
+  const html = renderToStaticMarkup(
+    <AdminTrialEventDeleteAction
+      trialEventId="event-1"
+      onDeleted={onDeleted}
+      onNotEmpty={onNotEmpty}
+    />,
+  );
+
+  return { html, onDeleted, onNotEmpty };
+}
+
+function confirmDeletion() {
+  const onConfirm = confirmModalPropsRef.current?.onConfirm as () => void;
+  onConfirm();
+}
+
+describe("AdminTrialEventDeleteAction", () => {
+  beforeEach(() => {
+    confirmModalPropsRef.current = null;
+    mutationState.isPending = false;
+    mutateAsyncMock.mockReset();
+    toastErrorMock.mockReset();
+    toastSuccessMock.mockReset();
+  });
+
+  it("wires the destructive confirmation and pending state", () => {
+    mutationState.isPending = true;
+
+    const { html } = renderAction();
+
+    expect(html).toContain("admin.trials.manage.deleteEvent.action");
+    expect(html).not.toContain("admin.trials.manage.deleteEvent.error");
+    expect(confirmModalPropsRef.current).toMatchObject({
+      open: false,
+      isConfirming: true,
+      title: "admin.trials.manage.deleteEvent.confirmTitle",
+      description: "admin.trials.manage.deleteEvent.confirmBody",
+    });
+  });
+
+  it("shows success feedback and reports the deleted event", async () => {
+    mutateAsyncMock.mockResolvedValue({ deletedTrialEventId: "event-1" });
+    const { onDeleted, onNotEmpty } = renderAction();
+
+    confirmDeletion();
+
+    await vi.waitFor(() => {
+      expect(toastSuccessMock).toHaveBeenCalledWith(
+        "admin.trials.manage.deleteEvent.success",
+      );
+    });
+    expect(onDeleted).toHaveBeenCalledWith("event-1");
+    expect(onNotEmpty).not.toHaveBeenCalled();
+    expect(toastErrorMock).not.toHaveBeenCalled();
+  });
+
+  it("shows one generic error toast without reporting deletion", async () => {
+    mutateAsyncMock.mockRejectedValue(new Error("boom"));
+    const { onDeleted, onNotEmpty } = renderAction();
+
+    confirmDeletion();
+
+    await vi.waitFor(() => {
+      expect(toastErrorMock).toHaveBeenCalledWith(
+        "admin.trials.manage.deleteEvent.error",
+      );
+    });
+    expect(toastErrorMock).toHaveBeenCalledOnce();
+    expect(onDeleted).not.toHaveBeenCalled();
+    expect(onNotEmpty).not.toHaveBeenCalled();
+  });
+
+  it("refreshes and shows localized feedback for a non-empty conflict", async () => {
+    mutateAsyncMock.mockRejectedValue(
+      new AdminMutationError("Conflict", "TRIAL_EVENT_NOT_EMPTY"),
+    );
+    const { onDeleted, onNotEmpty } = renderAction();
+
+    confirmDeletion();
+
+    await vi.waitFor(() => {
+      expect(toastErrorMock).toHaveBeenCalledWith(
+        "admin.trials.manage.deleteEvent.notEmpty",
+      );
+    });
+    expect(onNotEmpty).toHaveBeenCalledOnce();
+    expect(onDeleted).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/web/components/admin/trials/__tests__/admin-trial-event-workspace-page-client.test.tsx b/apps/web/components/admin/trials/__tests__/admin-trial-event-workspace-page-client.test.tsx
index 2d3e23a6..8fd60994 100644
--- a/apps/web/components/admin/trials/__tests__/admin-trial-event-workspace-page-client.test.tsx
+++ b/apps/web/components/admin/trials/__tests__/admin-trial-event-workspace-page-client.test.tsx
@@ -98,6 +98,7 @@ describe("AdminTrialEventWorkspacePageClient", () => {
       trialEventId: "event-1",
     });
     expect(panelPropsRef.current?.workspaceHref).toBeUndefined();
+    expect(panelPropsRef.current?.allowEmptyEventDeletion).toBe(true);
   });
 
   it("passes loading state to the reused panel", () => {
diff --git a/apps/web/components/admin/trials/__tests__/admin-trial-selected-event-panel.test.tsx b/apps/web/components/admin/trials/__tests__/admin-trial-selected-event-panel.test.tsx
index a4ff0fb8..41dd1c23 100644
--- a/apps/web/components/admin/trials/__tests__/admin-trial-selected-event-panel.test.tsx
+++ b/apps/web/components/admin/trials/__tests__/admin-trial-selected-event-panel.test.tsx
@@ -72,6 +72,11 @@ vi.mock("../admin-trial-event-edit-dialog", () => ({
     React.createElement("div", null, `edit-dialog-${open}`),
 }));
 
+vi.mock("../admin-trial-event-delete-action", () => ({
+  AdminTrialEventDeleteAction: ({ trialEventId }: { trialEventId: string }) =>
+    React.createElement("div", null, `delete-event-${trialEventId}`),
+}));
+
 vi.mock("@/queries/admin/trials", () => ({
   useUpdateAdminTrialEventMutation: () => ({
     mutateAsync: vi.fn(),
@@ -164,4 +169,33 @@ describe("AdminTrialSelectedEventPanel", () => {
       "admin.trials.manage.selected.actions.openWorkspace",
     );
   });
+
+  it("shows event deletion only for an empty event when explicitly allowed", () => {
+    const html = renderToStaticMarkup(
+      React.createElement(AdminTrialSelectedEventPanel, {
+        selectedEvent: {
+          trialEventId: "event-1",
+          eventDate: "2026-04-14",
+          eventPlace: "Helsinki",
+          eventName: null,
+          jarjestaja: null,
+          ylituomari: null,
+          ylituomariNumero: null,
+          ytKertomus: null,
+          kennelpiiri: null,
+          kennelpiirinro: null,
+          sklKoeId: 12345,
+          dogCount: 0,
+          entries: [],
+        },
+        isLoading: false,
+        isError: false,
+        errorText: "error",
+        onDeletedTrialEvent: vi.fn(),
+        allowEmptyEventDeletion: true,
+      }),
+    );
+
+    expect(html).toContain("delete-event-event-1");
+  });
 });
diff --git a/apps/web/components/admin/trials/__tests__/admin-trials-page-client.test.tsx b/apps/web/components/admin/trials/__tests__/admin-trials-page-client.test.tsx
index a7ffb103..5418cf17 100644
--- a/apps/web/components/admin/trials/__tests__/admin-trials-page-client.test.tsx
+++ b/apps/web/components/admin/trials/__tests__/admin-trials-page-client.test.tsx
@@ -169,6 +169,8 @@ describe("AdminTrialsPageClient", () => {
 
     expect(html).toContain("admin.trials.title");
     expect(html).toContain("admin.trials.description");
+    expect(html).toContain("admin.trials.manage.create.action");
+    expect(html).toContain("/admin/trials/new");
     expect(html).toContain("year|||");
     expect(html).toContain("2|1|1|event-1|admin.trials.manage.error");
     expect(html).toContain(
diff --git a/apps/web/components/admin/trials/admin-trial-event-create-page-client.tsx b/apps/web/components/admin/trials/admin-trial-event-create-page-client.tsx
new file mode 100644
index 00000000..df510cd5
--- /dev/null
+++ b/apps/web/components/admin/trials/admin-trial-event-create-page-client.tsx
@@ -0,0 +1,84 @@
+"use client";
+
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { useI18n } from "@/hooks/i18n";
+import {
+  getAdminTrialsHref,
+  submitAdminTrialEventCreation,
+} from "@/lib/admin/trials";
+import { useCreateAdminTrialEventMutation } from "@/queries/admin/trials";
+import { createEmptyTrialEventDraft } from "./admin-trial-event-edit-dialog-helpers";
+import { AdminTrialEventFormFields } from "./admin-trial-event-form-fields";
+
+// Renders and submits the full-page manual trial event creation flow.
+export function AdminTrialEventCreatePageClient({
+  initialEventDate,
+}: {
+  initialEventDate: string;
+}) {
+  const { t } = useI18n();
+  const router = useRouter();
+  const createMutation = useCreateAdminTrialEventMutation();
+  const [draft, setDraft] = useState(() => ({
+    ...createEmptyTrialEventDraft(),
+    eventDate: initialEventDate,
+  }));
+  const [errorText, setErrorText] = useState<string | null>(null);
+
+  return (
+    <div className="space-y-4">
+      <div className="space-y-2">
+        <h1 className="text-2xl font-semibold tracking-tight">
+          {t("admin.trials.manage.create.title")}
+        </h1>
+        <p className="text-sm text-muted-foreground">
+          {t("admin.trials.manage.create.description")}
+        </p>
+      </div>
+      <Card>
+        <CardContent className="p-5">
+          <form
+            className="space-y-4"
+            onSubmit={(event) => {
+              event.preventDefault();
+              void submitAdminTrialEventCreation({
+                draft,
+                isPending: createMutation.isPending,
+                mutateAsync: createMutation.mutateAsync,
+                replace: router.replace,
+                setErrorText,
+                t,
+              });
+            }}
+          >
+            {errorText ? (
+              <p className="text-sm text-destructive">{errorText}</p>
+            ) : null}
+            <AdminTrialEventFormFields
+              draft={draft}
+              disabled={createMutation.isPending}
+              onChange={setDraft}
+              requireSklKoeId
+            />
+            <div className="flex flex-wrap gap-2">
+              <Button type="submit" disabled={createMutation.isPending}>
+                {createMutation.isPending
+                  ? t("admin.trials.manage.create.saving")
+                  : t("admin.trials.manage.create.save")}
+              </Button>
+              <Button asChild variant="outline">
+                <Link href={getAdminTrialsHref()}>
+                  {t("admin.trials.manage.create.cancel")}
+                </Link>
+              </Button>
+            </div>
+          </form>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
diff --git a/apps/web/components/admin/trials/admin-trial-event-delete-action.tsx b/apps/web/components/admin/trials/admin-trial-event-delete-action.tsx
new file mode 100644
index 00000000..41501818
--- /dev/null
+++ b/apps/web/components/admin/trials/admin-trial-event-delete-action.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { ConfirmModal } from "@/components/ui/confirm-modal";
+import { toast } from "@/components/ui/sonner";
+import { useI18n } from "@/hooks/i18n";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { useDeleteAdminTrialEventMutation } from "@/queries/admin/trials";
+
+type AdminTrialEventDeleteActionProps = {
+  trialEventId: string;
+  onDeleted: (deletedTrialEventId: string) => void;
+  onNotEmpty: () => void;
+};
+
+// Coordinates confirmation, mutation feedback, and workspace callbacks for empty-event deletion.
+export function AdminTrialEventDeleteAction({
+  trialEventId,
+  onDeleted,
+  onNotEmpty,
+}: AdminTrialEventDeleteActionProps) {
+  const { t } = useI18n();
+  const deleteMutation = useDeleteAdminTrialEventMutation();
+  const [isOpen, setIsOpen] = useState(false);
+
+  async function handleDelete() {
+    try {
+      const result = await deleteMutation.mutateAsync({ trialEventId });
+      toast.success(t("admin.trials.manage.deleteEvent.success"));
+      setIsOpen(false);
+      onDeleted(result.deletedTrialEventId);
+    } catch (error) {
+      if (
+        error instanceof AdminMutationError &&
+        error.errorCode === "TRIAL_EVENT_NOT_EMPTY"
+      ) {
+        onNotEmpty();
+      }
+      toast.error(
+        error instanceof AdminMutationError
+          ? error.errorCode === "TRIAL_EVENT_NOT_EMPTY"
+            ? t("admin.trials.manage.deleteEvent.notEmpty")
+            : error.message
+          : t("admin.trials.manage.deleteEvent.error"),
+      );
+    }
+  }
+
+  return (
+    <>
+      <div className="space-y-1">
+        <Button
+          type="button"
+          variant="destructive"
+          disabled={deleteMutation.isPending}
+          onClick={() => setIsOpen(true)}
+        >
+          {t("admin.trials.manage.deleteEvent.action")}
+        </Button>
+      </div>
+      <ConfirmModal
+        open={isOpen}
+        title={t("admin.trials.manage.deleteEvent.confirmTitle")}
+        description={t("admin.trials.manage.deleteEvent.confirmBody")}
+        confirmLabel={t("admin.trials.manage.deleteEvent.confirm")}
+        confirmingLabel={t("admin.trials.manage.deleteEvent.deleting")}
+        cancelLabel={t("admin.trials.manage.deleteEvent.cancel")}
+        isConfirming={deleteMutation.isPending}
+        onConfirm={() => void handleDelete()}
+        onCancel={() => {
+          if (!deleteMutation.isPending) setIsOpen(false);
+        }}
+      />
+    </>
+  );
+}
diff --git a/apps/web/components/admin/trials/admin-trial-event-edit-dialog-helpers.ts b/apps/web/components/admin/trials/admin-trial-event-edit-dialog-helpers.ts
index 718b1e21..d4284e87 100644
--- a/apps/web/components/admin/trials/admin-trial-event-edit-dialog-helpers.ts
+++ b/apps/web/components/admin/trials/admin-trial-event-edit-dialog-helpers.ts
@@ -1,4 +1,5 @@
 import type { AdminTrialEventDetails } from "@beagle/contracts";
+export { parseSklKoeIdDraft } from "@/lib/admin/trials/submit-admin-trial-event-creation";
 
 export type TrialEventDraft = {
   eventDate: string;
@@ -12,6 +13,20 @@ export type TrialEventDraft = {
   sklKoeId: string;
 };
 
+export function createEmptyTrialEventDraft(): TrialEventDraft {
+  return {
+    eventDate: "",
+    eventPlace: "",
+    jarjestaja: "",
+    ylituomari: "",
+    ylituomariNumero: "",
+    ytKertomus: "",
+    kennelpiiri: "",
+    kennelpiirinro: "",
+    sklKoeId: "",
+  };
+}
+
 export function toTrialEventDraft(
   event: AdminTrialEventDetails,
 ): TrialEventDraft {
@@ -44,19 +59,3 @@ export function areTrialEventDraftsEqual(
     (left.sklKoeId === null ? "" : String(left.sklKoeId)) === right.sklKoeId
   );
 }
-
-const VALID_SKL_KOE_ID_PATTERN = /^[1-9]\d*$/;
-
-export function parseSklKoeIdDraft(value: string): number | null {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return null;
-  }
-
-  if (!VALID_SKL_KOE_ID_PATTERN.test(trimmed)) {
-    return null;
-  }
-
-  const parsed = Number(trimmed);
-  return Number.isSafeInteger(parsed) ? parsed : null;
-}
diff --git a/apps/web/components/admin/trials/admin-trial-event-edit-dialog.tsx b/apps/web/components/admin/trials/admin-trial-event-edit-dialog.tsx
index cb1e0f20..2d63bead 100644
--- a/apps/web/components/admin/trials/admin-trial-event-edit-dialog.tsx
+++ b/apps/web/components/admin/trials/admin-trial-event-edit-dialog.tsx
@@ -3,7 +3,6 @@
 import React, { useMemo, useState } from "react";
 import { AdminFormModalShell } from "@/components/admin";
 import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
 import { useI18n } from "@/hooks/i18n";
 import type { AdminTrialEventDetails } from "@beagle/contracts";
 import {
@@ -11,6 +10,7 @@ import {
   parseSklKoeIdDraft,
   toTrialEventDraft,
 } from "./admin-trial-event-edit-dialog-helpers";
+import { AdminTrialEventFormFields } from "./admin-trial-event-form-fields";
 
 export type UpdateAdminTrialEventPayload = {
   trialEventId: string;
@@ -197,135 +197,12 @@ function AdminTrialEventEditDialogContent({
           <p className="text-sm text-destructive">{errorText}</p>
         ) : null}
       </div>
-      <div className="grid gap-3 md:grid-cols-2">
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.eventDate")}</span>
-          <Input
-            type="date"
-            value={draft.eventDate}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                eventDate: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.eventPlace")}</span>
-          <Input
-            value={draft.eventPlace}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                eventPlace: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.jarjestaja")}</span>
-          <Input
-            value={draft.jarjestaja}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                jarjestaja: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.ylituomari")}</span>
-          <Input
-            value={draft.ylituomari}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                ylituomari: event.target.value,
-              }))
-            }
-          />
-          <span className="block text-xs text-muted-foreground">
-            {t("admin.trials.manage.eventModal.fields.ylituomariHelp")}
-          </span>
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>
-            {t("admin.trials.manage.eventModal.fields.ylituomariNumero")}
-          </span>
-          <Input
-            value={draft.ylituomariNumero}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                ylituomariNumero: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm md:col-span-2">
-          <span>{t("admin.trials.manage.eventModal.fields.ytKertomus")}</span>
-          <textarea
-            value={draft.ytKertomus}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                ytKertomus: event.target.value,
-              }))
-            }
-            className="min-h-24 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]"
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.kennelpiiri")}</span>
-          <Input
-            value={draft.kennelpiiri}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                kennelpiiri: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>
-            {t("admin.trials.manage.eventModal.fields.kennelpiirinro")}
-          </span>
-          <Input
-            value={draft.kennelpiirinro}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                kennelpiirinro: event.target.value,
-              }))
-            }
-          />
-        </label>
-        <label className="space-y-1 text-sm">
-          <span>{t("admin.trials.manage.eventModal.fields.sklKoeId")}</span>
-          <Input
-            inputMode="numeric"
-            value={draft.sklKoeId}
-            disabled={isPending}
-            onChange={(event) =>
-              setDraft((current) => ({
-                ...current,
-                sklKoeId: event.target.value,
-              }))
-            }
-          />
-        </label>
-      </div>
+      <AdminTrialEventFormFields
+        draft={draft}
+        disabled={isPending}
+        onChange={setDraft}
+        showJudgeUpdateHelp
+      />
     </AdminFormModalShell>
   );
 }
diff --git a/apps/web/components/admin/trials/admin-trial-event-form-fields.tsx b/apps/web/components/admin/trials/admin-trial-event-form-fields.tsx
new file mode 100644
index 00000000..b20cbdaa
--- /dev/null
+++ b/apps/web/components/admin/trials/admin-trial-event-form-fields.tsx
@@ -0,0 +1,120 @@
+"use client";
+
+import { Input } from "@/components/ui/input";
+import { useI18n } from "@/hooks/i18n";
+import type { TrialEventDraft } from "./admin-trial-event-edit-dialog-helpers";
+
+type AdminTrialEventFormFieldsProps = {
+  draft: TrialEventDraft;
+  disabled: boolean;
+  onChange: (draft: TrialEventDraft) => void;
+  showJudgeUpdateHelp?: boolean;
+  requireSklKoeId?: boolean;
+};
+
+export function AdminTrialEventFormFields({
+  draft,
+  disabled,
+  onChange,
+  showJudgeUpdateHelp = false,
+  requireSklKoeId = false,
+}: AdminTrialEventFormFieldsProps) {
+  const { t } = useI18n();
+
+  function setField<Field extends keyof TrialEventDraft>(
+    field: Field,
+    value: TrialEventDraft[Field],
+  ) {
+    onChange({ ...draft, [field]: value });
+  }
+
+  return (
+    <div className="grid gap-3 md:grid-cols-2">
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.eventDate")}</span>
+        <Input
+          type="date"
+          value={draft.eventDate}
+          disabled={disabled}
+          required
+          onChange={(event) => setField("eventDate", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.eventPlace")}</span>
+        <Input
+          value={draft.eventPlace}
+          disabled={disabled}
+          required
+          onChange={(event) => setField("eventPlace", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.jarjestaja")}</span>
+        <Input
+          value={draft.jarjestaja}
+          disabled={disabled}
+          onChange={(event) => setField("jarjestaja", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.ylituomari")}</span>
+        <Input
+          value={draft.ylituomari}
+          disabled={disabled}
+          onChange={(event) => setField("ylituomari", event.target.value)}
+        />
+        {showJudgeUpdateHelp ? (
+          <span className="block text-xs text-muted-foreground">
+            {t("admin.trials.manage.eventModal.fields.ylituomariHelp")}
+          </span>
+        ) : null}
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>
+          {t("admin.trials.manage.eventModal.fields.ylituomariNumero")}
+        </span>
+        <Input
+          value={draft.ylituomariNumero}
+          disabled={disabled}
+          onChange={(event) => setField("ylituomariNumero", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm md:col-span-2">
+        <span>{t("admin.trials.manage.eventModal.fields.ytKertomus")}</span>
+        <textarea
+          value={draft.ytKertomus}
+          disabled={disabled}
+          onChange={(event) => setField("ytKertomus", event.target.value)}
+          className="min-h-24 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]"
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.kennelpiiri")}</span>
+        <Input
+          value={draft.kennelpiiri}
+          disabled={disabled}
+          onChange={(event) => setField("kennelpiiri", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.kennelpiirinro")}</span>
+        <Input
+          value={draft.kennelpiirinro}
+          disabled={disabled}
+          onChange={(event) => setField("kennelpiirinro", event.target.value)}
+        />
+      </label>
+      <label className="space-y-1 text-sm">
+        <span>{t("admin.trials.manage.eventModal.fields.sklKoeId")}</span>
+        <Input
+          inputMode="numeric"
+          value={draft.sklKoeId}
+          disabled={disabled}
+          required={requireSklKoeId}
+          onChange={(event) => setField("sklKoeId", event.target.value)}
+        />
+      </label>
+    </div>
+  );
+}
diff --git a/apps/web/components/admin/trials/admin-trial-event-workspace-page-client.tsx b/apps/web/components/admin/trials/admin-trial-event-workspace-page-client.tsx
index 793fdaff..e049c019 100644
--- a/apps/web/components/admin/trials/admin-trial-event-workspace-page-client.tsx
+++ b/apps/web/components/admin/trials/admin-trial-event-workspace-page-client.tsx
@@ -60,6 +60,8 @@ export function AdminTrialEventWorkspacePageClient({
           isError={false}
           errorText={t("admin.trials.manage.workspace.error")}
           onDeletedTrialEvent={() => router.replace(getAdminTrialsHref())}
+          onTrialEventDeleteConflict={() => void eventQuery.refetch()}
+          allowEmptyEventDeletion
         />
       )}
     </div>
diff --git a/apps/web/components/admin/trials/admin-trial-selected-event-panel.tsx b/apps/web/components/admin/trials/admin-trial-selected-event-panel.tsx
index 5c6f3b8c..11dd63c0 100644
--- a/apps/web/components/admin/trials/admin-trial-selected-event-panel.tsx
+++ b/apps/web/components/admin/trials/admin-trial-selected-event-panel.tsx
@@ -27,6 +27,7 @@ import {
   type UpdateAdminTrialEventPayload,
 } from "./admin-trial-event-edit-dialog";
 import { AdminTrialEntryEditDialog } from "./admin-trial-entry-edit-dialog";
+import { AdminTrialEventDeleteAction } from "./admin-trial-event-delete-action";
 
 type AdminTrialSelectedEventPanelProps = {
   selectedEvent: AdminTrialEventDetails | null;
@@ -34,6 +35,8 @@ type AdminTrialSelectedEventPanelProps = {
   isError: boolean;
   errorText: string;
   onDeletedTrialEvent: (deletedTrialEventId: string) => void;
+  onTrialEventDeleteConflict?: () => void;
+  allowEmptyEventDeletion?: boolean;
   workspaceHref?: string;
 };
 
@@ -45,6 +48,8 @@ export function AdminTrialSelectedEventPanel({
   isError,
   errorText,
   onDeletedTrialEvent,
+  onTrialEventDeleteConflict,
+  allowEmptyEventDeletion = false,
   workspaceHref,
 }: AdminTrialSelectedEventPanelProps) {
   const { t } = useI18n();
@@ -186,6 +191,13 @@ export function AdminTrialSelectedEventPanel({
                   >
                     {t("admin.trials.manage.selected.actions.editEvent")}
                   </Button>
+                  {allowEmptyEventDeletion && selectedEntries.length === 0 ? (
+                    <AdminTrialEventDeleteAction
+                      trialEventId={selectedEvent.trialEventId}
+                      onDeleted={onDeletedTrialEvent}
+                      onNotEmpty={() => onTrialEventDeleteConflict?.()}
+                    />
+                  ) : null}
                 </div>
               </div>
             </div>
diff --git a/apps/web/components/admin/trials/admin-trials-page-client.tsx b/apps/web/components/admin/trials/admin-trials-page-client.tsx
index 3bbf235d..1c6c8384 100644
--- a/apps/web/components/admin/trials/admin-trials-page-client.tsx
+++ b/apps/web/components/admin/trials/admin-trials-page-client.tsx
@@ -1,9 +1,14 @@
 "use client";
 
 import React, { useState } from "react";
+import Link from "next/link";
 import type { AdminTrialEventSearchRequest } from "@beagle/contracts";
 import { useI18n } from "@/hooks/i18n";
-import { getAdminTrialEventHref } from "@/lib/admin/trials";
+import { Button } from "@/components/ui/button";
+import {
+  getAdminTrialEventCreateHref,
+  getAdminTrialEventHref,
+} from "@/lib/admin/trials";
 import { AdminTrialEventsFilters } from "./admin-trial-events-filters";
 import { AdminTrialEventsResults } from "./admin-trial-events-results";
 import { AdminTrialSelectedEventPanel } from "./admin-trial-selected-event-panel";
@@ -143,13 +148,20 @@ export function AdminTrialsPageClient() {
 
   return (
     <div className="space-y-4" suppressHydrationWarning>
-      <div className="space-y-2">
-        <h1 className="text-2xl font-semibold tracking-tight">
-          {t("admin.trials.title")}
-        </h1>
-        <p className="text-sm text-muted-foreground">
-          {t("admin.trials.description")}
-        </p>
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div className="space-y-2">
+          <h1 className="text-2xl font-semibold tracking-tight">
+            {t("admin.trials.title")}
+          </h1>
+          <p className="text-sm text-muted-foreground">
+            {t("admin.trials.description")}
+          </p>
+        </div>
+        <Button asChild>
+          <Link href={getAdminTrialEventCreateHref()}>
+            {t("admin.trials.manage.create.action")}
+          </Link>
+        </Button>
       </div>
 
       <AdminTrialEventsFilters
diff --git a/apps/web/components/admin/trials/index.ts b/apps/web/components/admin/trials/index.ts
index f015b28d..36a63d92 100644
--- a/apps/web/components/admin/trials/index.ts
+++ b/apps/web/components/admin/trials/index.ts
@@ -1,2 +1,3 @@
+export { AdminTrialEventCreatePageClient } from "./admin-trial-event-create-page-client";
 export { AdminTrialEventWorkspacePageClient } from "./admin-trial-event-workspace-page-client";
 export { AdminTrialsPageClient } from "./admin-trials-page-client";
diff --git a/apps/web/lib/admin/trials/__tests__/trial-route.test.ts b/apps/web/lib/admin/trials/__tests__/trial-route.test.ts
index 31d1388b..4fd230b5 100644
--- a/apps/web/lib/admin/trials/__tests__/trial-route.test.ts
+++ b/apps/web/lib/admin/trials/__tests__/trial-route.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { getAdminTrialEventHref, getAdminTrialsHref } from "../trial-route";
+import {
+  getAdminTrialEventCreateHref,
+  getAdminTrialEventHref,
+  getAdminTrialsHref,
+} from "../trial-route";
 
 describe("admin trial route helpers", () => {
   it("returns the admin trials root", () => {
@@ -10,6 +14,10 @@ describe("admin trial route helpers", () => {
     expect(getAdminTrialEventHref("event-1")).toBe("/admin/trials/event-1");
   });
 
+  it("builds the event creation href", () => {
+    expect(getAdminTrialEventCreateHref()).toBe("/admin/trials/new");
+  });
+
   it("encodes the event id as one path segment", () => {
     expect(getAdminTrialEventHref("event/with spaces")).toBe(
       "/admin/trials/event%2Fwith%20spaces",
diff --git a/apps/web/lib/admin/trials/index.ts b/apps/web/lib/admin/trials/index.ts
index 2f3dfb12..6eb021d1 100644
--- a/apps/web/lib/admin/trials/index.ts
+++ b/apps/web/lib/admin/trials/index.ts
@@ -1 +1,2 @@
 export * from "./trial-route";
+export * from "./submit-admin-trial-event-creation";
diff --git a/apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts b/apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts
new file mode 100644
index 00000000..6e99cc7f
--- /dev/null
+++ b/apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts
@@ -0,0 +1,106 @@
+import type {
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { getAdminTrialEventHref } from "./trial-route";
+
+export type AdminTrialEventCreationDraft = {
+  eventDate: string;
+  eventPlace: string;
+  jarjestaja: string;
+  ylituomari: string;
+  ylituomariNumero: string;
+  ytKertomus: string;
+  kennelpiiri: string;
+  kennelpiirinro: string;
+  sklKoeId: string;
+};
+
+type CreationMessageKey =
+  | "admin.trials.manage.eventModal.validation.invalidDate"
+  | "admin.trials.manage.eventModal.validation.requiredPlace"
+  | "admin.trials.manage.eventModal.validation.invalidSklKoeId"
+  | "admin.trials.manage.create.conflict"
+  | "admin.trials.manage.create.error";
+
+type SubmitAdminTrialEventCreationOptions = {
+  draft: AdminTrialEventCreationDraft;
+  isPending: boolean;
+  mutateAsync: (
+    request: CreateAdminTrialEventRequest,
+  ) => Promise<CreateAdminTrialEventResponse>;
+  replace: (href: string) => void;
+  setErrorText: (errorText: string | null) => void;
+  t: (key: CreationMessageKey) => string;
+};
+
+const VALID_SKL_KOE_ID_PATTERN = /^[1-9]\d*$/;
+
+export function parseSklKoeIdDraft(value: string): number | null {
+  const normalized = value.trim();
+  if (!VALID_SKL_KOE_ID_PATTERN.test(normalized)) {
+    return null;
+  }
+
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+
+// Runs the create-form validation, mutation, error mapping, and continuation.
+export async function submitAdminTrialEventCreation({
+  draft,
+  isPending,
+  mutateAsync,
+  replace,
+  setErrorText,
+  t,
+}: SubmitAdminTrialEventCreationOptions): Promise<void> {
+  if (isPending) {
+    return;
+  }
+
+  setErrorText(null);
+  const eventDate = draft.eventDate.trim();
+  if (!eventDate) {
+    setErrorText(t("admin.trials.manage.eventModal.validation.invalidDate"));
+    return;
+  }
+
+  const eventPlace = draft.eventPlace.trim();
+  if (!eventPlace) {
+    setErrorText(t("admin.trials.manage.eventModal.validation.requiredPlace"));
+    return;
+  }
+
+  const sklKoeId = parseSklKoeIdDraft(draft.sklKoeId);
+  if (sklKoeId === null) {
+    setErrorText(
+      t("admin.trials.manage.eventModal.validation.invalidSklKoeId"),
+    );
+    return;
+  }
+
+  try {
+    const result = await mutateAsync({
+      eventDate,
+      eventPlace,
+      jarjestaja: draft.jarjestaja.trim() || null,
+      ylituomari: draft.ylituomari.trim() || null,
+      ylituomariNumero: draft.ylituomariNumero.trim() || null,
+      ytKertomus: draft.ytKertomus.trim() || null,
+      kennelpiiri: draft.kennelpiiri.trim() || null,
+      kennelpiirinro: draft.kennelpiirinro.trim() || null,
+      sklKoeId,
+    });
+    replace(getAdminTrialEventHref(result.trialEventId));
+  } catch (error) {
+    setErrorText(
+      error instanceof AdminMutationError
+        ? error.errorCode === "SKL_KOE_ID_CONFLICT"
+          ? t("admin.trials.manage.create.conflict")
+          : error.message
+        : t("admin.trials.manage.create.error"),
+    );
+  }
+}
diff --git a/apps/web/lib/admin/trials/trial-route.ts b/apps/web/lib/admin/trials/trial-route.ts
index fc4f9324..03871766 100644
--- a/apps/web/lib/admin/trials/trial-route.ts
+++ b/apps/web/lib/admin/trials/trial-route.ts
@@ -4,6 +4,10 @@ export function getAdminTrialsHref(): string {
   return ADMIN_TRIALS_ROUTE_ROOT;
 }
 
+export function getAdminTrialEventCreateHref(): string {
+  return `${ADMIN_TRIALS_ROUTE_ROOT}/new`;
+}
+
 export function getAdminTrialEventHref(trialEventId: string): string {
   return `${ADMIN_TRIALS_ROUTE_ROOT}/${encodeURIComponent(trialEventId)}`;
 }
diff --git a/apps/web/lib/i18n/messages/admin/trials/__tests__/index.test.ts b/apps/web/lib/i18n/messages/admin/trials/__tests__/index.test.ts
index 2861a72a..7b5d930f 100644
--- a/apps/web/lib/i18n/messages/admin/trials/__tests__/index.test.ts
+++ b/apps/web/lib/i18n/messages/admin/trials/__tests__/index.test.ts
@@ -23,6 +23,9 @@ describe("admin trial message index", () => {
         "admin.trials.manage.selected.actions.openWorkspace"
       ],
     ).toBe("Avaa tapahtuman sivu");
+    expect(fiAdminTrialsMessages["admin.trials.manage.create.action"]).toBe(
+      "Luo tapahtuma",
+    );
     expect(svAdminTrialsMessages["admin.trials.manage.events.title"]).toBe(
       "Evenemang",
     );
@@ -43,5 +46,8 @@ describe("admin trial message index", () => {
         "admin.trials.manage.selected.actions.openWorkspace"
       ],
     ).toBe("Öppna evenemangssidan");
+    expect(svAdminTrialsMessages["admin.trials.manage.create.action"]).toBe(
+      "Skapa evenemang",
+    );
   });
 });
diff --git a/apps/web/lib/i18n/messages/admin/trials/manage.ts b/apps/web/lib/i18n/messages/admin/trials/manage.ts
index c07f2248..ba6f8a6d 100644
--- a/apps/web/lib/i18n/messages/admin/trials/manage.ts
+++ b/apps/web/lib/i18n/messages/admin/trials/manage.ts
@@ -45,6 +45,28 @@ export const fiAdminTrialsManageMessages = {
   "admin.trials.manage.workspace.error":
     "Ajokoetapahtuman lataaminen epäonnistui.",
   "admin.trials.manage.workspace.retry": "Yritä uudelleen",
+  "admin.trials.manage.create.action": "Luo tapahtuma",
+  "admin.trials.manage.create.title": "Luo ajokoetapahtuma",
+  "admin.trials.manage.create.description":
+    "Tallenna tapahtuman perustiedot. Koirakohtaiset tulokset lisätään myöhemmin.",
+  "admin.trials.manage.create.save": "Luo tapahtuma",
+  "admin.trials.manage.create.saving": "Luodaan...",
+  "admin.trials.manage.create.cancel": "Peruuta",
+  "admin.trials.manage.create.error": "Tapahtuman luominen epäonnistui.",
+  "admin.trials.manage.create.conflict":
+    "Annettu SKL koe ID kuuluu jo toiselle tapahtumalle.",
+  "admin.trials.manage.deleteEvent.action": "Poista tapahtuma",
+  "admin.trials.manage.deleteEvent.confirmTitle": "Poistetaanko tapahtuma?",
+  "admin.trials.manage.deleteEvent.confirmBody":
+    "Tyhjä tapahtuma poistetaan pysyvästi. Tapahtumaa, jolla on tuloksia, ei voi poistaa.",
+  "admin.trials.manage.deleteEvent.confirm": "Poista tapahtuma",
+  "admin.trials.manage.deleteEvent.deleting": "Poistetaan...",
+  "admin.trials.manage.deleteEvent.cancel": "Peruuta",
+  "admin.trials.manage.deleteEvent.success": "Tapahtuma poistettiin.",
+  "admin.trials.manage.deleteEvent.error":
+    "Tapahtuman poistaminen epäonnistui.",
+  "admin.trials.manage.deleteEvent.notEmpty":
+    "Tapahtumaa ei voi poistaa, koska sillä on koetuloksia.",
   "admin.trials.manage.selected.title": "Valittu tapahtuma",
   "admin.trials.manage.selected.subtitle":
     "Tapahtuman koirarivit ja rivikohtaiset toiminnot.",
@@ -79,7 +101,7 @@ export const fiAdminTrialsManageMessages = {
   "admin.trials.manage.selected.actions.delete.confirmTitle":
     "Poistetaanko tämä koetulos?",
   "admin.trials.manage.selected.actions.delete.confirmBody":
-    "Tämä poistaa vain tämän koirakohtaisen koetuloksen.\nJos tämä oli tapahtuman viimeinen tulos, myös tyhjä koetapahtuma poistetaan.",
+    "Tämä poistaa vain tämän koirakohtaisen koetuloksen. Jos tämä oli tapahtuman viimeinen tulos, tyhjä koetapahtuma säilyy.",
   "admin.trials.manage.selected.actions.delete.confirmDog": "Koira",
   "admin.trials.manage.selected.actions.delete.confirmRegistration":
     "Rekisterinumero",
@@ -179,6 +201,28 @@ export const svAdminTrialsManageMessages = {
   "admin.trials.manage.workspace.error":
     "Det gick inte att ladda jaktprovsevenemanget.",
   "admin.trials.manage.workspace.retry": "Försök igen",
+  "admin.trials.manage.create.action": "Skapa evenemang",
+  "admin.trials.manage.create.title": "Skapa jaktprovsevenemang",
+  "admin.trials.manage.create.description":
+    "Spara evenemangets grunduppgifter. Hundspecifika resultat läggs till senare.",
+  "admin.trials.manage.create.save": "Skapa evenemang",
+  "admin.trials.manage.create.saving": "Skapar...",
+  "admin.trials.manage.create.cancel": "Avbryt",
+  "admin.trials.manage.create.error": "Det gick inte att skapa evenemanget.",
+  "admin.trials.manage.create.conflict":
+    "Det angivna SKL prov-ID:t används redan av ett annat evenemang.",
+  "admin.trials.manage.deleteEvent.action": "Ta bort evenemang",
+  "admin.trials.manage.deleteEvent.confirmTitle": "Ta bort evenemanget?",
+  "admin.trials.manage.deleteEvent.confirmBody":
+    "Det tomma evenemanget tas bort permanent. Ett evenemang med resultat kan inte tas bort.",
+  "admin.trials.manage.deleteEvent.confirm": "Ta bort evenemang",
+  "admin.trials.manage.deleteEvent.deleting": "Tar bort...",
+  "admin.trials.manage.deleteEvent.cancel": "Avbryt",
+  "admin.trials.manage.deleteEvent.success": "Evenemanget togs bort.",
+  "admin.trials.manage.deleteEvent.error":
+    "Det gick inte att ta bort evenemanget.",
+  "admin.trials.manage.deleteEvent.notEmpty":
+    "Evenemanget kan inte tas bort eftersom det har provresultat.",
   "admin.trials.manage.selected.title": "Valt evenemang",
   "admin.trials.manage.selected.subtitle":
     "Hundrader och radåtgärder för valt evenemang.",
@@ -212,7 +256,7 @@ export const svAdminTrialsManageMessages = {
   "admin.trials.manage.selected.actions.delete.confirmTitle":
     "Ta bort det här provresultatet?",
   "admin.trials.manage.selected.actions.delete.confirmBody":
-    "Det här tar bara bort det här hundspecifika provresultatet.\nOm detta var det sista resultatet i evenemanget tas även det tomma provevenemanget bort.",
+    "Det här tar bara bort det hundspecifika provresultatet. Om det var evenemangets sista resultat bevaras det tomma evenemanget.",
   "admin.trials.manage.selected.actions.delete.confirmDog": "Hund",
   "admin.trials.manage.selected.actions.delete.confirmRegistration":
     "Registrering",
diff --git a/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-event-mutation.test.ts b/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-event-mutation.test.ts
new file mode 100644
index 00000000..2bcce2b1
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-event-mutation.test.ts
@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  adminTrialEventQueryKeyRoot,
+  adminTrialEventsQueryKeyRoot,
+} from "../query-keys";
+import { useCreateAdminTrialEventMutation } from "../use-create-admin-trial-event-mutation";
+
+const { useMutationMock, useQueryClientMock, invalidateMock, actionMock } =
+  vi.hoisted(() => ({
+    useMutationMock: vi.fn(),
+    useQueryClientMock: vi.fn(),
+    invalidateMock: vi.fn(),
+    actionMock: vi.fn(),
+  }));
+
+vi.mock("@tanstack/react-query", () => ({
+  useMutation: useMutationMock,
+  useQueryClient: useQueryClientMock,
+}));
+vi.mock("@/app/actions/admin/trials/manage/create-admin-trial-event", () => ({
+  createAdminTrialEventAction: actionMock,
+}));
+
+describe("useCreateAdminTrialEventMutation", () => {
+  beforeEach(() => {
+    useMutationMock.mockReset();
+    useQueryClientMock.mockReturnValue({ invalidateQueries: invalidateMock });
+    invalidateMock.mockReset();
+    actionMock.mockReset();
+    useMutationMock.mockImplementation((options) => options);
+  });
+
+  it("returns action data and invalidates admin event queries", async () => {
+    actionMock.mockResolvedValue({
+      hasError: false,
+      data: { trialEventId: "event-1" },
+    });
+    useCreateAdminTrialEventMutation();
+    const options = useMutationMock.mock.calls[0]?.[0];
+
+    await expect(options.mutationFn({})).resolves.toEqual({
+      trialEventId: "event-1",
+    });
+    await options.onSuccess();
+    expect(invalidateMock).toHaveBeenCalledWith({
+      queryKey: adminTrialEventsQueryKeyRoot,
+    });
+    expect(invalidateMock).toHaveBeenCalledWith({
+      queryKey: adminTrialEventQueryKeyRoot,
+    });
+  });
+
+  it("rejects action errors", async () => {
+    actionMock.mockResolvedValue({
+      hasError: true,
+      data: null,
+      errorCode: "SKL_KOE_ID_CONFLICT",
+      message: "Conflict",
+    });
+    useCreateAdminTrialEventMutation();
+
+    await expect(
+      useMutationMock.mock.calls[0]?.[0].mutationFn({}),
+    ).rejects.toMatchObject({ errorCode: "SKL_KOE_ID_CONFLICT" });
+  });
+});
diff --git a/apps/web/queries/admin/trials/manage/__tests__/use-delete-admin-trial-event-mutation.test.ts b/apps/web/queries/admin/trials/manage/__tests__/use-delete-admin-trial-event-mutation.test.ts
new file mode 100644
index 00000000..0a7fd416
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/__tests__/use-delete-admin-trial-event-mutation.test.ts
@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  adminTrialEventQueryKeyRoot,
+  adminTrialEventsQueryKeyRoot,
+} from "../query-keys";
+import { useDeleteAdminTrialEventMutation } from "../use-delete-admin-trial-event-mutation";
+
+const { useMutationMock, useQueryClientMock, invalidateMock, actionMock } =
+  vi.hoisted(() => ({
+    useMutationMock: vi.fn(),
+    useQueryClientMock: vi.fn(),
+    invalidateMock: vi.fn(),
+    actionMock: vi.fn(),
+  }));
+
+vi.mock("@tanstack/react-query", () => ({
+  useMutation: useMutationMock,
+  useQueryClient: useQueryClientMock,
+}));
+vi.mock("@/app/actions/admin/trials/manage/delete-admin-trial-event", () => ({
+  deleteAdminTrialEventAction: actionMock,
+}));
+
+describe("useDeleteAdminTrialEventMutation", () => {
+  beforeEach(() => {
+    useMutationMock.mockReset();
+    useQueryClientMock.mockReturnValue({ invalidateQueries: invalidateMock });
+    invalidateMock.mockReset();
+    actionMock.mockReset();
+    useMutationMock.mockImplementation((options) => options);
+  });
+
+  it("returns action data and invalidates admin event queries", async () => {
+    actionMock.mockResolvedValue({
+      hasError: false,
+      data: { deletedTrialEventId: "event-1" },
+    });
+    useDeleteAdminTrialEventMutation();
+    const options = useMutationMock.mock.calls[0]?.[0];
+
+    await expect(
+      options.mutationFn({ trialEventId: "event-1" }),
+    ).resolves.toEqual({ deletedTrialEventId: "event-1" });
+    await options.onSuccess();
+    expect(invalidateMock).toHaveBeenCalledWith({
+      queryKey: adminTrialEventsQueryKeyRoot,
+    });
+    expect(invalidateMock).toHaveBeenCalledWith({
+      queryKey: adminTrialEventQueryKeyRoot,
+    });
+  });
+});
diff --git a/apps/web/queries/admin/trials/manage/index.ts b/apps/web/queries/admin/trials/manage/index.ts
index 5f677796..f798a697 100644
--- a/apps/web/queries/admin/trials/manage/index.ts
+++ b/apps/web/queries/admin/trials/manage/index.ts
@@ -1,4 +1,6 @@
 export * from "./query-keys";
+export * from "./use-create-admin-trial-event-mutation";
+export * from "./use-delete-admin-trial-event-mutation";
 export * from "./use-admin-trial-event-query";
 export * from "./use-admin-trial-events-query";
 export * from "./use-delete-admin-trial-entry-mutation";
diff --git a/apps/web/queries/admin/trials/manage/use-create-admin-trial-event-mutation.ts b/apps/web/queries/admin/trials/manage/use-create-admin-trial-event-mutation.ts
new file mode 100644
index 00000000..354befe1
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/use-create-admin-trial-event-mutation.ts
@@ -0,0 +1,42 @@
+"use client";
+
+import type {
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { createAdminTrialEventAction } from "@/app/actions/admin/trials/manage/create-admin-trial-event";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import {
+  adminTrialEventQueryKeyRoot,
+  adminTrialEventsQueryKeyRoot,
+} from "./query-keys";
+
+export function useCreateAdminTrialEventMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation<
+    CreateAdminTrialEventResponse,
+    AdminMutationError,
+    CreateAdminTrialEventRequest
+  >({
+    mutationFn: async (input) => {
+      const result = await createAdminTrialEventAction(input);
+      if (result.hasError || !result.data) {
+        throw new AdminMutationError(
+          result.message ?? "Failed to create trial event.",
+          result.errorCode,
+        );
+      }
+      return result.data;
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({
+        queryKey: adminTrialEventsQueryKeyRoot,
+      });
+      await queryClient.invalidateQueries({
+        queryKey: adminTrialEventQueryKeyRoot,
+      });
+    },
+  });
+}
diff --git a/apps/web/queries/admin/trials/manage/use-delete-admin-trial-event-mutation.ts b/apps/web/queries/admin/trials/manage/use-delete-admin-trial-event-mutation.ts
new file mode 100644
index 00000000..10c1e023
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/use-delete-admin-trial-event-mutation.ts
@@ -0,0 +1,42 @@
+"use client";
+
+import type {
+  DeleteAdminTrialEventRequest,
+  DeleteAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { deleteAdminTrialEventAction } from "@/app/actions/admin/trials/manage/delete-admin-trial-event";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import {
+  adminTrialEventQueryKeyRoot,
+  adminTrialEventsQueryKeyRoot,
+} from "./query-keys";
+
+export function useDeleteAdminTrialEventMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation<
+    DeleteAdminTrialEventResponse,
+    AdminMutationError,
+    DeleteAdminTrialEventRequest
+  >({
+    mutationFn: async (input) => {
+      const result = await deleteAdminTrialEventAction(input);
+      if (result.hasError || !result.data) {
+        throw new AdminMutationError(
+          result.message ?? "Failed to delete trial event.",
+          result.errorCode,
+        );
+      }
+      return result.data;
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({
+        queryKey: adminTrialEventsQueryKeyRoot,
+      });
+      await queryClient.invalidateQueries({
+        queryKey: adminTrialEventQueryKeyRoot,
+      });
+    },
+  });
+}
diff --git a/docs/features/admin-trial-management.md b/docs/features/admin-trial-management.md
index 17c90851..bb4f006d 100644
--- a/docs/features/admin-trial-management.md
+++ b/docs/features/admin-trial-management.md
@@ -7,16 +7,20 @@ and follow-up admin flow redesign).
 
 - The admin list page is an event-first master-detail workflow for canonical
   AJOK `TrialEvent` + `TrialEntry` rows.
-- An admin can search events, select one event, inspect and edit its metadata
-  and dog rows, delete a result, or open the event at the stable
+- An admin can create and search events, select one event, inspect and edit its
+  metadata and dog rows, delete a result, or open the event at the stable
   `/admin/trials/[trialEventId]` workspace URL.
+- Empty events remain available to administrators. They can be deleted
+  explicitly from their workspace, but only while they have no result rows.
 - Per-dog inspection opens the generated trial PDF. Existing event and result
   editing remains modal-based.
 
 ## Main files
 
 - `apps/web/app/(admin)/admin/trials/page.tsx`: route entrypoint for event master-detail list
+- `apps/web/app/(admin)/admin/trials/new/page.tsx`: full-page event creation route
 - `apps/web/app/(admin)/admin/trials/[trialEventId]/page.tsx`: stable event workspace route
+- `apps/web/components/admin/trials/admin-trial-event-create-page-client.tsx`: event creation form and continuation
 - `apps/web/components/admin/trials/admin-trials-page-client.tsx`: event filters + event list + selected-event rows
 - `apps/web/components/admin/trials/admin-trial-event-workspace-page-client.tsx`: one-event workspace states and navigation
 - `apps/web/components/admin/trials/admin-trial-selected-event-panel.tsx`: selected-event rows and row actions
@@ -37,8 +41,9 @@ and follow-up admin flow redesign).
 2. Event selection fetches selected event rows through `useAdminTrialEventQuery`.
 3. The selected-event panel links to the stable event workspace, which fetches
    only the `trialEventId` from its route.
-4. Event and result changes use the existing admin mutations; the PDF action
+4. Event and result changes use admin Server Action mutations; the PDF action
    opens `/api/trials/[trialEntryId]/pdf` in a new tab.
+5. Successful event creation opens the persisted empty event workspace.
 
 ## Contract rules
 
@@ -46,6 +51,10 @@ and follow-up admin flow redesign).
   `page`, `filters`, `availableYears`, `items[]`).
 - Event detail response: one event (`event`) with event header fields and
   selected dog rows (`entries[]`).
+- Event creation requires a positive `sklKoeId`, an ISO date, and a non-empty
+  place. Duplicate SKL IDs return `SKL_KOE_ID_CONFLICT`.
+- Empty event deletion returns `TRIAL_EVENT_NOT_EMPTY` if result rows are
+  present and `TRIAL_EVENT_NOT_FOUND` if the event no longer exists.
 - `TRIAL_EVENT_NOT_FOUND` is returned for missing event IDs.
 - After BEJ-81 switch, event/list identifiers are:
   - `sklKoeId` (preferred when available)
@@ -58,13 +67,17 @@ and follow-up admin flow redesign).
 - Selected dog rows have PDF, edit, and result-delete actions.
 - A missing workspace event is shown explicitly and never falls back to a
   different event.
-- Until BEJ-103 Gate E2 changes the lifecycle, deleting the final result also
-  deletes its event. The workspace then returns to `/admin/trials`; non-final
-  and failed deletions remain on the workspace.
+- Deleting the final result leaves its event persisted and displays the valid
+  empty-event state in the workspace.
+- Explicit event deletion is offered only for an empty event and is enforced
+  by both the server and database write. Successful deletion returns to
+  `/admin/trials`; failed deletion remains on the workspace.
 
 ## Tests
 
+- `apps/web/app/(admin)/admin/trials/new/__tests__/page.test.tsx`
 - `apps/web/app/(admin)/admin/trials/[trialEventId]/__tests__/page.test.tsx`
+- `apps/web/components/admin/trials/__tests__/admin-trial-event-create-page-client.test.tsx`
 - `apps/web/components/admin/trials/__tests__/admin-trial-event-workspace-page-client.test.tsx`
 - `apps/web/components/admin/trials/__tests__/admin-trials-page-client.test.tsx`
 - `apps/web/components/admin/trials/__tests__/admin-trial-entry-actions.test.tsx`
diff --git a/packages/contracts/admin/trials/manage/create-admin-trial-event.ts b/packages/contracts/admin/trials/manage/create-admin-trial-event.ts
new file mode 100644
index 00000000..4d5d89a8
--- /dev/null
+++ b/packages/contracts/admin/trials/manage/create-admin-trial-event.ts
@@ -0,0 +1,15 @@
+export type CreateAdminTrialEventRequest = {
+  eventDate: string;
+  eventPlace: string;
+  jarjestaja: string | null;
+  ylituomari: string | null;
+  ylituomariNumero: string | null;
+  ytKertomus: string | null;
+  kennelpiiri: string | null;
+  kennelpiirinro: string | null;
+  sklKoeId: number;
+};
+
+export type CreateAdminTrialEventResponse = {
+  trialEventId: string;
+};
diff --git a/packages/contracts/admin/trials/manage/delete-admin-trial-event.ts b/packages/contracts/admin/trials/manage/delete-admin-trial-event.ts
new file mode 100644
index 00000000..58b5fe72
--- /dev/null
+++ b/packages/contracts/admin/trials/manage/delete-admin-trial-event.ts
@@ -0,0 +1,7 @@
+export type DeleteAdminTrialEventRequest = {
+  trialEventId: string;
+};
+
+export type DeleteAdminTrialEventResponse = {
+  deletedTrialEventId: string;
+};
diff --git a/packages/contracts/admin/trials/manage/index.ts b/packages/contracts/admin/trials/manage/index.ts
index a7125112..b335d5b6 100644
--- a/packages/contracts/admin/trials/manage/index.ts
+++ b/packages/contracts/admin/trials/manage/index.ts
@@ -12,6 +12,14 @@ export type {
   AdminTrialEventDetailsResponse,
   AdminTrialEventEntry,
 } from "./admin-trial-event-details";
+export type {
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+} from "./create-admin-trial-event";
+export type {
+  DeleteAdminTrialEventRequest,
+  DeleteAdminTrialEventResponse,
+} from "./delete-admin-trial-event";
 export type {
   DeleteAdminTrialEntryRequest,
   DeleteAdminTrialEntryResponse,
diff --git a/packages/contracts/index.ts b/packages/contracts/index.ts
index 97382686..2c61a7ef 100644
--- a/packages/contracts/index.ts
+++ b/packages/contracts/index.ts
@@ -292,6 +292,10 @@ export type {
   AdminTrialEventDetailsRequest,
   AdminTrialEventDetailsResponse,
   AdminTrialEventEntry,
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+  DeleteAdminTrialEventRequest,
+  DeleteAdminTrialEventResponse,
   DeleteAdminTrialEntryRequest,
   DeleteAdminTrialEntryResponse,
   UpdateAdminTrialEventRequest,
diff --git a/packages/db/admin/trials/manage/__tests__/create-trial-event.test.ts b/packages/db/admin/trials/manage/__tests__/create-trial-event.test.ts
new file mode 100644
index 00000000..909d075a
--- /dev/null
+++ b/packages/db/admin/trials/manage/__tests__/create-trial-event.test.ts
@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminTrialEventWriteDb } from "../create-trial-event";
+
+const { trialEventCreateMock } = vi.hoisted(() => ({
+  trialEventCreateMock: vi.fn(),
+}));
+
+vi.mock("@db/core/prisma", () => ({
+  prisma: { trialEvent: { create: trialEventCreateMock } },
+}));
+
+describe("createAdminTrialEventWriteDb", () => {
+  beforeEach(() => {
+    trialEventCreateMock.mockReset();
+  });
+
+  it("creates one empty event with the resolved rule window", async () => {
+    trialEventCreateMock.mockResolvedValue({ id: "event-1" });
+    const eventDate = new Date("2026-07-21T00:00:00.000Z");
+
+    await expect(
+      createAdminTrialEventWriteDb({
+        eventDate,
+        eventPlace: "Helsinki",
+        jarjestaja: "Club",
+        ylituomari: null,
+        ylituomariNumero: null,
+        ytKertomus: null,
+        kennelpiiri: null,
+        kennelpiirinro: null,
+        sklKoeId: 123,
+        trialRuleWindowId: "window-1",
+      }),
+    ).resolves.toEqual({ trialEventId: "event-1" });
+
+    expect(trialEventCreateMock).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        koepaiva: eventDate,
+        koekunta: "Helsinki",
+        sklKoeId: 123,
+        trialRuleWindowId: "window-1",
+      }),
+      select: { id: true },
+    });
+  });
+
+  it("propagates duplicate SKL id errors for the service to map", async () => {
+    const duplicateError = Object.assign(new Error("duplicate SKL id"), {
+      code: "P2002",
+    });
+    trialEventCreateMock.mockRejectedValue(duplicateError);
+
+    await expect(
+      createAdminTrialEventWriteDb({
+        eventDate: new Date("2026-07-21T00:00:00.000Z"),
+        eventPlace: "Helsinki",
+        jarjestaja: null,
+        ylituomari: null,
+        ylituomariNumero: null,
+        ytKertomus: null,
+        kennelpiiri: null,
+        kennelpiirinro: null,
+        sklKoeId: 123,
+        trialRuleWindowId: null,
+      }),
+    ).rejects.toBe(duplicateError);
+  });
+});
diff --git a/packages/db/admin/trials/manage/__tests__/delete-trial-entry.test.ts b/packages/db/admin/trials/manage/__tests__/delete-trial-entry.test.ts
index 15faef64..39f9a969 100644
--- a/packages/db/admin/trials/manage/__tests__/delete-trial-entry.test.ts
+++ b/packages/db/admin/trials/manage/__tests__/delete-trial-entry.test.ts
@@ -2,31 +2,18 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import { ADMIN_WRITE_TX_CONFIG } from "@db/core/interactive-write-transaction";
 import { deleteAdminTrialEntryWriteDb } from "../delete-trial-entry";
 
-const {
-  prismaTransactionMock,
-  trialEntryDeleteManyMock,
-  trialEntryCountMock,
-  trialEventDeleteMock,
-} = vi.hoisted(() => {
+const { prismaTransactionMock, trialEntryDeleteManyMock } = vi.hoisted(() => {
   const trialEntryDeleteMany = vi.fn();
-  const trialEntryCount = vi.fn();
-  const trialEventDelete = vi.fn();
 
   const tx = {
     trialEntry: {
       deleteMany: trialEntryDeleteMany,
-      count: trialEntryCount,
-    },
-    trialEvent: {
-      delete: trialEventDelete,
     },
   };
 
   return {
     prismaTransactionMock: vi.fn(async (callback) => callback(tx)),
     trialEntryDeleteManyMock: trialEntryDeleteMany,
-    trialEntryCountMock: trialEntryCount,
-    trialEventDeleteMock: trialEventDelete,
   };
 });
 
@@ -40,8 +27,6 @@ describe("deleteAdminTrialEntryWriteDb", () => {
   beforeEach(() => {
     prismaTransactionMock.mockClear();
     trialEntryDeleteManyMock.mockReset();
-    trialEntryCountMock.mockReset();
-    trialEventDeleteMock.mockReset();
   });
 
   it("returns not_found when no matching row is deleted", async () => {
@@ -53,14 +38,10 @@ describe("deleteAdminTrialEntryWriteDb", () => {
         trialEntryId: "entry-1",
       }),
     ).resolves.toEqual({ status: "not_found" });
-
-    expect(trialEntryCountMock).not.toHaveBeenCalled();
-    expect(trialEventDeleteMock).not.toHaveBeenCalled();
   });
 
-  it("keeps parent trial event when sibling entries remain", async () => {
+  it("deletes the entry while preserving its parent event", async () => {
     trialEntryDeleteManyMock.mockResolvedValue({ count: 1 });
-    trialEntryCountMock.mockResolvedValue(2);
 
     await expect(
       deleteAdminTrialEntryWriteDb({
@@ -73,36 +54,10 @@ describe("deleteAdminTrialEntryWriteDb", () => {
       trialEventId: "event-1",
       deletedTrialEvent: false,
     });
-
-    expect(trialEventDeleteMock).not.toHaveBeenCalled();
-  });
-
-  it("deletes parent trial event when last entry is removed", async () => {
-    trialEntryDeleteManyMock.mockResolvedValue({ count: 1 });
-    trialEntryCountMock.mockResolvedValue(0);
-
-    await expect(
-      deleteAdminTrialEntryWriteDb({
-        trialEventId: "event-1",
-        trialEntryId: "entry-1",
-      }),
-    ).resolves.toEqual({
-      status: "deleted",
-      deletedTrialEntryId: "entry-1",
-      trialEventId: "event-1",
-      deletedTrialEvent: true,
-    });
-
-    expect(trialEventDeleteMock).toHaveBeenCalledWith({
-      where: {
-        id: "event-1",
-      },
-    });
   });
 
   it("passes explicit transaction timeout options", async () => {
     trialEntryDeleteManyMock.mockResolvedValue({ count: 1 });
-    trialEntryCountMock.mockResolvedValue(1);
 
     await deleteAdminTrialEntryWriteDb({
       trialEventId: "event-1",
diff --git a/packages/db/admin/trials/manage/__tests__/delete-trial-event.test.ts b/packages/db/admin/trials/manage/__tests__/delete-trial-event.test.ts
new file mode 100644
index 00000000..c790af46
--- /dev/null
+++ b/packages/db/admin/trials/manage/__tests__/delete-trial-event.test.ts
@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ADMIN_WRITE_TX_CONFIG } from "@db/core/interactive-write-transaction";
+import { deleteAdminTrialEventWriteDb } from "../delete-trial-event";
+
+const { transactionMock, deleteManyMock, findUniqueMock } = vi.hoisted(() => {
+  const deleteManyMock = vi.fn();
+  const findUniqueMock = vi.fn();
+  const tx = {
+    trialEvent: { deleteMany: deleteManyMock, findUnique: findUniqueMock },
+  };
+  return {
+    transactionMock: vi.fn(async (callback) => callback(tx)),
+    deleteManyMock,
+    findUniqueMock,
+  };
+});
+
+vi.mock("@db/core/prisma", () => ({
+  prisma: { $transaction: transactionMock },
+}));
+
+describe("deleteAdminTrialEventWriteDb", () => {
+  beforeEach(() => {
+    transactionMock.mockClear();
+    deleteManyMock.mockReset();
+    findUniqueMock.mockReset();
+  });
+
+  it("deletes only an event with no entries", async () => {
+    deleteManyMock.mockResolvedValue({ count: 1 });
+
+    await expect(
+      deleteAdminTrialEventWriteDb({ trialEventId: "event-1" }),
+    ).resolves.toEqual({
+      status: "deleted",
+      deletedTrialEventId: "event-1",
+    });
+    expect(deleteManyMock).toHaveBeenCalledWith({
+      where: { id: "event-1", entries: { none: {} } },
+    });
+    expect(findUniqueMock).not.toHaveBeenCalled();
+    expect(transactionMock).toHaveBeenCalledWith(
+      expect.any(Function),
+      ADMIN_WRITE_TX_CONFIG,
+    );
+  });
+
+  it("rejects an existing non-empty event", async () => {
+    deleteManyMock.mockResolvedValue({ count: 0 });
+    findUniqueMock.mockResolvedValue({ id: "event-1" });
+
+    await expect(
+      deleteAdminTrialEventWriteDb({ trialEventId: "event-1" }),
+    ).resolves.toEqual({ status: "not_empty" });
+  });
+
+  it("reports a missing event", async () => {
+    deleteManyMock.mockResolvedValue({ count: 0 });
+    findUniqueMock.mockResolvedValue(null);
+
+    await expect(
+      deleteAdminTrialEventWriteDb({ trialEventId: "missing" }),
+    ).resolves.toEqual({ status: "not_found" });
+  });
+});
diff --git a/packages/db/admin/trials/manage/create-trial-event.ts b/packages/db/admin/trials/manage/create-trial-event.ts
new file mode 100644
index 00000000..8fbdd4d7
--- /dev/null
+++ b/packages/db/admin/trials/manage/create-trial-event.ts
@@ -0,0 +1,43 @@
+import { prisma } from "@db/core/prisma";
+
+export type CreateAdminTrialEventWriteRequestDb = {
+  eventDate: Date;
+  eventPlace: string;
+  jarjestaja: string | null;
+  ylituomari: string | null;
+  ylituomariNumero: string | null;
+  ytKertomus: string | null;
+  kennelpiiri: string | null;
+  kennelpiirinro: string | null;
+  sklKoeId: number;
+  trialRuleWindowId: string | null;
+};
+
+export type CreateAdminTrialEventWriteResultDb = {
+  trialEventId: string;
+};
+
+// Creates one canonical event without child result rows.
+export async function createAdminTrialEventWriteDb(
+  input: CreateAdminTrialEventWriteRequestDb,
+): Promise<CreateAdminTrialEventWriteResultDb> {
+  const created = await prisma.trialEvent.create({
+    data: {
+      koepaiva: input.eventDate,
+      koekunta: input.eventPlace,
+      jarjestaja: input.jarjestaja,
+      ylituomariNimi: input.ylituomari,
+      ylituomariNumero: input.ylituomariNumero,
+      ytKertomus: input.ytKertomus,
+      kennelpiiri: input.kennelpiiri,
+      kennelpiirinro: input.kennelpiirinro,
+      sklKoeId: input.sklKoeId,
+      trialRuleWindowId: input.trialRuleWindowId,
+    },
+    select: {
+      id: true,
+    },
+  });
+
+  return { trialEventId: created.id };
+}
diff --git a/packages/db/admin/trials/manage/delete-trial-entry.ts b/packages/db/admin/trials/manage/delete-trial-entry.ts
index 57325543..de18733d 100644
--- a/packages/db/admin/trials/manage/delete-trial-entry.ts
+++ b/packages/db/admin/trials/manage/delete-trial-entry.ts
@@ -15,8 +15,8 @@ export type DeleteAdminTrialEntryWriteResultDb =
       deletedTrialEvent: boolean;
     };
 
-// modification: deleting TrialEntry cascades to TrialEra and TrialEraLisatieto.
-// If this was the last entry, remove the now-empty TrialEvent as cleanup.
+// Deleting TrialEntry cascades to TrialEra and TrialEraLisatieto.
+// The parent event intentionally remains persisted when the final entry is removed.
 export async function deleteAdminTrialEntryWriteDb(
   input: DeleteAdminTrialEntryWriteRequestDb,
 ): Promise<DeleteAdminTrialEntryWriteResultDb> {
@@ -32,27 +32,11 @@ export async function deleteAdminTrialEntryWriteDb(
       return { status: "not_found" };
     }
 
-    const remainingEntries = await tx.trialEntry.count({
-      where: {
-        trialEventId: input.trialEventId,
-      },
-    });
-
-    let deletedTrialEvent = false;
-    if (remainingEntries === 0) {
-      await tx.trialEvent.delete({
-        where: {
-          id: input.trialEventId,
-        },
-      });
-      deletedTrialEvent = true;
-    }
-
     return {
       status: "deleted",
       deletedTrialEntryId: input.trialEntryId,
       trialEventId: input.trialEventId,
-      deletedTrialEvent,
+      deletedTrialEvent: false,
     };
   }, ADMIN_WRITE_TX_CONFIG);
 }
diff --git a/packages/db/admin/trials/manage/delete-trial-event.ts b/packages/db/admin/trials/manage/delete-trial-event.ts
new file mode 100644
index 00000000..2598b5b2
--- /dev/null
+++ b/packages/db/admin/trials/manage/delete-trial-event.ts
@@ -0,0 +1,39 @@
+import { ADMIN_WRITE_TX_CONFIG } from "@db/core/interactive-write-transaction";
+import { prisma } from "@db/core/prisma";
+
+export type DeleteAdminTrialEventWriteRequestDb = {
+  trialEventId: string;
+};
+
+export type DeleteAdminTrialEventWriteResultDb =
+  | { status: "not_found" }
+  | { status: "not_empty" }
+  | { status: "deleted"; deletedTrialEventId: string };
+
+// Enforces the empty-only event deletion rule in the database write itself.
+export async function deleteAdminTrialEventWriteDb(
+  input: DeleteAdminTrialEventWriteRequestDb,
+): Promise<DeleteAdminTrialEventWriteResultDb> {
+  return prisma.$transaction(async (tx) => {
+    const deleted = await tx.trialEvent.deleteMany({
+      where: {
+        id: input.trialEventId,
+        entries: { none: {} },
+      },
+    });
+
+    if (deleted.count > 0) {
+      return {
+        status: "deleted",
+        deletedTrialEventId: input.trialEventId,
+      };
+    }
+
+    const existing = await tx.trialEvent.findUnique({
+      where: { id: input.trialEventId },
+      select: { id: true },
+    });
+
+    return existing ? { status: "not_empty" } : { status: "not_found" };
+  }, ADMIN_WRITE_TX_CONFIG);
+}
diff --git a/packages/db/admin/trials/manage/index.ts b/packages/db/admin/trials/manage/index.ts
index 96012a3f..0cfddbea 100644
--- a/packages/db/admin/trials/manage/index.ts
+++ b/packages/db/admin/trials/manage/index.ts
@@ -1,5 +1,15 @@
 export { getAdminTrialEventDetailsDb } from "./get-trial-event-details";
 export { searchAdminTrialsDb } from "./search-trials";
+export {
+  createAdminTrialEventWriteDb,
+  type CreateAdminTrialEventWriteRequestDb,
+  type CreateAdminTrialEventWriteResultDb,
+} from "./create-trial-event";
+export {
+  deleteAdminTrialEventWriteDb,
+  type DeleteAdminTrialEventWriteRequestDb,
+  type DeleteAdminTrialEventWriteResultDb,
+} from "./delete-trial-event";
 export {
   deleteAdminTrialEntryWriteDb,
   type DeleteAdminTrialEntryWriteRequestDb,
diff --git a/packages/db/index.ts b/packages/db/index.ts
index 37c0b180..779e44b0 100644
--- a/packages/db/index.ts
+++ b/packages/db/index.ts
@@ -153,6 +153,7 @@ export {
   getBeagleTrialDetailsDb,
   getBeagleTrialsForDogDb,
   getBeagleTrialSummarySourceForDogDb,
+  listActiveTrialRuleWindowsDb,
   searchBeagleTrialsDb,
   upsertKoiratietokantaAjokResultDb,
   type BeagleTrialDetailsRequestDb,
@@ -166,6 +167,7 @@ export {
   type BeagleTrialSearchResponseDb,
   type BeagleTrialSearchRowDb,
   type BeagleTrialSearchSortDb,
+  type ActiveTrialRuleWindowDb,
   type KoiratietokantaAjokEntryDbInput,
   type KoiratietokantaAjokEventDbInput,
   type KoiratietokantaAjokEraDbInput,
@@ -177,6 +179,8 @@ export {
 export {
   getAdminTrialEventDetailsDb,
   searchAdminTrialsDb,
+  createAdminTrialEventWriteDb,
+  deleteAdminTrialEventWriteDb,
   deleteAdminTrialEntryWriteDb,
   updateAdminTrialEventWriteDb,
   updateAdminTrialEntryWriteDb,
@@ -189,6 +193,10 @@ export {
   type AdminTrialEventSearchResponseDb,
   type AdminTrialEventSearchSortDb,
   type AdminTrialEventSummaryDb,
+  type CreateAdminTrialEventWriteRequestDb,
+  type CreateAdminTrialEventWriteResultDb,
+  type DeleteAdminTrialEventWriteRequestDb,
+  type DeleteAdminTrialEventWriteResultDb,
   type DeleteAdminTrialEntryWriteRequestDb,
   type DeleteAdminTrialEntryWriteResultDb,
   type UpdateAdminTrialEventWriteRequestDb,
diff --git a/packages/db/trials/__tests__/list-active-trial-rule-windows.test.ts b/packages/db/trials/__tests__/list-active-trial-rule-windows.test.ts
new file mode 100644
index 00000000..0d83109e
--- /dev/null
+++ b/packages/db/trials/__tests__/list-active-trial-rule-windows.test.ts
@@ -0,0 +1,32 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { listActiveTrialRuleWindowsDb } from "../list-active-trial-rule-windows";
+
+const { ruleWindowFindManyMock } = vi.hoisted(() => ({
+  ruleWindowFindManyMock: vi.fn(),
+}));
+
+vi.mock("@db/core/prisma", () => ({
+  prisma: { trialRuleWindow: { findMany: ruleWindowFindManyMock } },
+}));
+
+describe("listActiveTrialRuleWindowsDb", () => {
+  beforeEach(() => {
+    ruleWindowFindManyMock.mockReset();
+  });
+
+  it("loads the minimal active rule-window shape in resolution order", async () => {
+    const rows = [{ id: "window-1", fromYmd: 20200101, toYmd: null }];
+    ruleWindowFindManyMock.mockResolvedValue(rows);
+
+    await expect(listActiveTrialRuleWindowsDb()).resolves.toBe(rows);
+    expect(ruleWindowFindManyMock).toHaveBeenCalledWith({
+      where: { isActive: true },
+      orderBy: [{ sortOrder: "asc" }, { id: "asc" }],
+      select: {
+        id: true,
+        fromYmd: true,
+        toYmd: true,
+      },
+    });
+  });
+});
diff --git a/packages/db/trials/index.ts b/packages/db/trials/index.ts
index c1d8a519..0348bb80 100644
--- a/packages/db/trials/index.ts
+++ b/packages/db/trials/index.ts
@@ -2,6 +2,10 @@ export { getBeagleTrialDetailsDb } from "./get-beagle-trial-details";
 export { getBeagleTrialsForDogDb } from "./get-beagle-trials-for-dog";
 export { getBeagleTrialSummarySourceForDogDb } from "./get-beagle-trials-summary-for-dog";
 export { searchBeagleTrialsDb } from "./search-beagle-trials";
+export {
+  listActiveTrialRuleWindowsDb,
+  type ActiveTrialRuleWindowDb,
+} from "./list-active-trial-rule-windows";
 export type {
   BeagleTrialDetailsRequestDb,
   BeagleTrialDetailsResponseDb,
diff --git a/packages/db/trials/list-active-trial-rule-windows.ts b/packages/db/trials/list-active-trial-rule-windows.ts
new file mode 100644
index 00000000..e01ecf0a
--- /dev/null
+++ b/packages/db/trials/list-active-trial-rule-windows.ts
@@ -0,0 +1,22 @@
+import { prisma } from "@db/core/prisma";
+
+export type ActiveTrialRuleWindowDb = {
+  id: string;
+  fromYmd: number | null;
+  toYmd: number | null;
+};
+
+// Loads active rule windows in deterministic rule-resolution order.
+export async function listActiveTrialRuleWindowsDb(): Promise<
+  ActiveTrialRuleWindowDb[]
+> {
+  return prisma.trialRuleWindow.findMany({
+    where: { isActive: true },
+    orderBy: [{ sortOrder: "asc" }, { id: "asc" }],
+    select: {
+      id: true,
+      fromYmd: true,
+      toYmd: true,
+    },
+  });
+}
diff --git a/packages/server/admin/index.ts b/packages/server/admin/index.ts
index ec963078..92a08cf3 100644
--- a/packages/server/admin/index.ts
+++ b/packages/server/admin/index.ts
@@ -21,6 +21,8 @@ export { createAdminDogDisease } from "./dogs";
 export { deleteAdminDogDisease } from "./dogs";
 export { listAdminTrialEvents } from "./trials";
 export { getAdminTrialEvent } from "./trials";
+export { createAdminTrialEvent } from "./trials";
+export { deleteAdminTrialEvent } from "./trials";
 export { deleteAdminTrialEntry } from "./trials";
 export { updateAdminTrialEvent } from "./trials";
 export { updateAdminTrialEntry } from "./trials";
diff --git a/packages/server/admin/trials/manage/__tests__/create-trial-event.integration.test.ts b/packages/server/admin/trials/manage/__tests__/create-trial-event.integration.test.ts
new file mode 100644
index 00000000..a65d6e50
--- /dev/null
+++ b/packages/server/admin/trials/manage/__tests__/create-trial-event.integration.test.ts
@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminTrialEvent } from "../create-trial-event";
+
+const { ruleWindowFindManyMock, trialEventCreateMock } = vi.hoisted(() => ({
+  ruleWindowFindManyMock: vi.fn(),
+  trialEventCreateMock: vi.fn(),
+}));
+
+vi.mock("@db/core/prisma", () => ({
+  prisma: {
+    trialRuleWindow: { findMany: ruleWindowFindManyMock },
+    trialEvent: { create: trialEventCreateMock },
+  },
+}));
+
+const admin = {
+  id: "u_1",
+  email: "admin@example.com",
+  username: null,
+  role: "ADMIN" as const,
+};
+
+const validInput = {
+  eventDate: "2026-07-21",
+  eventPlace: " Helsinki ",
+  jarjestaja: " Club ",
+  ylituomari: null,
+  ylituomariNumero: null,
+  ytKertomus: null,
+  kennelpiiri: null,
+  kennelpiirinro: null,
+  sklKoeId: 123,
+};
+
+describe("createAdminTrialEvent with the DB repository", () => {
+  beforeEach(() => {
+    ruleWindowFindManyMock.mockReset();
+    trialEventCreateMock.mockReset();
+    ruleWindowFindManyMock.mockResolvedValue([
+      { id: "window-old", fromYmd: 20200101, toYmd: 20251231 },
+      { id: "window-current", fromYmd: 20260101, toYmd: null },
+    ]);
+    trialEventCreateMock.mockResolvedValue({ id: "event-1" });
+  });
+
+  it("resolves the rule window and persists one empty event", async () => {
+    await expect(createAdminTrialEvent(validInput, admin)).resolves.toEqual({
+      status: 201,
+      body: { ok: true, data: { trialEventId: "event-1" } },
+    });
+
+    expect(ruleWindowFindManyMock).toHaveBeenCalledWith({
+      where: { isActive: true },
+      orderBy: [{ sortOrder: "asc" }, { id: "asc" }],
+      select: {
+        id: true,
+        fromYmd: true,
+        toYmd: true,
+      },
+    });
+    expect(trialEventCreateMock).toHaveBeenCalledWith({
+      data: {
+        koepaiva: new Date("2026-07-21T00:00:00.000Z"),
+        koekunta: "Helsinki",
+        jarjestaja: "Club",
+        ylituomariNimi: null,
+        ylituomariNumero: null,
+        ytKertomus: null,
+        kennelpiiri: null,
+        kennelpiirinro: null,
+        sklKoeId: 123,
+        trialRuleWindowId: "window-current",
+      },
+      select: { id: true },
+    });
+  });
+
+  it("maps a repository duplicate error to the stable conflict", async () => {
+    trialEventCreateMock.mockRejectedValue(
+      Object.assign(new Error("duplicate SKL id"), { code: "P2002" }),
+    );
+
+    await expect(createAdminTrialEvent(validInput, admin)).resolves.toEqual({
+      status: 409,
+      body: {
+        ok: false,
+        error: "An event already uses this SKL koe id.",
+        code: "SKL_KOE_ID_CONFLICT",
+      },
+    });
+  });
+});
diff --git a/packages/server/admin/trials/manage/__tests__/create-trial-event.test.ts b/packages/server/admin/trials/manage/__tests__/create-trial-event.test.ts
new file mode 100644
index 00000000..b9337aff
--- /dev/null
+++ b/packages/server/admin/trials/manage/__tests__/create-trial-event.test.ts
@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminTrialEvent } from "../create-trial-event";
+
+const { createWriteMock, listActiveRuleWindowsMock } = vi.hoisted(() => ({
+  createWriteMock: vi.fn(),
+  listActiveRuleWindowsMock: vi.fn(),
+}));
+
+vi.mock("@beagle/db", () => ({
+  createAdminTrialEventWriteDb: createWriteMock,
+  listActiveTrialRuleWindowsDb: listActiveRuleWindowsMock,
+}));
+
+const admin = {
+  id: "u_1",
+  email: "admin@example.com",
+  username: null,
+  role: "ADMIN" as const,
+};
+
+const validInput = {
+  eventDate: "2026-07-21",
+  eventPlace: " Helsinki ",
+  jarjestaja: " Club ",
+  ylituomari: null,
+  ylituomariNumero: null,
+  ytKertomus: null,
+  kennelpiiri: null,
+  kennelpiirinro: null,
+  sklKoeId: 123,
+};
+
+describe("createAdminTrialEvent", () => {
+  beforeEach(() => {
+    createWriteMock.mockReset();
+    listActiveRuleWindowsMock.mockReset();
+    listActiveRuleWindowsMock.mockResolvedValue([
+      { id: "window-1", fromYmd: 20200101, toYmd: null },
+    ]);
+    createWriteMock.mockResolvedValue({ trialEventId: "event-1" });
+  });
+
+  it("requires admin authorization", async () => {
+    const result = await createAdminTrialEvent(validInput, {
+      ...admin,
+      role: "USER",
+    });
+
+    expect(result.status).toBe(403);
+    expect(createWriteMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["event date", { eventDate: "2026-02-30" }, "INVALID_EVENT_DATE"],
+    ["event place", { eventPlace: " " }, "INVALID_EVENT_PLACE"],
+    ["SKL id", { sklKoeId: 0 }, "INVALID_SKL_KOE_ID"],
+  ])("rejects an invalid %s", async (_label, override, code) => {
+    const result = await createAdminTrialEvent(
+      { ...validInput, ...override },
+      admin,
+    );
+
+    expect(result.status).toBe(400);
+    expect(result.body).toMatchObject({ ok: false, code });
+    expect(createWriteMock).not.toHaveBeenCalled();
+  });
+
+  it("normalizes metadata and assigns the active rule window", async () => {
+    const result = await createAdminTrialEvent(validInput, admin);
+
+    expect(result).toEqual({
+      status: 201,
+      body: { ok: true, data: { trialEventId: "event-1" } },
+    });
+    expect(listActiveRuleWindowsMock).toHaveBeenCalledOnce();
+    expect(createWriteMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        eventDate: new Date("2026-07-21T00:00:00.000Z"),
+        eventPlace: "Helsinki",
+        jarjestaja: "Club",
+        sklKoeId: 123,
+        trialRuleWindowId: "window-1",
+      }),
+    );
+  });
+
+  it("allows no matching active rule window", async () => {
+    listActiveRuleWindowsMock.mockResolvedValue([]);
+
+    await createAdminTrialEvent(validInput, admin);
+
+    expect(createWriteMock).toHaveBeenCalledWith(
+      expect.objectContaining({ trialRuleWindowId: null }),
+    );
+  });
+
+  it("maps duplicate SKL ids to a stable conflict", async () => {
+    createWriteMock.mockRejectedValue({ code: "P2002" });
+
+    await expect(createAdminTrialEvent(validInput, admin)).resolves.toEqual({
+      status: 409,
+      body: {
+        ok: false,
+        error: "An event already uses this SKL koe id.",
+        code: "SKL_KOE_ID_CONFLICT",
+      },
+    });
+  });
+});
diff --git a/packages/server/admin/trials/manage/__tests__/delete-trial-entry.test.ts b/packages/server/admin/trials/manage/__tests__/delete-trial-entry.test.ts
index b77290d7..e8ab765d 100644
--- a/packages/server/admin/trials/manage/__tests__/delete-trial-entry.test.ts
+++ b/packages/server/admin/trials/manage/__tests__/delete-trial-entry.test.ts
@@ -117,7 +117,7 @@ describe("deleteAdminTrialEntry", () => {
       status: "deleted",
       deletedTrialEntryId: "entry-1",
       trialEventId: "event-1",
-      deletedTrialEvent: true,
+      deletedTrialEvent: false,
     });
 
     await expect(
@@ -140,7 +140,7 @@ describe("deleteAdminTrialEntry", () => {
         data: {
           deletedTrialEntryId: "entry-1",
           trialEventId: "event-1",
-          deletedTrialEvent: true,
+          deletedTrialEvent: false,
         },
       },
     });
diff --git a/packages/server/admin/trials/manage/__tests__/delete-trial-event.test.ts b/packages/server/admin/trials/manage/__tests__/delete-trial-event.test.ts
new file mode 100644
index 00000000..53d97c77
--- /dev/null
+++ b/packages/server/admin/trials/manage/__tests__/delete-trial-event.test.ts
@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { deleteAdminTrialEvent } from "../delete-trial-event";
+
+const { deleteWriteMock } = vi.hoisted(() => ({ deleteWriteMock: vi.fn() }));
+
+vi.mock("@beagle/db", () => ({
+  deleteAdminTrialEventWriteDb: deleteWriteMock,
+}));
+
+const admin = {
+  id: "u_1",
+  email: "admin@example.com",
+  username: null,
+  role: "ADMIN" as const,
+};
+
+describe("deleteAdminTrialEvent", () => {
+  beforeEach(() => deleteWriteMock.mockReset());
+
+  it("validates and authorizes the request", async () => {
+    expect(
+      (await deleteAdminTrialEvent({ trialEventId: " " }, admin)).status,
+    ).toBe(400);
+    expect(
+      (
+        await deleteAdminTrialEvent(
+          { trialEventId: "event-1" },
+          { ...admin, role: "USER" },
+        )
+      ).status,
+    ).toBe(403);
+    expect(deleteWriteMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["not_found", 404, "TRIAL_EVENT_NOT_FOUND"],
+    ["not_empty", 409, "TRIAL_EVENT_NOT_EMPTY"],
+  ] as const)("maps %s", async (status, httpStatus, code) => {
+    deleteWriteMock.mockResolvedValue({ status });
+
+    const result = await deleteAdminTrialEvent(
+      { trialEventId: "event-1" },
+      admin,
+    );
+
+    expect(result.status).toBe(httpStatus);
+    expect(result.body).toMatchObject({ ok: false, code });
+  });
+
+  it("returns the deleted event id", async () => {
+    deleteWriteMock.mockResolvedValue({
+      status: "deleted",
+      deletedTrialEventId: "event-1",
+    });
+
+    await expect(
+      deleteAdminTrialEvent({ trialEventId: " event-1 " }, admin),
+    ).resolves.toEqual({
+      status: 200,
+      body: { ok: true, data: { deletedTrialEventId: "event-1" } },
+    });
+    expect(deleteWriteMock).toHaveBeenCalledWith({ trialEventId: "event-1" });
+  });
+});
diff --git a/packages/server/admin/trials/manage/create-trial-event.ts b/packages/server/admin/trials/manage/create-trial-event.ts
new file mode 100644
index 00000000..35f9c552
--- /dev/null
+++ b/packages/server/admin/trials/manage/create-trial-event.ts
@@ -0,0 +1,155 @@
+import type {
+  CreateAdminTrialEventRequest,
+  CreateAdminTrialEventResponse,
+  CurrentUserDto,
+} from "@beagle/contracts";
+import {
+  createAdminTrialEventWriteDb,
+  listActiveTrialRuleWindowsDb,
+} from "@beagle/db";
+import { requireAdmin } from "@server/admin/core/service";
+import { toErrorLog, withLogContext } from "@server/core/logger";
+import type { ServiceResult } from "@server/core/result";
+import { resolveTrialRuleWindowId } from "@server/trials/core";
+import { parseAdminTrialEventWriteInput } from "./internal/parse-admin-trial-event-write-input";
+
+type ServiceLogContext = {
+  requestId?: string;
+  actorUserId?: string;
+};
+
+function isUniqueConstraintError(error: unknown): boolean {
+  return Boolean(
+    error &&
+    typeof error === "object" &&
+    "code" in error &&
+    (error as { code?: string }).code === "P2002",
+  );
+}
+
+// Creates one empty canonical trial event for an authorized administrator.
+export async function createAdminTrialEvent(
+  input: CreateAdminTrialEventRequest,
+  currentUser: CurrentUserDto | null,
+  context?: ServiceLogContext,
+): Promise<ServiceResult<CreateAdminTrialEventResponse>> {
+  const startedAt = Date.now();
+  const log = withLogContext({
+    layer: "service",
+    useCase: "admin-trials.createAdminTrialEvent",
+    ...(context?.requestId ? { requestId: context.requestId } : {}),
+    ...(context?.actorUserId ? { actorUserId: context.actorUserId } : {}),
+  });
+
+  const authResult = requireAdmin(currentUser);
+  if (!authResult.body.ok) {
+    log.warn(
+      {
+        event: "forbidden",
+        status: authResult.status,
+        durationMs: Date.now() - startedAt,
+      },
+      "admin trial event creation rejected by authorization",
+    );
+    return { status: authResult.status, body: authResult.body };
+  }
+
+  const parsed = parseAdminTrialEventWriteInput(input, {
+    requireSklKoeId: true,
+  });
+  if (!parsed.ok) {
+    log.warn(
+      { event: parsed.issue.event, durationMs: Date.now() - startedAt },
+      "admin trial event creation rejected because event metadata is invalid",
+    );
+    return {
+      status: 400,
+      body: {
+        ok: false,
+        error: parsed.issue.error,
+        code: parsed.issue.code,
+      },
+    };
+  }
+
+  const event = parsed.data;
+  log.info(
+    {
+      event: "start",
+      eventDate: event.normalizedEventDate,
+      eventPlace: event.eventPlace,
+      sklKoeId: event.sklKoeId,
+    },
+    "admin trial event creation started",
+  );
+
+  try {
+    const activeRuleWindows = await listActiveTrialRuleWindowsDb();
+    const trialRuleWindowId = resolveTrialRuleWindowId(
+      activeRuleWindows,
+      event.eventDate,
+    );
+    const result = await createAdminTrialEventWriteDb({
+      eventDate: event.eventDate,
+      eventPlace: event.eventPlace,
+      jarjestaja: event.jarjestaja,
+      ylituomari: event.ylituomari,
+      ylituomariNumero: event.ylituomariNumero,
+      ytKertomus: event.ytKertomus,
+      kennelpiiri: event.kennelpiiri,
+      kennelpiirinro: event.kennelpiirinro,
+      sklKoeId: event.sklKoeId!,
+      trialRuleWindowId,
+    });
+
+    log.info(
+      {
+        event: "success",
+        trialEventId: result.trialEventId,
+        sklKoeId: event.sklKoeId,
+        durationMs: Date.now() - startedAt,
+      },
+      "admin trial event creation succeeded",
+    );
+    return {
+      status: 201,
+      body: { ok: true, data: { trialEventId: result.trialEventId } },
+    };
+  } catch (error) {
+    if (isUniqueConstraintError(error)) {
+      log.warn(
+        {
+          event: "skl_koe_id_conflict",
+          sklKoeId: event.sklKoeId,
+          durationMs: Date.now() - startedAt,
+        },
+        "admin trial event creation rejected because sklKoeId is already used",
+      );
+      return {
+        status: 409,
+        body: {
+          ok: false,
+          error: "An event already uses this SKL koe id.",
+          code: "SKL_KOE_ID_CONFLICT",
+        },
+      };
+    }
+
+    log.error(
+      {
+        event: "exception",
+        durationMs: Date.now() - startedAt,
+        ...toErrorLog(error),
+      },
+      "admin trial event creation failed",
+    );
+    return {
+      status: 500,
+      body: {
+        ok: false,
+        error: "Failed to create admin trial event.",
+        code: "INTERNAL_ERROR",
+      },
+    };
+  }
+}
diff --git a/packages/server/admin/trials/manage/delete-trial-event.ts b/packages/server/admin/trials/manage/delete-trial-event.ts
new file mode 100644
index 00000000..61233360
--- /dev/null
+++ b/packages/server/admin/trials/manage/delete-trial-event.ts
@@ -0,0 +1,124 @@
+import type {
+  CurrentUserDto,
+  DeleteAdminTrialEventRequest,
+  DeleteAdminTrialEventResponse,
+} from "@beagle/contracts";
+import { deleteAdminTrialEventWriteDb } from "@beagle/db";
+import { requireAdmin } from "@server/admin/core/service";
+import { toErrorLog, withLogContext } from "@server/core/logger";
+import type { ServiceResult } from "@server/core/result";
+
+type ServiceLogContext = {
+  requestId?: string;
+  actorUserId?: string;
+};
+
+// Deletes one canonical trial event only while it has no result rows.
+export async function deleteAdminTrialEvent(
+  input: DeleteAdminTrialEventRequest,
+  currentUser: CurrentUserDto | null,
+  context?: ServiceLogContext,
+): Promise<ServiceResult<DeleteAdminTrialEventResponse>> {
+  const startedAt = Date.now();
+  const trialEventId = input.trialEventId.trim();
+  const log = withLogContext({
+    layer: "service",
+    useCase: "admin-trials.deleteAdminTrialEvent",
+    ...(context?.requestId ? { requestId: context.requestId } : {}),
+    ...(context?.actorUserId ? { actorUserId: context.actorUserId } : {}),
+  });
+
+  if (!trialEventId) {
+    log.warn(
+      { event: "invalid_trial_event_id", durationMs: Date.now() - startedAt },
+      "admin trial event deletion rejected because trialEventId is invalid",
+    );
+    return {
+      status: 400,
+      body: {
+        ok: false,
+        error: "Trial event id is required.",
+        code: "INVALID_TRIAL_EVENT_ID",
+      },
+    };
+  }
+
+  const authResult = requireAdmin(currentUser);
+  if (!authResult.body.ok) {
+    log.warn(
+      {
+        event: "forbidden",
+        status: authResult.status,
+        durationMs: Date.now() - startedAt,
+      },
+      "admin trial event deletion rejected by authorization",
+    );
+    return { status: authResult.status, body: authResult.body };
+  }
+
+  log.info(
+    { event: "start", trialEventId },
+    "admin trial event deletion started",
+  );
+  try {
+    const result = await deleteAdminTrialEventWriteDb({ trialEventId });
+    if (result.status === "not_found") {
+      return {
+        status: 404,
+        body: {
+          ok: false,
+          error: "Trial event not found.",
+          code: "TRIAL_EVENT_NOT_FOUND",
+        },
+      };
+    }
+    if (result.status === "not_empty") {
+      log.warn(
+        {
+          event: "not_empty",
+          trialEventId,
+          durationMs: Date.now() - startedAt,
+        },
+        "admin trial event deletion rejected because the event has entries",
+      );
+      return {
+        status: 409,
+        body: {
+          ok: false,
+          error: "A trial event with results cannot be deleted.",
+          code: "TRIAL_EVENT_NOT_EMPTY",
+        },
+      };
+    }
+
+    log.info(
+      { event: "success", trialEventId, durationMs: Date.now() - startedAt },
+      "admin trial event deletion succeeded",
+    );
+    return {
+      status: 200,
+      body: {
+        ok: true,
+        data: { deletedTrialEventId: result.deletedTrialEventId },
+      },
+    };
+  } catch (error) {
+    log.error(
+      {
+        event: "exception",
+        trialEventId,
+        durationMs: Date.now() - startedAt,
+        ...toErrorLog(error),
+      },
+      "admin trial event deletion failed",
+    );
+    return {
+      status: 500,
+      body: {
+        ok: false,
+        error: "Failed to delete admin trial event.",
+        code: "INTERNAL_ERROR",
+      },
+    };
+  }
+}
diff --git a/packages/server/admin/trials/manage/index.ts b/packages/server/admin/trials/manage/index.ts
index 2e5bada5..606751fb 100644
--- a/packages/server/admin/trials/manage/index.ts
+++ b/packages/server/admin/trials/manage/index.ts
@@ -1,5 +1,7 @@
 export { getAdminTrialEvent } from "./get-trial-event";
 export { listAdminTrialEvents } from "./list-trials";
+export { createAdminTrialEvent } from "./create-trial-event";
+export { deleteAdminTrialEvent } from "./delete-trial-event";
 export { deleteAdminTrialEntry } from "./delete-trial-entry";
 export { updateAdminTrialEvent } from "./update-trial-event";
 export { updateAdminTrialEntry } from "./update-trial-entry";
diff --git a/packages/server/admin/trials/manage/internal/parse-admin-trial-event-write-input.ts b/packages/server/admin/trials/manage/internal/parse-admin-trial-event-write-input.ts
new file mode 100644
index 00000000..17408cf3
--- /dev/null
+++ b/packages/server/admin/trials/manage/internal/parse-admin-trial-event-write-input.ts
@@ -0,0 +1,108 @@
+import { parseIsoDateOnlyToUtcDate } from "@server/trials/internal/iso-date";
+
+type AdminTrialEventWriteInput = {
+  eventDate: string;
+  eventPlace: string;
+  jarjestaja: string | null;
+  ylituomari: string | null;
+  ylituomariNumero: string | null;
+  ytKertomus: string | null;
+  kennelpiiri: string | null;
+  kennelpiirinro: string | null;
+  sklKoeId: number | null;
+};
+
+type ParsedAdminTrialEventWriteInput = {
+  normalizedEventDate: string;
+  eventDate: Date;
+  eventPlace: string;
+  jarjestaja: string | null;
+  ylituomari: string | null;
+  ylituomariNumero: string | null;
+  ytKertomus: string | null;
+  kennelpiiri: string | null;
+  kennelpiirinro: string | null;
+  sklKoeId: number | null;
+};
+
+type AdminTrialEventWriteValidationIssue = {
+  event: "invalid_event_date" | "invalid_event_place" | "invalid_skl_koe_id";
+  code: "INVALID_EVENT_DATE" | "INVALID_EVENT_PLACE" | "INVALID_SKL_KOE_ID";
+  error: string;
+};
+
+function normalizeOptionalText(value: string | null): string | null {
+  if (value === null) {
+    return null;
+  }
+
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+// Normalizes the event metadata shared by admin event creation and editing.
+export function parseAdminTrialEventWriteInput(
+  input: AdminTrialEventWriteInput,
+  options: { requireSklKoeId: boolean },
+):
+  | { ok: true; data: ParsedAdminTrialEventWriteInput }
+  | { ok: false; issue: AdminTrialEventWriteValidationIssue } {
+  const normalizedEventDate = input.eventDate.trim();
+  const eventDate = parseIsoDateOnlyToUtcDate(normalizedEventDate);
+  if (!eventDate) {
+    return {
+      ok: false,
+      issue: {
+        event: "invalid_event_date",
+        code: "INVALID_EVENT_DATE",
+        error: "Event date must use YYYY-MM-DD format.",
+      },
+    };
+  }
+
+  const eventPlace = input.eventPlace.trim();
+  if (!eventPlace) {
+    return {
+      ok: false,
+      issue: {
+        event: "invalid_event_place",
+        code: "INVALID_EVENT_PLACE",
+        error: "Event place is required.",
+      },
+    };
+  }
+
+  const sklKoeId = input.sklKoeId;
+  if (
+    (options.requireSklKoeId && sklKoeId === null) ||
+    (sklKoeId !== null &&
+      (!Number.isInteger(sklKoeId) ||
+        !Number.isFinite(sklKoeId) ||
+        sklKoeId < 1))
+  ) {
+    return {
+      ok: false,
+      issue: {
+        event: "invalid_skl_koe_id",
+        code: "INVALID_SKL_KOE_ID",
+        error: "SKL koe id must be a positive integer.",
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    data: {
+      normalizedEventDate,
+      eventDate,
+      eventPlace,
+      jarjestaja: normalizeOptionalText(input.jarjestaja),
+      ylituomari: normalizeOptionalText(input.ylituomari),
+      ylituomariNumero: normalizeOptionalText(input.ylituomariNumero),
+      ytKertomus: normalizeOptionalText(input.ytKertomus),
+      kennelpiiri: normalizeOptionalText(input.kennelpiiri),
+      kennelpiirinro: normalizeOptionalText(input.kennelpiirinro),
+      sklKoeId,
+    },
+  };
+}
diff --git a/packages/server/admin/trials/manage/update-trial-event.ts b/packages/server/admin/trials/manage/update-trial-event.ts
index 12c7b1de..1b4971f8 100644
--- a/packages/server/admin/trials/manage/update-trial-event.ts
+++ b/packages/server/admin/trials/manage/update-trial-event.ts
@@ -7,26 +7,13 @@ import { updateAdminTrialEventWriteDb } from "@beagle/db";
 import { requireAdmin } from "@server/admin/core/service";
 import { toErrorLog, withLogContext } from "@server/core/logger";
 import type { ServiceResult } from "@server/core/result";
-import { parseIsoDateOnlyToUtcDate } from "@server/trials/internal/iso-date";
+import { parseAdminTrialEventWriteInput } from "./internal/parse-admin-trial-event-write-input";
 
 type ServiceLogContext = {
   requestId?: string;
   actorUserId?: string;
 };
 
-function normalizeRequiredText(value: string): string {
-  return value.trim();
-}
-
-function normalizeOptionalText(value: string | null): string | null {
-  if (value === null) {
-    return null;
-  }
-
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
 // Validates and updates canonical TrialEvent metadata for one admin-selected event.
 export async function updateAdminTrialEvent(
   input: UpdateAdminTrialEventRequest,
@@ -73,72 +60,39 @@ export async function updateAdminTrialEvent(
     };
   }
 
-  const normalizedEventDate = input.eventDate.trim();
-  const eventDate = parseIsoDateOnlyToUtcDate(normalizedEventDate);
-  if (!eventDate) {
+  const parsed = parseAdminTrialEventWriteInput(input, {
+    requireSklKoeId: false,
+  });
+  if (!parsed.ok) {
     log.warn(
       {
-        event: "invalid_event_date",
-        eventDate: input.eventDate,
+        event: parsed.issue.event,
         durationMs: Date.now() - startedAt,
       },
-      "admin trial event update rejected because eventDate is invalid",
-    );
-    return {
-      status: 400,
-      body: {
-        ok: false,
-        error: "Event date must use YYYY-MM-DD format.",
-        code: "INVALID_EVENT_DATE",
-      },
-    };
-  }
-
-  const eventPlace = normalizeRequiredText(input.eventPlace);
-  if (!eventPlace) {
-    log.warn(
-      { event: "invalid_event_place", durationMs: Date.now() - startedAt },
-      "admin trial event update rejected because eventPlace is invalid",
+      "admin trial event update rejected because event metadata is invalid",
     );
     return {
       status: 400,
       body: {
         ok: false,
-        error: "Event place is required.",
-        code: "INVALID_EVENT_PLACE",
+        error: parsed.issue.error,
+        code: parsed.issue.code,
       },
     };
   }
 
-  const jarjestaja = normalizeOptionalText(input.jarjestaja);
-  const ylituomari = normalizeOptionalText(input.ylituomari);
-  const ylituomariNumero = normalizeOptionalText(input.ylituomariNumero);
-  const ytKertomus = normalizeOptionalText(input.ytKertomus);
-  const kennelpiiri = normalizeOptionalText(input.kennelpiiri);
-  const kennelpiirinro = normalizeOptionalText(input.kennelpiirinro);
-
-  const sklKoeId = input.sklKoeId;
-  if (
-    sklKoeId !== null &&
-    (!Number.isInteger(sklKoeId) || !Number.isFinite(sklKoeId) || sklKoeId < 1)
-  ) {
-    log.warn(
-      {
-        event: "invalid_skl_koe_id",
-        sklKoeId: input.sklKoeId,
-        durationMs: Date.now() - startedAt,
-      },
-      "admin trial event update rejected because sklKoeId is invalid",
-    );
-    return {
-      status: 400,
-      body: {
-        ok: false,
-        error: "SKL koe id must be a positive integer.",
-        code: "INVALID_SKL_KOE_ID",
-      },
-    };
-  }
+  const {
+    normalizedEventDate,
+    eventDate,
+    eventPlace,
+    jarjestaja,
+    ylituomari,
+    ylituomariNumero,
+    ytKertomus,
+    kennelpiiri,
+    kennelpiirinro,
+    sklKoeId,
+  } = parsed.data;
 
   log.info(
     {
diff --git a/packages/server/index.ts b/packages/server/index.ts
index 681c80d7..9be0bf62 100644
--- a/packages/server/index.ts
+++ b/packages/server/index.ts
@@ -45,6 +45,8 @@ export { createTrialsService, trialsService } from "./trials";
 export { upsertKoiratietokantaAjokResultService } from "./trials";
 export { listAdminTrialEvents } from "./admin";
 export { getAdminTrialEvent } from "./admin";
+export { createAdminTrialEvent } from "./admin";
+export { deleteAdminTrialEvent } from "./admin";
 export { deleteAdminTrialEntry } from "./admin";
 export { updateAdminTrialEvent } from "./admin";
 export { updateAdminTrialEntry } from "./admin";
diff --git a/packages/server/trials/integrations/koiratietokanta/__tests__/upsert-ajok-result.test.ts b/packages/server/trials/integrations/koiratietokanta/__tests__/upsert-ajok-result.test.ts
index 09b0b33c..ce205de9 100644
--- a/packages/server/trials/integrations/koiratietokanta/__tests__/upsert-ajok-result.test.ts
+++ b/packages/server/trials/integrations/koiratietokanta/__tests__/upsert-ajok-result.test.ts
@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { upsertKoiratietokantaAjokResultService } from "../upsert-ajok-result";
 
-const { upsertDbMock, trialRuleWindowFindManyMock } = vi.hoisted(() => ({
+const { upsertDbMock, listActiveRuleWindowsMock } = vi.hoisted(() => ({
   upsertDbMock: vi.fn(),
-  trialRuleWindowFindManyMock: vi.fn(),
+  listActiveRuleWindowsMock: vi.fn(),
 }));
 
 vi.mock("@beagle/db", () => ({
@@ -22,19 +22,15 @@ vi.mock("@beagle/db", () => ({
     SULJETTU: "SULJETTU",
     KESKEYTETTY: "KESKEYTETTY",
   },
-  prisma: {
-    trialRuleWindow: {
-      findMany: trialRuleWindowFindManyMock,
-    },
-  },
+  listActiveTrialRuleWindowsDb: listActiveRuleWindowsMock,
   upsertKoiratietokantaAjokResultDb: upsertDbMock,
 }));
 
 describe("upsertKoiratietokantaAjokResultService", () => {
   beforeEach(() => {
     upsertDbMock.mockReset();
-    trialRuleWindowFindManyMock.mockReset();
-    trialRuleWindowFindManyMock.mockResolvedValue([
+    listActiveRuleWindowsMock.mockReset();
+    listActiveRuleWindowsMock.mockResolvedValue([
       {
         id: "window-1",
         fromYmd: 20200101,
diff --git a/packages/server/trials/integrations/koiratietokanta/upsert-ajok-result.ts b/packages/server/trials/integrations/koiratietokanta/upsert-ajok-result.ts
index f66bcf6f..193e9647 100644
--- a/packages/server/trials/integrations/koiratietokanta/upsert-ajok-result.ts
+++ b/packages/server/trials/integrations/koiratietokanta/upsert-ajok-result.ts
@@ -2,7 +2,10 @@ import {
   type KoiratietokantaAjokUpsertRequest,
   type KoiratietokantaAjokUpsertResponse,
 } from "@beagle/contracts";
-import { prisma, upsertKoiratietokantaAjokResultDb } from "@beagle/db";
+import {
+  listActiveTrialRuleWindowsDb,
+  upsertKoiratietokantaAjokResultDb,
+} from "@beagle/db";
 import { toErrorLog, withLogContext } from "@server/core/logger";
 import type { ServiceResult } from "@server/core/result";
 import { resolveTrialRuleWindowId } from "@server/trials/core";
@@ -35,10 +38,7 @@ export async function upsertKoiratietokantaAjokResultService(
   }
 
   try {
-    const activeRuleWindows = await prisma.trialRuleWindow.findMany({
-      where: { isActive: true },
-      orderBy: [{ sortOrder: "asc" }, { id: "asc" }],
-    });
+    const activeRuleWindows = await listActiveTrialRuleWindowsDb();
     const trialRuleWindowId = resolveTrialRuleWindowId(
       activeRuleWindows,
       mapped.event.koepaiva,