diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3daad43..0c8e92c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,13 +17,19 @@ This project uses a user-facing changelog format.
 - 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.
+- Ylläpitäjä voi lisätä ajokoetapahtumaan koirakohtaisia tuloksia yksi kerrallaan ja jatkaa seuraavaan tulokseen tai palata tapahtuman sivulle.
 
 ### Changed
 
 - Viimeisen koetuloksen poistaminen säilyttää ajokoetapahtuman tyhjänä, kunnes ylläpitäjä poistaa tapahtuman erikseen.
+- Uuden ajokoetapahtuman luomisen jälkeen siirrytään suoraan lisäämään tapahtuman ensimmäistä koetulosta.
 
 ### Fixed
 
+- Ajokoetuloksen lisätietorivit tallennetaan kelvollisessa kokonaislukujärjestyksessä, ja hylätty lisätietorivi näytetään aiempaa tarkemmin.
+- Ajokoetuloksen lisäyslomakkeen selaimen Takaisin-toiminto ei enää yritä perua navigointia epäluotettavalla edestakaisella sivuhistorian käsittelyllä.
+- Ylisuuria kokonaislukuarvoja ei enää tallenneta tyhjinä ajokoetuloksen luonnissa tai muokkauksessa.
+
 ### Removed
 
 ## [0.19.0] - 2026-07-20
diff --git a/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/__tests__/page.test.tsx b/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/__tests__/page.test.tsx
new file mode 100644
index 00000000..24af523f
--- /dev/null
+++ b/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/__tests__/page.test.tsx
@@ -0,0 +1,24 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+import Page from "../page";
+
+vi.mock(
+  "@/components/admin/trials/admin-trial-entry-create-page-client",
+  () => ({
+    AdminTrialEntryCreatePageClient: ({
+      trialEventId,
+    }: {
+      trialEventId: string;
+    }) => React.createElement("div", null, trialEventId),
+  }),
+);
+
+describe("manual trial result create page", () => {
+  it("passes the route event id to the client workflow", async () => {
+    const html = renderToStaticMarkup(
+      await Page({ params: Promise.resolve({ trialEventId: "event-1" }) }),
+    );
+    expect(html).toContain("event-1");
+  });
+});
diff --git a/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/page.tsx b/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/page.tsx
new file mode 100644
index 00000000..6a37c2c6
--- /dev/null
+++ b/apps/web/app/(admin)/admin/trials/[trialEventId]/results/new/page.tsx
@@ -0,0 +1,10 @@
+import { AdminTrialEntryCreatePageClient } from "@/components/admin/trials/admin-trial-entry-create-page-client";
+
+export default async function AdminTrialEntryCreatePage({
+  params,
+}: {
+  params: Promise<{ trialEventId: string }>;
+}) {
+  const { trialEventId } = await params;
+  return <AdminTrialEntryCreatePageClient trialEventId={trialEventId} />;
+}
diff --git a/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-entry.test.ts b/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-entry.test.ts
index 10c2d43e..a14b81f5 100644
--- a/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-entry.test.ts
+++ b/apps/web/app/actions/admin/trials/manage/__tests__/create-admin-trial-entry.test.ts
@@ -53,4 +53,30 @@ describe("createAdminTrialEntryAction", () => {
       message: "Conflict",
     });
   });
+
+  it("passes through safe validation details", async () => {
+    guard.mockResolvedValue({ ok: true });
+    user.mockResolvedValue({ id: "u1", email: "a@example.com", role: "ADMIN" });
+    create.mockResolvedValue({
+      status: 400,
+      body: {
+        ok: false,
+        code: "INVALID_TRIAL_ADDITIONAL_INFO",
+        error: "Invalid",
+        details: {
+          area: "additional_info",
+          reason: "invalid_lisatieto_order",
+          koodi: "25",
+          osa: "b",
+        },
+      },
+    });
+    await expect(createAdminTrialEntryAction(input)).resolves.toMatchObject({
+      validationIssue: {
+        reason: "invalid_lisatieto_order",
+        koodi: "25",
+        osa: "b",
+      },
+    });
+  });
 });
diff --git a/apps/web/app/actions/admin/trials/manage/create-admin-trial-entry.ts b/apps/web/app/actions/admin/trials/manage/create-admin-trial-entry.ts
index 2c46291a..34ac0bed 100644
--- a/apps/web/app/actions/admin/trials/manage/create-admin-trial-entry.ts
+++ b/apps/web/app/actions/admin/trials/manage/create-admin-trial-entry.ts
@@ -1,6 +1,7 @@
 "use server";
 
 import type {
+  AdminTrialEntryValidationIssue,
   CreateAdminTrialEntryRequest,
   CreateAdminTrialEntryResponse,
 } from "@beagle/contracts";
@@ -13,8 +14,42 @@ export type CreateAdminTrialEntryActionResult = {
   hasError: boolean;
   errorCode?: string;
   message?: string;
+  validationIssue?: AdminTrialEntryValidationIssue;
 };
 
+const VALIDATION_REASONS = new Set<AdminTrialEntryValidationIssue["reason"]>([
+  "invalid_write_shape",
+  "invalid_koetyyppi",
+  "invalid_huomautus",
+  "invalid_entry_integer",
+  "invalid_entry_number",
+  "missing_eras",
+  "invalid_era_number",
+  "duplicate_eras",
+  "non_continuous_eras",
+  "invalid_era_integer",
+  "invalid_era_number_field",
+  "invalid_lisatieto_code",
+  "duplicate_lisatieto_key",
+  "invalid_lisatieto_era",
+  "duplicate_lisatieto_era_value",
+  "invalid_lisatieto_order",
+]);
+
+function toValidationIssue(
+  value: unknown,
+): AdminTrialEntryValidationIssue | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const candidate = value as Partial<AdminTrialEntryValidationIssue>;
+  if (
+    !["entry", "eras", "additional_info"].includes(candidate.area ?? "") ||
+    !candidate.reason ||
+    !VALIDATION_REASONS.has(candidate.reason)
+  )
+    return undefined;
+  return candidate as AdminTrialEntryValidationIssue;
+}
+
 export async function createAdminTrialEntryAction(
   input: CreateAdminTrialEntryRequest,
 ): Promise<CreateAdminTrialEntryActionResult> {
@@ -42,11 +77,13 @@ export async function createAdminTrialEntryAction(
     { actorUserId: user.id },
   );
   if (!result.body.ok) {
+    const validationIssue = toValidationIssue(result.body.details);
     return {
       data: null,
       hasError: true,
       errorCode: result.body.code,
       message: result.body.error,
+      ...(validationIssue ? { validationIssue } : {}),
     };
   }
   return { data: result.body.data, hasError: false };
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
index 9b492494..9cd7a967 100644
--- 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
@@ -143,7 +143,7 @@ describe("AdminTrialEventCreatePageClient", () => {
       sklKoeId: 456,
     });
     expect(replaceMock).toHaveBeenCalledWith(
-      "/admin/trials/event%2Fwith%20spaces",
+      "/admin/trials/event%2Fwith%20spaces/results/new",
     );
   });
 
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 8fd60994..0bf569af 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
@@ -99,6 +99,9 @@ describe("AdminTrialEventWorkspacePageClient", () => {
     });
     expect(panelPropsRef.current?.workspaceHref).toBeUndefined();
     expect(panelPropsRef.current?.allowEmptyEventDeletion).toBe(true);
+    expect(panelPropsRef.current?.createEntryHref).toBe(
+      "/admin/trials/event-1/results/new",
+    );
   });
 
   it("passes loading state to the reused panel", () => {
diff --git a/apps/web/components/admin/trials/admin-trial-entry-create-page-client.tsx b/apps/web/components/admin/trials/admin-trial-entry-create-page-client.tsx
new file mode 100644
index 00000000..8cf7f2ad
--- /dev/null
+++ b/apps/web/components/admin/trials/admin-trial-entry-create-page-client.tsx
@@ -0,0 +1,316 @@
+"use client";
+
+import React from "react";
+import type { AdminTrialEntryValidationIssue } from "@beagle/contracts";
+import { useRouter } from "next/navigation";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { ConfirmModal } from "@/components/ui/confirm-modal";
+import { Input } from "@/components/ui/input";
+import { toast } from "@/components/ui/sonner";
+import { useI18n } from "@/hooks/i18n";
+import { useUnsavedTrialEntryGuard } from "@/hooks/admin/trials/manage/use-unsaved-trial-entry-guard";
+import { formatDateForFinland } from "@/lib/admin/core/date";
+import {
+  areAdminTrialEntryCreateDraftsEqual,
+  createAdminTrialEntryCreateDraft,
+  createEmptyEraDraft,
+  getAdminTrialEventHref,
+  getAdminTrialsHref,
+  getNextEraNumber,
+  toCreateAdminTrialEntryRequest,
+} from "@/lib/admin/trials";
+import {
+  useAdminTrialEventQuery,
+  useCreateAdminTrialEntryMutation,
+} from "@/queries/admin/trials";
+import { EntryMetaSection } from "./internal/entry-meta-section";
+import { EraSection } from "./internal/era-section";
+import { LisatiedotMatrix } from "./internal/lisatiedot-matrix";
+
+type SaveIntent = "another" | "finish";
+
+export function AdminTrialEntryCreatePageClient({
+  trialEventId,
+}: {
+  trialEventId: string;
+}) {
+  const { t } = useI18n();
+  const router = useRouter();
+  const eventQuery = useAdminTrialEventQuery({ trialEventId });
+  const event = eventQuery.data?.event;
+
+  if (eventQuery.isLoading)
+    return <p>{t("admin.trials.manage.resultCreate.loading")}</p>;
+  if (eventQuery.isError || !event) {
+    const missing = eventQuery.error?.errorCode === "TRIAL_EVENT_NOT_FOUND";
+    return (
+      <StateCard
+        message={t(
+          missing
+            ? "admin.trials.manage.resultCreate.eventNotFound"
+            : "admin.trials.manage.resultCreate.loadError",
+        )}
+        action={
+          missing
+            ? () => router.replace(getAdminTrialsHref())
+            : () => void eventQuery.refetch()
+        }
+        actionLabel={t(
+          missing
+            ? "admin.trials.manage.resultCreate.backToList"
+            : "admin.trials.manage.workspace.retry",
+        )}
+      />
+    );
+  }
+  if (event.sklKoeId === null) {
+    return (
+      <StateCard
+        message={t("admin.trials.manage.resultCreate.missingSklId")}
+        action={() => router.replace(getAdminTrialEventHref(trialEventId))}
+        actionLabel={t("admin.trials.manage.resultCreate.backToWorkspace")}
+      />
+    );
+  }
+  return (
+    <ResultCreateForm
+      key={`${event.trialEventId}:${event.ylituomari ?? ""}:${event.ylituomariNumero ?? ""}`}
+      event={event}
+    />
+  );
+}
+
+function StateCard({
+  message,
+  action,
+  actionLabel,
+}: {
+  message: string;
+  action: () => void;
+  actionLabel: string;
+}) {
+  return (
+    <Card>
+      <CardContent className="space-y-4 p-5">
+        <p className="text-sm text-muted-foreground">{message}</p>
+        <Button variant="outline" onClick={action}>
+          {actionLabel}
+        </Button>
+      </CardContent>
+    </Card>
+  );
+}
+
+function ResultCreateForm({
+  event,
+}: {
+  event: NonNullable<
+    ReturnType<typeof useAdminTrialEventQuery>["data"]
+  >["event"];
+}) {
+  const { t } = useI18n();
+  const router = useRouter();
+  const mutation = useCreateAdminTrialEntryMutation();
+  const initial = React.useMemo(
+    () => createAdminTrialEntryCreateDraft(event),
+    [event],
+  );
+  const [draft, setDraft] = React.useState(initial);
+  const [errorText, setErrorText] = React.useState<string | null>(null);
+  const submittingRef = React.useRef(false);
+  const dirty = !areAdminTrialEntryCreateDraftsEqual(initial, draft);
+  const guard = useUnsavedTrialEntryGuard(dirty);
+  const workspaceHref = getAdminTrialEventHref(event.trialEventId);
+
+  function addEra() {
+    const era = getNextEraNumber(draft.eras);
+    setDraft((current) => ({
+      ...current,
+      eras: [...current.eras, createEmptyEraDraft(era)],
+      lisatiedotRows: current.lisatiedotRows.map((row) => ({
+        ...row,
+        eraValues: { ...row.eraValues, [era]: "" },
+      })),
+    }));
+  }
+  function removeEra(era: number) {
+    if (era === 1) return;
+    setDraft((current) => ({
+      ...current,
+      eras: current.eras.filter((item) => item.era !== era),
+      lisatiedotRows: current.lisatiedotRows.map((row) => {
+        const values = { ...row.eraValues };
+        delete values[era];
+        return { ...row, eraValues: values };
+      }),
+    }));
+  }
+  async function submit(intent: SaveIntent) {
+    if (submittingRef.current || mutation.isPending) return;
+    setErrorText(null);
+    const parsed = toCreateAdminTrialEntryRequest(event.trialEventId, draft);
+    if (!parsed.ok) {
+      setErrorText(
+        t(
+          `admin.trials.manage.resultCreate.validation.${parsed.section}` as never,
+        ),
+      );
+      return;
+    }
+    submittingRef.current = true;
+    try {
+      await mutation.mutateAsync(parsed.request);
+      toast.success(t("admin.trials.manage.resultCreate.success"));
+      if (intent === "another")
+        setDraft(createAdminTrialEntryCreateDraft(event));
+      else router.replace(workspaceHref);
+    } catch (error) {
+      const code =
+        error instanceof AdminMutationError ? error.errorCode : undefined;
+      if (code === "UNAUTHENTICATED" || code === "FORBIDDEN") {
+        router.refresh();
+        return;
+      }
+      const map: Record<string, string> = {
+        INVALID_REGISTRATION_NUMBER: "registration",
+        TRIAL_ENTRY_REGISTRATION_CONFLICT: "conflict",
+        INVALID_TRIAL_ENTRY: "entry",
+        INVALID_TRIAL_ERAS: "eras",
+        INVALID_TRIAL_ADDITIONAL_INFO: "additionalInfo",
+        TRIAL_EVENT_NOT_FOUND: "eventNotFound",
+        TRIAL_EVENT_MISSING_SKL_ID: "missingSklId",
+      };
+      const issue =
+        error instanceof AdminMutationError
+          ? (error.details as AdminTrialEntryValidationIssue | undefined)
+          : undefined;
+      if (issue?.area === "additional_info" && issue.koodi) {
+        const row = `${issue.koodi}${issue.osa ? issue.osa : ""}`;
+        const issueKey =
+          issue.reason === "invalid_lisatieto_order"
+            ? "admin.trials.manage.resultCreate.error.additionalInfoOrder"
+            : "admin.trials.manage.resultCreate.error.additionalInfoRow";
+        setErrorText(`${t(issueKey)}: ${row}.`);
+      } else {
+        setErrorText(
+          t(
+            `admin.trials.manage.resultCreate.error.${map[code ?? ""] ?? "generic"}` as never,
+          ),
+        );
+      }
+    } finally {
+      submittingRef.current = false;
+    }
+  }
+
+  return (
+    <div className="space-y-4">
+      <div>
+        <h1 className="text-2xl font-semibold">
+          {t("admin.trials.manage.resultCreate.title")}
+        </h1>
+        <p className="text-sm text-muted-foreground">
+          {formatDateForFinland(event.eventDate)} • {event.eventPlace} • SKL{" "}
+          {event.sklKoeId}
+        </p>
+      </div>
+      <Card>
+        <CardContent className="space-y-5 p-5">
+          {errorText ? (
+            <p className="text-sm text-destructive" role="alert">
+              {errorText}
+            </p>
+          ) : null}
+          <label className="block space-y-1 text-sm">
+            <span>{t("admin.trials.manage.resultCreate.registration")}</span>
+            <Input
+              value={draft.registrationNo}
+              disabled={mutation.isPending}
+              onChange={(e) =>
+                setDraft((current) => ({
+                  ...current,
+                  registrationNo: e.target.value,
+                }))
+              }
+            />
+          </label>
+          <EntryMetaSection
+            entryDraft={draft.entry}
+            isPending={mutation.isPending}
+            onChange={(update) =>
+              setDraft((current) => ({
+                ...current,
+                entry: update(current.entry),
+              }))
+            }
+          />
+          <EraSection
+            eras={draft.eras}
+            isPending={mutation.isPending}
+            onAddEra={addEra}
+            onRemoveEra={removeEra}
+            onChangeEraField={(era, field, value) =>
+              setDraft((current) => ({
+                ...current,
+                eras: current.eras.map((item) =>
+                  item.era === era ? { ...item, [field]: value } : item,
+                ),
+              }))
+            }
+          />
+          <LisatiedotMatrix
+            eras={draft.eras}
+            rows={draft.lisatiedotRows}
+            isPending={mutation.isPending}
+            onChangeCell={(koodi, osa, era, value) =>
+              setDraft((current) => ({
+                ...current,
+                lisatiedotRows: current.lisatiedotRows.map((row) =>
+                  row.koodi === koodi && row.osa === osa
+                    ? { ...row, eraValues: { ...row.eraValues, [era]: value } }
+                    : row,
+                ),
+              }))
+            }
+          />
+          <div className="flex flex-wrap gap-2">
+            <Button
+              disabled={mutation.isPending}
+              onClick={() => void submit("another")}
+            >
+              {t("admin.trials.manage.resultCreate.saveAnother")}
+            </Button>
+            <Button
+              variant="outline"
+              disabled={mutation.isPending}
+              onClick={() => void submit("finish")}
+            >
+              {t("admin.trials.manage.resultCreate.saveFinish")}
+            </Button>
+            <Button
+              variant="ghost"
+              disabled={mutation.isPending}
+              onClick={() =>
+                guard.requestLeave(() => router.replace(workspaceHref))
+              }
+            >
+              {t("admin.trials.manage.resultCreate.cancel")}
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+      <ConfirmModal
+        open={guard.isConfirmingLeave}
+        title={t("admin.trials.manage.resultCreate.unsaved.title")}
+        description={t("admin.trials.manage.resultCreate.unsaved.body")}
+        confirmLabel={t("admin.trials.manage.resultCreate.unsaved.confirm")}
+        cancelLabel={t("admin.trials.manage.resultCreate.unsaved.cancel")}
+        confirmVariant="default"
+        onConfirm={guard.confirmLeave}
+        onCancel={guard.cancelLeave}
+      />
+    </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 e049c019..ad60d85c 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
@@ -4,7 +4,10 @@ import { useRouter } from "next/navigation";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent } from "@/components/ui/card";
 import { useI18n } from "@/hooks/i18n";
-import { getAdminTrialsHref } from "@/lib/admin/trials";
+import {
+  getAdminTrialEntryCreateHref,
+  getAdminTrialsHref,
+} from "@/lib/admin/trials";
 import { useAdminTrialEventQuery } from "@/queries/admin/trials";
 import { AdminTrialSelectedEventPanel } from "./admin-trial-selected-event-panel";
 
@@ -62,6 +65,7 @@ export function AdminTrialEventWorkspacePageClient({
           onDeletedTrialEvent={() => router.replace(getAdminTrialsHref())}
           onTrialEventDeleteConflict={() => void eventQuery.refetch()}
           allowEmptyEventDeletion
+          createEntryHref={getAdminTrialEntryCreateHref(trialEventId)}
         />
       )}
     </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 11dd63c0..486c389b 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
@@ -38,6 +38,7 @@ type AdminTrialSelectedEventPanelProps = {
   onTrialEventDeleteConflict?: () => void;
   allowEmptyEventDeletion?: boolean;
   workspaceHref?: string;
+  createEntryHref?: string;
 };
 
 const EMPTY_ENTRIES: AdminTrialEventEntry[] = [];
@@ -51,6 +52,7 @@ export function AdminTrialSelectedEventPanel({
   onTrialEventDeleteConflict,
   allowEmptyEventDeletion = false,
   workspaceHref,
+  createEntryHref,
 }: AdminTrialSelectedEventPanelProps) {
   const { t } = useI18n();
   const [isEditOpen, setIsEditOpen] = React.useState(false);
@@ -172,6 +174,13 @@ export function AdminTrialSelectedEventPanel({
                   </div>
                 </div>
                 <div className="flex flex-wrap gap-2">
+                  {createEntryHref ? (
+                    <Button asChild>
+                      <Link href={createEntryHref}>
+                        {t("admin.trials.manage.resultCreate.action")}
+                      </Link>
+                    </Button>
+                  ) : null}
                   {workspaceHref ? (
                     <Button asChild variant="outline">
                       <Link href={workspaceHref}>
diff --git a/apps/web/components/admin/trials/index.ts b/apps/web/components/admin/trials/index.ts
index 36a63d92..3acd71eb 100644
--- a/apps/web/components/admin/trials/index.ts
+++ b/apps/web/components/admin/trials/index.ts
@@ -1,3 +1,4 @@
 export { AdminTrialEventCreatePageClient } from "./admin-trial-event-create-page-client";
+export { AdminTrialEntryCreatePageClient } from "./admin-trial-entry-create-page-client";
 export { AdminTrialEventWorkspacePageClient } from "./admin-trial-event-workspace-page-client";
 export { AdminTrialsPageClient } from "./admin-trials-page-client";
diff --git a/apps/web/hooks/admin/trials/manage/__tests__/use-unsaved-trial-entry-guard.test.ts b/apps/web/hooks/admin/trials/manage/__tests__/use-unsaved-trial-entry-guard.test.ts
new file mode 100644
index 00000000..6a515755
--- /dev/null
+++ b/apps/web/hooks/admin/trials/manage/__tests__/use-unsaved-trial-entry-guard.test.ts
@@ -0,0 +1,298 @@
+import { useEffect } from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useUnsavedTrialEntryGuard } from "../use-unsaved-trial-entry-guard";
+
+const { hookState } = vi.hoisted(() => ({
+  hookState: {
+    index: 0,
+    stateSlots: [] as unknown[],
+    refSlots: [] as Array<{ current: unknown }>,
+    effectSlots: [] as Array<{
+      cleanup?: () => void;
+      dependencies?: readonly unknown[];
+    }>,
+  },
+}));
+
+vi.mock("react", async () => {
+  const actual = await vi.importActual<typeof import("react")>("react");
+  const nextHookIndex = () => hookState.index++;
+
+  function mockUseEffect(
+    effect: () => void | (() => void),
+    dependencies?: readonly unknown[],
+  ) {
+    const index = nextHookIndex();
+    const previous = hookState.effectSlots[index];
+    const unchanged =
+      dependencies &&
+      previous?.dependencies &&
+      dependencies.length === previous.dependencies.length &&
+      dependencies.every((value, position) =>
+        Object.is(value, previous.dependencies?.[position]),
+      );
+    if (unchanged) return;
+
+    previous?.cleanup?.();
+    const cleanup = effect();
+    hookState.effectSlots[index] = {
+      cleanup: cleanup ?? undefined,
+      dependencies,
+    };
+  }
+
+  function mockUseRef<T>(initialValue: T) {
+    const index = nextHookIndex();
+    if (!(index in hookState.refSlots))
+      hookState.refSlots[index] = { current: initialValue };
+    return hookState.refSlots[index] as { current: T };
+  }
+
+  function mockUseState<T>(initialValue: T) {
+    const index = nextHookIndex();
+    if (!(index in hookState.stateSlots))
+      hookState.stateSlots[index] = initialValue;
+    const setState = (value: T | ((current: T) => T)) => {
+      hookState.stateSlots[index] =
+        typeof value === "function"
+          ? (value as (current: T) => T)(hookState.stateSlots[index] as T)
+          : value;
+    };
+    return [hookState.stateSlots[index] as T, setState] as const;
+  }
+
+  return {
+    ...actual,
+    useEffect: mockUseEffect,
+    useRef: mockUseRef,
+    useState: mockUseState,
+  };
+});
+
+type BrowserListeners = {
+  beforeunload?: (event: BeforeUnloadEvent) => void;
+  click?: (event: MouseEvent) => void;
+};
+
+type Guard = ReturnType<typeof useUnsavedTrialEntryGuard>;
+
+const listeners: BrowserListeners = {};
+const assignMock = vi.fn();
+const historyBackMock = vi.fn();
+const historyForwardMock = vi.fn();
+const windowAddEventListenerMock = vi.fn(
+  (type: string, listener: EventListenerOrEventListenerObject) => {
+    if (type === "beforeunload")
+      listeners.beforeunload = listener as BrowserListeners["beforeunload"];
+  },
+);
+const windowRemoveEventListenerMock = vi.fn();
+const documentAddEventListenerMock = vi.fn(
+  (type: string, listener: EventListenerOrEventListenerObject) => {
+    if (type === "click")
+      listeners.click = listener as BrowserListeners["click"];
+  },
+);
+const documentRemoveEventListenerMock = vi.fn();
+
+let latestGuard: Guard | null = null;
+
+function GuardHarness({ isDirty }: { isDirty: boolean }) {
+  const guard = useUnsavedTrialEntryGuard(isDirty);
+  useEffect(() => {
+    latestGuard = guard;
+  }, [guard]);
+  return null;
+}
+
+function renderGuard(isDirty: boolean): Guard {
+  hookState.index = 0;
+  GuardHarness({ isDirty });
+  return latestGuard!;
+}
+
+function createClick({
+  href = "http://localhost/admin/trials/event-1",
+  target = "",
+  download = false,
+  metaKey = false,
+  ctrlKey = false,
+  shiftKey = false,
+  altKey = false,
+}: {
+  href?: string;
+  target?: string;
+  download?: boolean;
+  metaKey?: boolean;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+} = {}) {
+  const preventDefault = vi.fn();
+  const anchor = {
+    href,
+    target,
+    hasAttribute: (name: string) => name === "download" && download,
+  };
+  const event = {
+    altKey,
+    button: 0,
+    ctrlKey,
+    defaultPrevented: false,
+    metaKey,
+    preventDefault,
+    shiftKey,
+    target: { closest: () => anchor },
+  } as unknown as MouseEvent;
+  return { event, preventDefault };
+}
+
+describe("useUnsavedTrialEntryGuard", () => {
+  beforeEach(() => {
+    hookState.index = 0;
+    hookState.stateSlots = [];
+    hookState.refSlots = [];
+    hookState.effectSlots = [];
+    latestGuard = null;
+    Object.keys(listeners).forEach(
+      (key) => delete listeners[key as keyof BrowserListeners],
+    );
+    assignMock.mockReset();
+    historyBackMock.mockReset();
+    historyForwardMock.mockReset();
+    windowAddEventListenerMock.mockClear();
+    windowRemoveEventListenerMock.mockClear();
+    documentAddEventListenerMock.mockClear();
+    documentRemoveEventListenerMock.mockClear();
+    vi.stubGlobal("window", {
+      addEventListener: windowAddEventListenerMock,
+      removeEventListener: windowRemoveEventListenerMock,
+      history: {
+        back: historyBackMock,
+        forward: historyForwardMock,
+      },
+      location: {
+        assign: assignMock,
+        href: "http://localhost/admin/trials/event-1/results/new",
+        origin: "http://localhost",
+      },
+    });
+    vi.stubGlobal("document", {
+      addEventListener: documentAddEventListenerMock,
+      removeEventListener: documentRemoveEventListenerMock,
+    });
+  });
+
+  afterEach(() => {
+    for (const effect of hookState.effectSlots) effect?.cleanup?.();
+    vi.unstubAllGlobals();
+  });
+
+  it("runs clean leave requests immediately", () => {
+    const action = vi.fn();
+
+    const guard = renderGuard(false);
+    guard.requestLeave(action);
+
+    expect(action).toHaveBeenCalledOnce();
+    expect(guard.isConfirmingLeave).toBe(false);
+  });
+
+  it("keeps dirty requests pending until confirmed and runs them once", () => {
+    const action = vi.fn();
+
+    renderGuard(true).requestLeave(action);
+    const pendingGuard = renderGuard(true);
+
+    expect(pendingGuard.isConfirmingLeave).toBe(true);
+    expect(action).not.toHaveBeenCalled();
+
+    pendingGuard.confirmLeave();
+    pendingGuard.confirmLeave();
+
+    expect(action).toHaveBeenCalledOnce();
+    expect(renderGuard(true).isConfirmingLeave).toBe(false);
+  });
+
+  it("cancels a dirty leave without running its action", () => {
+    const action = vi.fn();
+
+    renderGuard(true).requestLeave(action);
+    const pendingGuard = renderGuard(true);
+    pendingGuard.cancelLeave();
+
+    expect(action).not.toHaveBeenCalled();
+    expect(renderGuard(true).isConfirmingLeave).toBe(false);
+  });
+
+  it("blocks unload while dirty without installing popstate handling", () => {
+    renderGuard(true);
+    const event = {
+      preventDefault: vi.fn(),
+      returnValue: false,
+    } as unknown as BeforeUnloadEvent;
+
+    listeners.beforeunload?.(event);
+
+    expect(event.preventDefault).toHaveBeenCalledOnce();
+    expect(event.returnValue).toBe(true);
+    expect(windowAddEventListenerMock).not.toHaveBeenCalledWith(
+      "popstate",
+      expect.anything(),
+    );
+    expect(historyBackMock).not.toHaveBeenCalled();
+    expect(historyForwardMock).not.toHaveBeenCalled();
+  });
+
+  it("does not install browser guards while clean", () => {
+    renderGuard(false);
+
+    expect(windowAddEventListenerMock).not.toHaveBeenCalled();
+    expect(documentAddEventListenerMock).not.toHaveBeenCalled();
+  });
+
+  it("confirms an intercepted same-tab link and opens the intended URL", () => {
+    renderGuard(true);
+    const { event, preventDefault } = createClick({ target: "_self" });
+
+    listeners.click?.(event);
+    const pendingGuard = renderGuard(true);
+
+    expect(preventDefault).toHaveBeenCalledOnce();
+    expect(pendingGuard.isConfirmingLeave).toBe(true);
+
+    pendingGuard.confirmLeave();
+
+    expect(assignMock).toHaveBeenCalledOnce();
+    expect(assignMock).toHaveBeenCalledWith(
+      "http://localhost/admin/trials/event-1",
+    );
+  });
+
+  it.each([
+    { name: "Cmd-click", options: { metaKey: true } },
+    { name: "Ctrl-click", options: { ctrlKey: true } },
+    { name: "Shift-click", options: { shiftKey: true } },
+    { name: "Alt-click", options: { altKey: true } },
+    { name: "new-tab target", options: { target: "_blank" } },
+    { name: "download", options: { download: true } },
+    {
+      name: "external URL",
+      options: { href: "https://example.com/somewhere" },
+    },
+    {
+      name: "current URL",
+      options: {
+        href: "http://localhost/admin/trials/event-1/results/new",
+      },
+    },
+  ])("does not intercept $name", ({ options }) => {
+    renderGuard(true);
+    const { event, preventDefault } = createClick(options);
+
+    listeners.click?.(event);
+
+    expect(preventDefault).not.toHaveBeenCalled();
+    expect(renderGuard(true).isConfirmingLeave).toBe(false);
+  });
+});
diff --git a/apps/web/hooks/admin/trials/manage/use-unsaved-trial-entry-guard.ts b/apps/web/hooks/admin/trials/manage/use-unsaved-trial-entry-guard.ts
new file mode 100644
index 00000000..9f9b27de
--- /dev/null
+++ b/apps/web/hooks/admin/trials/manage/use-unsaved-trial-entry-guard.ts
@@ -0,0 +1,79 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+
+export function useUnsavedTrialEntryGuard(isDirty: boolean) {
+  const [isConfirmingLeave, setIsConfirmingLeave] = useState(false);
+  const pendingLeaveRef = useRef<(() => void) | null>(null);
+  const allowLeaveRef = useRef(false);
+
+  function queueLeave(action: () => void) {
+    pendingLeaveRef.current = action;
+    setIsConfirmingLeave(true);
+  }
+
+  useEffect(() => {
+    if (!isDirty) return;
+    const handleBeforeUnload = (event: BeforeUnloadEvent) => {
+      if (allowLeaveRef.current) return;
+      event.preventDefault();
+      event.returnValue = true;
+    };
+    const handleClick = (event: MouseEvent) => {
+      if (
+        allowLeaveRef.current ||
+        event.defaultPrevented ||
+        event.button !== 0 ||
+        event.metaKey ||
+        event.ctrlKey ||
+        event.shiftKey ||
+        event.altKey
+      )
+        return;
+      const anchor = (event.target as Element | null)?.closest("a");
+      if (
+        !anchor ||
+        (anchor.target && anchor.target !== "_self") ||
+        anchor.hasAttribute("download")
+      )
+        return;
+      const target = new URL(anchor.href, window.location.href);
+      if (
+        target.origin !== window.location.origin ||
+        target.href === window.location.href
+      )
+        return;
+      event.preventDefault();
+      pendingLeaveRef.current = () => window.location.assign(target.href);
+      setIsConfirmingLeave(true);
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    document.addEventListener("click", handleClick, true);
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      document.removeEventListener("click", handleClick, true);
+    };
+  }, [isDirty]);
+
+  function requestLeave(action: () => void) {
+    if (!isDirty) action();
+    else queueLeave(action);
+  }
+
+  return {
+    isConfirmingLeave,
+    requestLeave,
+    cancelLeave: () => {
+      pendingLeaveRef.current = null;
+      setIsConfirmingLeave(false);
+    },
+    confirmLeave: () => {
+      const action = pendingLeaveRef.current;
+      pendingLeaveRef.current = null;
+      if (!action) return;
+      allowLeaveRef.current = true;
+      setIsConfirmingLeave(false);
+      action();
+    },
+  };
+}
diff --git a/apps/web/lib/admin/trials/__tests__/entry-create-model.test.ts b/apps/web/lib/admin/trials/__tests__/entry-create-model.test.ts
new file mode 100644
index 00000000..3553c35f
--- /dev/null
+++ b/apps/web/lib/admin/trials/__tests__/entry-create-model.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import type { AdminTrialEventDetails } from "@beagle/contracts";
+import {
+  createAdminTrialEntryCreateDraft,
+  toCreateAdminTrialEntryRequest,
+} from "../entry-create-model";
+
+const event: AdminTrialEventDetails = {
+  trialEventId: "event-1",
+  eventDate: "2026-07-21",
+  eventPlace: "Helsinki",
+  eventName: null,
+  jarjestaja: null,
+  ylituomari: "Judge",
+  ylituomariNumero: "123",
+  ytKertomus: null,
+  kennelpiiri: null,
+  kennelpiirinro: null,
+  sklKoeId: 456,
+  dogCount: 0,
+  entries: [],
+};
+
+describe("manual trial entry create model", () => {
+  it("starts clean with event judge defaults, NORMAL and one era", () => {
+    const draft = createAdminTrialEntryCreateDraft(event);
+    expect(draft.registrationNo).toBe("");
+    expect(draft.entry).toMatchObject({
+      koetyyppi: "NORMAL",
+      judge: "Judge",
+      ylituomariNumeroSnapshot: "123",
+    });
+    expect(draft.eras.map((era) => era.era)).toEqual([1]);
+  });
+
+  it("serializes the R1 request and keeps registration server normalization authoritative", () => {
+    const draft = createAdminTrialEntryCreateDraft(event);
+    draft.registrationNo = " FI 12345/21 ";
+    const result = toCreateAdminTrialEntryRequest(event.trialEventId, draft);
+    expect(result).toMatchObject({
+      ok: true,
+      request: {
+        trialEventId: "event-1",
+        registrationNo: "FI 12345/21",
+        entry: { judge: "Judge" },
+        eras: [{ era: 1 }],
+      },
+    });
+  });
+
+  it("rejects missing registration and malformed numeric input", () => {
+    const draft = createAdminTrialEntryCreateDraft(event);
+    expect(toCreateAdminTrialEntryRequest("event-1", draft)).toEqual({
+      ok: false,
+      section: "registration",
+    });
+    draft.registrationNo = "FI123";
+    draft.entry.points = "bad";
+    expect(toCreateAdminTrialEntryRequest("event-1", draft)).toEqual({
+      ok: false,
+      section: "entry",
+    });
+  });
+
+  it.each(["koiriaLuokassa", "hyvaksytytAjominuutit"] as const)(
+    "rejects oversized entry integer input in %s",
+    (field) => {
+      const draft = createAdminTrialEntryCreateDraft(event);
+      draft.registrationNo = "FI123";
+      draft.entry[field] = "9".repeat(400);
+
+      expect(toCreateAdminTrialEntryRequest("event-1", draft)).toEqual({
+        ok: false,
+        section: "entry",
+      });
+    },
+  );
+
+  it.each(["hakumin", "ajomin"] as const)(
+    "rejects oversized era integer input in %s",
+    (field) => {
+      const draft = createAdminTrialEntryCreateDraft(event);
+      draft.registrationNo = "FI123";
+      draft.eras[0][field] = "9".repeat(400);
+
+      expect(toCreateAdminTrialEntryRequest("event-1", draft)).toEqual({
+        ok: false,
+        section: "eras",
+      });
+    },
+  );
+
+  it("uses integer persistence order and omits empty lisatieto rows", () => {
+    const draft = createAdminTrialEntryCreateDraft(event);
+    draft.registrationNo = "FI43560/18";
+    const row25b = draft.lisatiedotRows.find(
+      (row) => row.koodi === "25" && row.osa === "b",
+    );
+    expect(row25b?.sortOrder).toBe(25.1);
+    expect(Number.isInteger(row25b?.jarjestys)).toBe(true);
+    if (row25b) row25b.eraValues[1] = "1";
+
+    const result = toCreateAdminTrialEntryRequest("event-1", draft);
+    expect(result).toMatchObject({
+      ok: true,
+      request: {
+        lisatiedotRows: [
+          expect.objectContaining({
+            koodi: "25",
+            osa: "b",
+            jarjestys: expect.any(Number),
+          }),
+        ],
+      },
+    });
+    if (result.ok) {
+      expect(result.request.lisatiedotRows).toHaveLength(1);
+      expect(Number.isInteger(result.request.lisatiedotRows[0].jarjestys)).toBe(
+        true,
+      );
+    }
+  });
+});
diff --git a/apps/web/lib/admin/trials/__tests__/entry-edit-dialog-model.test.ts b/apps/web/lib/admin/trials/__tests__/entry-edit-dialog-model.test.ts
index d68f9aca..e756df55 100644
--- a/apps/web/lib/admin/trials/__tests__/entry-edit-dialog-model.test.ts
+++ b/apps/web/lib/admin/trials/__tests__/entry-edit-dialog-model.test.ts
@@ -54,11 +54,24 @@ describe("entry edit lisatiedot model", () => {
     expect(parseInteger(" 42 ")).toBe(42);
   });
 
+  it("parses only integers representable by PostgreSQL Int", () => {
+    expect(parseInteger("-2147483648")).toBe(-2_147_483_648);
+    expect(parseInteger("2147483647")).toBe(2_147_483_647);
+    expect(parseInteger("-2147483649")).toBeNull();
+    expect(parseInteger("2147483648")).toBeNull();
+    expect(parseInteger("9".repeat(400))).toBeNull();
+  });
+
   it("validates optional numeric input before payload conversion", () => {
     expect(isValidOptionalInteger("")).toBe(true);
     expect(isValidOptionalInteger(" 42 ")).toBe(true);
+    expect(isValidOptionalInteger("-2147483648")).toBe(true);
+    expect(isValidOptionalInteger("2147483647")).toBe(true);
     expect(isValidOptionalInteger("12abc")).toBe(false);
     expect(isValidOptionalInteger("1-2")).toBe(false);
+    expect(isValidOptionalInteger("-2147483649")).toBe(false);
+    expect(isValidOptionalInteger("2147483648")).toBe(false);
+    expect(isValidOptionalInteger("9".repeat(400))).toBe(false);
 
     expect(isValidOptionalDecimal("")).toBe(true);
     expect(isValidOptionalDecimal(" 4,25 ")).toBe(true);
@@ -209,6 +222,7 @@ describe("entry edit lisatiedot model", () => {
     expect(
       rows.find((row) => row.koodi === "25" && row.osa === "b"),
     ).toMatchObject({
+      jarjestys: 26,
       eraValues: { 1: "0", 2: "" },
     });
     expect(
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 4fd230b5..fc745cb4 100644
--- a/apps/web/lib/admin/trials/__tests__/trial-route.test.ts
+++ b/apps/web/lib/admin/trials/__tests__/trial-route.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   getAdminTrialEventCreateHref,
+  getAdminTrialEntryCreateHref,
   getAdminTrialEventHref,
   getAdminTrialsHref,
 } from "../trial-route";
@@ -23,4 +24,10 @@ describe("admin trial route helpers", () => {
       "/admin/trials/event%2Fwith%20spaces",
     );
   });
+
+  it("builds a result creation href under the workspace", () => {
+    expect(getAdminTrialEntryCreateHref("event-1")).toBe(
+      "/admin/trials/event-1/results/new",
+    );
+  });
 });
diff --git a/apps/web/lib/admin/trials/entry-create-model.ts b/apps/web/lib/admin/trials/entry-create-model.ts
new file mode 100644
index 00000000..6bc6fa36
--- /dev/null
+++ b/apps/web/lib/admin/trials/entry-create-model.ts
@@ -0,0 +1,183 @@
+import type {
+  AdminTrialEventDetails,
+  AdminTrialEventEntry,
+  CreateAdminTrialEntryRequest,
+} from "@beagle/contracts";
+import {
+  createEmptyEraDraft,
+  isValidOptionalDecimal,
+  isValidOptionalInteger,
+  parseDecimal,
+  parseInteger,
+  parseNullableString,
+  toEntryDraft,
+  toLisatietoRows,
+  type EntryDraft,
+  type EraDraft,
+  type LisatietoRowDraft,
+} from "./entry-edit-dialog-model";
+
+export type AdminTrialEntryCreateDraft = {
+  registrationNo: string;
+  entry: EntryDraft;
+  eras: EraDraft[];
+  lisatiedotRows: LisatietoRowDraft[];
+};
+
+export type AdminTrialEntryCreateValidation =
+  | { ok: true; request: CreateAdminTrialEntryRequest }
+  | { ok: false; section: "registration" | "entry" | "eras" };
+
+function emptyEntry(event: AdminTrialEventDetails): AdminTrialEventEntry {
+  return {
+    trialId: "",
+    dogId: null,
+    dogName: "",
+    registrationNo: null,
+    entryKey: "",
+    koemuoto: null,
+    koetyyppi: "NORMAL",
+    rank: null,
+    award: null,
+    points: null,
+    judge: event.ylituomari,
+    ylituomariNumeroSnapshot: event.ylituomariNumero,
+    eras: [],
+  };
+}
+
+export function createAdminTrialEntryCreateDraft(
+  event: AdminTrialEventDetails,
+): AdminTrialEntryCreateDraft {
+  const entry = emptyEntry(event);
+  const eras = [createEmptyEraDraft(1)];
+  return {
+    registrationNo: "",
+    entry: toEntryDraft(entry),
+    eras,
+    lisatiedotRows: toLisatietoRows(entry, eras),
+  };
+}
+
+export function areAdminTrialEntryCreateDraftsEqual(
+  left: AdminTrialEntryCreateDraft,
+  right: AdminTrialEntryCreateDraft,
+): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export function toCreateAdminTrialEntryRequest(
+  trialEventId: string,
+  draft: AdminTrialEntryCreateDraft,
+): AdminTrialEntryCreateValidation {
+  if (!draft.registrationNo.trim())
+    return { ok: false, section: "registration" };
+  const integerValues = [
+    draft.entry.koiriaLuokassa,
+    draft.entry.hyvaksytytAjominuutit,
+  ];
+  const decimalValues = [
+    draft.entry.points,
+    draft.entry.ajoajanPisteet,
+    draft.entry.haku,
+    draft.entry.hauk,
+    draft.entry.yva,
+    draft.entry.hlo,
+    draft.entry.alo,
+    draft.entry.tja,
+    draft.entry.pin,
+    draft.entry.ansiopisteetYhteensa,
+    draft.entry.tappiopisteetYhteensa,
+  ];
+  if (
+    integerValues.some((value) => !isValidOptionalInteger(value)) ||
+    decimalValues.some((value) => !isValidOptionalDecimal(value))
+  ) {
+    return { ok: false, section: "entry" };
+  }
+  const eras = [...draft.eras].sort((a, b) => a.era - b.era);
+  if (
+    !eras.length ||
+    eras.some(
+      (era, index) =>
+        era.era !== index + 1 ||
+        !isValidOptionalInteger(era.hakumin) ||
+        !isValidOptionalInteger(era.ajomin) ||
+        [era.haku, era.hauk, era.yva, era.hlo, era.alo, era.tja, era.pin].some(
+          (value) => !isValidOptionalDecimal(value),
+        ),
+    )
+  ) {
+    return { ok: false, section: "eras" };
+  }
+  const entry = draft.entry;
+  return {
+    ok: true,
+    request: {
+      trialEventId,
+      registrationNo: draft.registrationNo.trim(),
+      entry: {
+        koemaasto: parseNullableString(entry.koemaasto),
+        koemuoto: parseNullableString(entry.koemuoto),
+        koetyyppi: entry.koetyyppi,
+        ke: parseNullableString(entry.ke),
+        lk: parseNullableString(entry.lk),
+        award: parseNullableString(entry.award),
+        rank: parseNullableString(entry.rank),
+        points: parseDecimal(entry.points),
+        koiriaLuokassa: parseInteger(entry.koiriaLuokassa),
+        hyvaksytytAjominuutit: parseInteger(entry.hyvaksytytAjominuutit),
+        ajoajanPisteet: parseDecimal(entry.ajoajanPisteet),
+        haku: parseDecimal(entry.haku),
+        hauk: parseDecimal(entry.hauk),
+        yva: parseDecimal(entry.yva),
+        hlo: parseDecimal(entry.hlo),
+        alo: parseDecimal(entry.alo),
+        tja: parseDecimal(entry.tja),
+        pin: parseDecimal(entry.pin),
+        ansiopisteetYhteensa: parseDecimal(entry.ansiopisteetYhteensa),
+        tappiopisteetYhteensa: parseDecimal(entry.tappiopisteetYhteensa),
+        judge: parseNullableString(entry.judge),
+        huomautus: entry.huomautus || null,
+        huomautusTeksti: parseNullableString(entry.huomautusTeksti),
+        ylituomariNumeroSnapshot: parseNullableString(
+          entry.ylituomariNumeroSnapshot,
+        ),
+        ryhmatuomariNimi: parseNullableString(entry.ryhmatuomariNimi),
+        palkintotuomariNimi: parseNullableString(entry.palkintotuomariNimi),
+        omistajaSnapshot: parseNullableString(entry.omistajaSnapshot),
+        omistajanKotikuntaSnapshot: parseNullableString(
+          entry.omistajanKotikuntaSnapshot,
+        ),
+      },
+      eras: eras.map((era) => ({
+        era: era.era,
+        alkoi: parseNullableString(era.alkoi),
+        hakumin: parseInteger(era.hakumin),
+        ajomin: parseInteger(era.ajomin),
+        haku: parseDecimal(era.haku),
+        hauk: parseDecimal(era.hauk),
+        yva: parseDecimal(era.yva),
+        hlo: parseDecimal(era.hlo),
+        alo: parseDecimal(era.alo),
+        tja: parseDecimal(era.tja),
+        pin: parseDecimal(era.pin),
+        huomautusTeksti: parseNullableString(era.huomautusTeksti),
+      })),
+      lisatiedotRows: draft.lisatiedotRows
+        .filter((row) =>
+          eras.some((era) => (row.eraValues[era.era] ?? "").trim().length > 0),
+        )
+        .map((row) => ({
+          koodi: row.koodi,
+          osa: row.osa,
+          nimi: row.nimi,
+          jarjestys: row.jarjestys,
+          eraValues: eras.map((era) => ({
+            era: era.era,
+            arvo: parseNullableString(row.eraValues[era.era] ?? ""),
+          })),
+        })),
+    },
+  };
+}
diff --git a/apps/web/lib/admin/trials/entry-edit-config.ts b/apps/web/lib/admin/trials/entry-edit-config.ts
index 43b65f22..115ba8ea 100644
--- a/apps/web/lib/admin/trials/entry-edit-config.ts
+++ b/apps/web/lib/admin/trials/entry-edit-config.ts
@@ -33,6 +33,7 @@ export type AdminTrialLisatietoConfig = {
   label: string;
   inputKind: AdminTrialLisatietoInputKind;
   sortOrder: number;
+  persistenceOrder: number;
 };
 
 function defineLisatieto(
@@ -42,7 +43,7 @@ function defineLisatieto(
   inputKind: AdminTrialLisatietoInputKind,
   sortOrder: number,
   osa = "",
-): AdminTrialLisatietoConfig {
+): Omit<AdminTrialLisatietoConfig, "persistenceOrder"> {
   return { koodi, osa, group, label, inputKind, sortOrder };
 }
 
@@ -59,7 +60,7 @@ export const ADMIN_TRIAL_LISATIETO_GROUP_LABELS: Record<
   unknown: "Muut / tuntemattomat",
 };
 
-export const ADMIN_TRIAL_LISATIETO_CONFIG = [
+const ADMIN_TRIAL_LISATIETO_CONFIG_SOURCE = [
   defineLisatieto("10", "olosuhteet", "Vaativat olosuhteet", "marker", 10),
   defineLisatieto("11", "olosuhteet", "Paljas maa", "marker", 11),
   defineLisatieto("12", "olosuhteet", "Lumikeli", "integer", 12),
@@ -142,7 +143,16 @@ export const ADMIN_TRIAL_LISATIETO_CONFIG = [
   ),
   defineLisatieto("61", "muut_ominaisuudet", "Hallittavuus", "decimal", 61),
   defineLisatieto("62", "muut_ominaisuudet", "Matka ajoerässä", "decimal", 62),
-] as const satisfies readonly AdminTrialLisatietoConfig[];
+] as const satisfies readonly Omit<
+  AdminTrialLisatietoConfig,
+  "persistenceOrder"
+>[];
+
+export const ADMIN_TRIAL_LISATIETO_CONFIG: readonly AdminTrialLisatietoConfig[] =
+  ADMIN_TRIAL_LISATIETO_CONFIG_SOURCE.map((item, index) => ({
+    ...item,
+    persistenceOrder: index + 1,
+  }));
 
 export const ADMIN_TRIAL_LISATIETO_KOODIT = Array.from(
   new Set(ADMIN_TRIAL_LISATIETO_CONFIG.map((item) => item.koodi)),
diff --git a/apps/web/lib/admin/trials/entry-edit-dialog-model.ts b/apps/web/lib/admin/trials/entry-edit-dialog-model.ts
index 0264c68c..7a0af752 100644
--- a/apps/web/lib/admin/trials/entry-edit-dialog-model.ts
+++ b/apps/web/lib/admin/trials/entry-edit-dialog-model.ts
@@ -199,7 +199,7 @@ export function toLisatietoRows(
       koodi: config.koodi,
       osa: config.osa,
       nimi: config.label,
-      jarjestys: config.sortOrder,
+      jarjestys: config.persistenceOrder,
     });
   }
 
@@ -211,6 +211,7 @@ export function toLisatietoRows(
         nimi: item.nimi,
         jarjestys: item.jarjestys,
       });
+      row.jarjestys = item.jarjestys;
       row.eraValues[era.era] = item.arvo;
     }
   }
@@ -238,12 +239,19 @@ export function toLisatietoRows(
   });
 }
 
+const MIN_DB_INTEGER = -2_147_483_648;
+const MAX_DB_INTEGER = 2_147_483_647;
+
 export function parseInteger(value: string): number | null {
   const trimmed = value.trim();
   if (!trimmed) return null;
   if (!/^-?\d+$/.test(trimmed)) return null;
   const parsed = Number.parseInt(trimmed, 10);
-  return Number.isInteger(parsed) ? parsed : null;
+  return Number.isSafeInteger(parsed) &&
+    parsed >= MIN_DB_INTEGER &&
+    parsed <= MAX_DB_INTEGER
+    ? parsed
+    : null;
 }
 
 export function parseDecimal(value: string): number | null {
@@ -255,7 +263,7 @@ export function parseDecimal(value: string): number | null {
 
 export function isValidOptionalInteger(value: string): boolean {
   const trimmed = value.trim();
-  return trimmed.length === 0 || /^-?\d+$/.test(trimmed);
+  return trimmed.length === 0 || parseInteger(trimmed) !== null;
 }
 
 export function isValidOptionalDecimal(value: string): boolean {
diff --git a/apps/web/lib/admin/trials/index.ts b/apps/web/lib/admin/trials/index.ts
index 6eb021d1..02c2b754 100644
--- a/apps/web/lib/admin/trials/index.ts
+++ b/apps/web/lib/admin/trials/index.ts
@@ -1,2 +1,7 @@
 export * from "./trial-route";
 export * from "./submit-admin-trial-event-creation";
+export * from "./entry-create-model";
+export {
+  createEmptyEraDraft,
+  getNextEraNumber,
+} from "./entry-edit-dialog-model";
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
index 6e99cc7f..1b8ff22a 100644
--- a/apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts
+++ b/apps/web/lib/admin/trials/submit-admin-trial-event-creation.ts
@@ -3,7 +3,7 @@ import type {
   CreateAdminTrialEventResponse,
 } from "@beagle/contracts";
 import { AdminMutationError } from "@/queries/admin/mutation-error";
-import { getAdminTrialEventHref } from "./trial-route";
+import { getAdminTrialEntryCreateHref } from "./trial-route";
 
 export type AdminTrialEventCreationDraft = {
   eventDate: string;
@@ -93,7 +93,7 @@ export async function submitAdminTrialEventCreation({
       kennelpiirinro: draft.kennelpiirinro.trim() || null,
       sklKoeId,
     });
-    replace(getAdminTrialEventHref(result.trialEventId));
+    replace(getAdminTrialEntryCreateHref(result.trialEventId));
   } catch (error) {
     setErrorText(
       error instanceof AdminMutationError
diff --git a/apps/web/lib/admin/trials/trial-route.ts b/apps/web/lib/admin/trials/trial-route.ts
index 03871766..f88d338d 100644
--- a/apps/web/lib/admin/trials/trial-route.ts
+++ b/apps/web/lib/admin/trials/trial-route.ts
@@ -11,3 +11,7 @@ export function getAdminTrialEventCreateHref(): string {
 export function getAdminTrialEventHref(trialEventId: string): string {
   return `${ADMIN_TRIALS_ROUTE_ROOT}/${encodeURIComponent(trialEventId)}`;
 }
+
+export function getAdminTrialEntryCreateHref(trialEventId: string): string {
+  return `${getAdminTrialEventHref(trialEventId)}/results/new`;
+}
diff --git a/apps/web/lib/i18n/messages/admin/trials/manage.ts b/apps/web/lib/i18n/messages/admin/trials/manage.ts
index ba6f8a6d..82e3ad82 100644
--- a/apps/web/lib/i18n/messages/admin/trials/manage.ts
+++ b/apps/web/lib/i18n/messages/admin/trials/manage.ts
@@ -55,6 +55,53 @@ export const fiAdminTrialsManageMessages = {
   "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.resultCreate.action": "Lisää tulos",
+  "admin.trials.manage.resultCreate.title": "Lisää koetulos",
+  "admin.trials.manage.resultCreate.loading": "Ladataan tapahtumaa...",
+  "admin.trials.manage.resultCreate.loadError":
+    "Tapahtuman lataaminen epäonnistui.",
+  "admin.trials.manage.resultCreate.eventNotFound":
+    "Ajokoetapahtumaa ei löytynyt.",
+  "admin.trials.manage.resultCreate.missingSklId":
+    "Tulosta ei voi lisätä, koska tapahtumalta puuttuu SKL koe ID.",
+  "admin.trials.manage.resultCreate.backToList": "Takaisin tapahtumiin",
+  "admin.trials.manage.resultCreate.backToWorkspace":
+    "Takaisin tapahtuman sivulle",
+  "admin.trials.manage.resultCreate.registration": "Rekisterinumero",
+  "admin.trials.manage.resultCreate.saveAnother": "Tallenna ja lisää seuraava",
+  "admin.trials.manage.resultCreate.saveFinish": "Tallenna ja lopeta",
+  "admin.trials.manage.resultCreate.cancel": "Peruuta",
+  "admin.trials.manage.resultCreate.success": "Koetulos tallennettiin.",
+  "admin.trials.manage.resultCreate.validation.registration":
+    "Anna rekisterinumero.",
+  "admin.trials.manage.resultCreate.validation.entry":
+    "Tarkista tuloksen numeeriset kentät.",
+  "admin.trials.manage.resultCreate.validation.eras":
+    "Tarkista erien numerointi ja numeeriset kentät.",
+  "admin.trials.manage.resultCreate.error.registration":
+    "Rekisterinumero ei ole kelvollinen.",
+  "admin.trials.manage.resultCreate.error.conflict":
+    "Tällä rekisterinumerolla on jo tulos tapahtumassa.",
+  "admin.trials.manage.resultCreate.error.entry":
+    "Tarkista tuloksen perustiedot.",
+  "admin.trials.manage.resultCreate.error.eras": "Tarkista erien tiedot.",
+  "admin.trials.manage.resultCreate.error.additionalInfo":
+    "Tarkista lisätietojen arvot.",
+  "admin.trials.manage.resultCreate.error.additionalInfoOrder":
+    "Lomake muodosti virheellisen järjestyksen lisätiedolle",
+  "admin.trials.manage.resultCreate.error.additionalInfoRow":
+    "Palvelin hylkäsi lisätiedon",
+  "admin.trials.manage.resultCreate.error.eventNotFound":
+    "Ajokoetapahtumaa ei enää löytynyt.",
+  "admin.trials.manage.resultCreate.error.missingSklId":
+    "Tapahtumalta puuttuu SKL koe ID.",
+  "admin.trials.manage.resultCreate.error.generic":
+    "Koetuloksen tallentaminen epäonnistui.",
+  "admin.trials.manage.resultCreate.unsaved.title": "Hylätäänkö muutokset?",
+  "admin.trials.manage.resultCreate.unsaved.body":
+    "Tallentamattomat tiedot menetetään.",
+  "admin.trials.manage.resultCreate.unsaved.confirm": "Hylkää muutokset",
+  "admin.trials.manage.resultCreate.unsaved.cancel": "Jatka muokkaamista",
   "admin.trials.manage.deleteEvent.action": "Poista tapahtuma",
   "admin.trials.manage.deleteEvent.confirmTitle": "Poistetaanko tapahtuma?",
   "admin.trials.manage.deleteEvent.confirmBody":
@@ -211,6 +258,54 @@ export const svAdminTrialsManageMessages = {
   "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.resultCreate.action": "Lägg till resultat",
+  "admin.trials.manage.resultCreate.title": "Lägg till provresultat",
+  "admin.trials.manage.resultCreate.loading": "Laddar evenemanget...",
+  "admin.trials.manage.resultCreate.loadError":
+    "Det gick inte att ladda evenemanget.",
+  "admin.trials.manage.resultCreate.eventNotFound":
+    "Jaktprovsevenemanget hittades inte.",
+  "admin.trials.manage.resultCreate.missingSklId":
+    "Resultatet kan inte läggas till eftersom evenemanget saknar SKL prov-ID.",
+  "admin.trials.manage.resultCreate.backToList": "Tillbaka till evenemangen",
+  "admin.trials.manage.resultCreate.backToWorkspace":
+    "Tillbaka till evenemangssidan",
+  "admin.trials.manage.resultCreate.registration": "Registreringsnummer",
+  "admin.trials.manage.resultCreate.saveAnother": "Spara och lägg till nästa",
+  "admin.trials.manage.resultCreate.saveFinish": "Spara och avsluta",
+  "admin.trials.manage.resultCreate.cancel": "Avbryt",
+  "admin.trials.manage.resultCreate.success": "Provresultatet sparades.",
+  "admin.trials.manage.resultCreate.validation.registration":
+    "Ange registreringsnummer.",
+  "admin.trials.manage.resultCreate.validation.entry":
+    "Kontrollera resultatets numeriska fält.",
+  "admin.trials.manage.resultCreate.validation.eras":
+    "Kontrollera omgångarnas numrering och numeriska fält.",
+  "admin.trials.manage.resultCreate.error.registration":
+    "Registreringsnumret är ogiltigt.",
+  "admin.trials.manage.resultCreate.error.conflict":
+    "Registreringsnumret har redan ett resultat i evenemanget.",
+  "admin.trials.manage.resultCreate.error.entry":
+    "Kontrollera resultatets grunduppgifter.",
+  "admin.trials.manage.resultCreate.error.eras":
+    "Kontrollera omgångarnas uppgifter.",
+  "admin.trials.manage.resultCreate.error.additionalInfo":
+    "Kontrollera tilläggsuppgifternas värden.",
+  "admin.trials.manage.resultCreate.error.additionalInfoOrder":
+    "Formuläret skapade en ogiltig ordning för tilläggsuppgiften",
+  "admin.trials.manage.resultCreate.error.additionalInfoRow":
+    "Servern avvisade tilläggsuppgiften",
+  "admin.trials.manage.resultCreate.error.eventNotFound":
+    "Jaktprovsevenemanget finns inte längre.",
+  "admin.trials.manage.resultCreate.error.missingSklId":
+    "Evenemanget saknar SKL prov-ID.",
+  "admin.trials.manage.resultCreate.error.generic":
+    "Det gick inte att spara provresultatet.",
+  "admin.trials.manage.resultCreate.unsaved.title": "Kassera ändringarna?",
+  "admin.trials.manage.resultCreate.unsaved.body":
+    "Uppgifter som inte sparats går förlorade.",
+  "admin.trials.manage.resultCreate.unsaved.confirm": "Kassera ändringarna",
+  "admin.trials.manage.resultCreate.unsaved.cancel": "Fortsätt redigera",
   "admin.trials.manage.deleteEvent.action": "Ta bort evenemang",
   "admin.trials.manage.deleteEvent.confirmTitle": "Ta bort evenemanget?",
   "admin.trials.manage.deleteEvent.confirmBody":
diff --git a/apps/web/queries/admin/mutation-error.ts b/apps/web/queries/admin/mutation-error.ts
index bd4cb7c1..9bec0c2a 100644
--- a/apps/web/queries/admin/mutation-error.ts
+++ b/apps/web/queries/admin/mutation-error.ts
@@ -1,7 +1,11 @@
 export class AdminMutationError extends Error {
   readonly errorCode?: string;
 
-  constructor(message: string, errorCode?: string) {
+  constructor(
+    message: string,
+    errorCode?: string,
+    readonly details?: unknown,
+  ) {
     super(message);
     this.name = "AdminMutationError";
     this.errorCode = errorCode;
diff --git a/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-entry-mutation.test.ts b/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-entry-mutation.test.ts
new file mode 100644
index 00000000..f5a08f26
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/__tests__/use-create-admin-trial-entry-mutation.test.ts
@@ -0,0 +1,61 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useCreateAdminTrialEntryMutation } from "../use-create-admin-trial-entry-mutation";
+
+const { useMutation, invalidateQueries, action } = vi.hoisted(() => ({
+  useMutation: vi.fn(),
+  invalidateQueries: vi.fn(),
+  action: vi.fn(),
+}));
+vi.mock("@tanstack/react-query", () => ({
+  useMutation,
+  useQueryClient: () => ({ invalidateQueries }),
+}));
+vi.mock("@/app/actions/admin/trials/manage/create-admin-trial-entry", () => ({
+  createAdminTrialEntryAction: action,
+}));
+
+describe("useCreateAdminTrialEntryMutation", () => {
+  beforeEach(() => {
+    useMutation.mockReset();
+    invalidateQueries.mockReset();
+    action.mockReset();
+    useMutation.mockImplementation((options) => options);
+  });
+  it("calls the R1 action and refetches all affected query roots", async () => {
+    action.mockResolvedValue({
+      hasError: false,
+      data: { trialEventId: "event-1", trialEntryId: "entry-1" },
+    });
+    useCreateAdminTrialEntryMutation();
+    const options = useMutation.mock.calls[0][0];
+    await expect(
+      options.mutationFn({ trialEventId: "event-1" }),
+    ).resolves.toEqual({ trialEventId: "event-1", trialEntryId: "entry-1" });
+    await options.onSuccess();
+    expect(invalidateQueries).toHaveBeenCalledTimes(5);
+    expect(invalidateQueries).toHaveBeenCalledWith(
+      expect.objectContaining({ refetchType: "all" }),
+    );
+  });
+  it("surfaces the stable action error code", async () => {
+    action.mockResolvedValue({
+      hasError: true,
+      data: null,
+      errorCode: "INVALID_TRIAL_ADDITIONAL_INFO",
+      message: "Invalid",
+      validationIssue: {
+        area: "additional_info",
+        reason: "invalid_lisatieto_order",
+        koodi: "25",
+        osa: "b",
+      },
+    });
+    useCreateAdminTrialEntryMutation();
+    await expect(
+      useMutation.mock.calls[0][0].mutationFn({}),
+    ).rejects.toMatchObject({
+      errorCode: "INVALID_TRIAL_ADDITIONAL_INFO",
+      details: { koodi: "25", osa: "b" },
+    });
+  });
+});
diff --git a/apps/web/queries/admin/trials/manage/index.ts b/apps/web/queries/admin/trials/manage/index.ts
index f798a697..f468da92 100644
--- a/apps/web/queries/admin/trials/manage/index.ts
+++ b/apps/web/queries/admin/trials/manage/index.ts
@@ -1,5 +1,6 @@
 export * from "./query-keys";
 export * from "./use-create-admin-trial-event-mutation";
+export * from "./use-create-admin-trial-entry-mutation";
 export * from "./use-delete-admin-trial-event-mutation";
 export * from "./use-admin-trial-event-query";
 export * from "./use-admin-trial-events-query";
diff --git a/apps/web/queries/admin/trials/manage/use-create-admin-trial-entry-mutation.ts b/apps/web/queries/admin/trials/manage/use-create-admin-trial-entry-mutation.ts
new file mode 100644
index 00000000..077c51e2
--- /dev/null
+++ b/apps/web/queries/admin/trials/manage/use-create-admin-trial-entry-mutation.ts
@@ -0,0 +1,62 @@
+"use client";
+
+import type {
+  CreateAdminTrialEntryRequest,
+  CreateAdminTrialEntryResponse,
+} from "@beagle/contracts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { createAdminTrialEntryAction } from "@/app/actions/admin/trials/manage/create-admin-trial-entry";
+import { AdminMutationError } from "@/queries/admin/mutation-error";
+import { beagleDogsQueryKeyRoot } from "@/queries/public/beagle/dogs/profile/query-keys";
+import { beagleTrialsQueryKeyRoot } from "@/queries/public/beagle/trials/query-keys";
+import { homeStatisticsQueryKey } from "@/queries/public/home/statistics/query-keys";
+import {
+  adminTrialEventQueryKeyRoot,
+  adminTrialEventsQueryKeyRoot,
+} from "./query-keys";
+
+export function useCreateAdminTrialEntryMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation<
+    CreateAdminTrialEntryResponse,
+    AdminMutationError,
+    CreateAdminTrialEntryRequest
+  >({
+    mutationFn: async (input) => {
+      const result = await createAdminTrialEntryAction(input);
+      if (result.hasError || !result.data) {
+        throw new AdminMutationError(
+          result.message ?? "Failed to create trial entry.",
+          result.errorCode,
+          result.validationIssue,
+        );
+      }
+      return result.data;
+    },
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: adminTrialEventsQueryKeyRoot,
+          refetchType: "all",
+        }),
+        queryClient.invalidateQueries({
+          queryKey: adminTrialEventQueryKeyRoot,
+          refetchType: "all",
+        }),
+        queryClient.invalidateQueries({
+          queryKey: beagleTrialsQueryKeyRoot,
+          refetchType: "all",
+        }),
+        queryClient.invalidateQueries({
+          queryKey: beagleDogsQueryKeyRoot,
+          refetchType: "all",
+        }),
+        queryClient.invalidateQueries({
+          queryKey: homeStatisticsQueryKey,
+          refetchType: "all",
+        }),
+      ]);
+    },
+  });
+}
diff --git a/docs/features/admin-trial-management.md b/docs/features/admin-trial-management.md
index f2f0c831..25c88de6 100644
--- a/docs/features/admin-trial-management.md
+++ b/docs/features/admin-trial-management.md
@@ -14,14 +14,16 @@ and follow-up admin flow redesign).
   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.
-- The R1 backend contract can create one manual result at a time through an
-  admin Server Action. It is intentionally not linked to a UI until R2.
+- An admin can create one manual result at a time from an event workspace.
+  The full-page form supports saving another result for the same event or
+  finishing back at the workspace.
 
 ## 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/app/(admin)/admin/trials/[trialEventId]/results/new/page.tsx`: manual result creation 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
@@ -45,10 +47,12 @@ and follow-up admin flow redesign).
    only the `trialEventId` from its route.
 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.
+5. Successful event creation opens the first manual result form for the new event.
 6. Manual result creation validates and canonicalizes the typed registration,
    then atomically creates the entry, eras, and lisätiedot. A matching local
    `DogRegistration` links the dog; an unknown registration remains unlinked.
+7. Successful result creation refetches admin event data and affected public
+   trial, dog-profile trial, and home-statistics queries without optimistic rows.
 
 ## Contract rules
 
@@ -63,6 +67,10 @@ and follow-up admin flow redesign).
   `TRIAL_ENTRY_REGISTRATION_CONFLICT`.
 - Manual result writes require each normalized lisätieto `(koodi, osa)` pair
   to occur only once across the submitted matrix rows.
+- Lisätieto UI sorting is separate from its integer persisted `jarjestys`;
+  unused create-form rows are omitted from the write payload.
+- Manual-result validation errors may carry safe structured field context for
+  localized feedback without exposing raw user-entered values.
 - `TrialEvent.koepaiva` is a PostgreSQL `DATE`; all trial contracts serialize
   it as timezone-free `YYYY-MM-DD`.
 - Empty event deletion returns `TRIAL_EVENT_NOT_EMPTY` if result rows are
@@ -76,6 +84,10 @@ and follow-up admin flow redesign).
 
 - Event rows/cards are the interaction target for choosing a selected event.
 - The selected-event header has event edit and workspace navigation actions.
+- The event workspace links to the full-page result form. Dirty result forms
+  confirm internal navigation and use native unload protection for refresh or
+  close. Browser Back leaves the form without application confirmation because
+  the App Router has no reliable asynchronous route-blocking hook.
 - 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.
diff --git a/docs/planning/trials/README.md b/docs/planning/trials/README.md
index 0dc0ccb9..19878253 100644
--- a/docs/planning/trials/README.md
+++ b/docs/planning/trials/README.md
@@ -19,6 +19,9 @@ on the next gate.
   identity, transaction, error, date-only, and Server Action backend contract.
 - [Result creation R2](./result-creation-r2.md) defines the full-page result
   form and admin UI workflow built on the approved R1 contract.
+- [Rule-window-aware result fields](./result-fields-by-rule-window.md) defines
+  the second result-creation follow-up after R2: introduce field-set selection
+  for every rule window and verify the 2023+ set first.
 - [Later UX](./later-ux.md) records deferred ideas only and does not authorize
   their implementation.
 
@@ -76,12 +79,15 @@ E2
 R1 (backend)
  ↓
 R2 (UI)
+ ↓
+R3 (rule-window field sets)
 ```
 
 1. `E1` - event workspace
 2. `E2` - event creation and empty-event lifecycle
 3. `R1` - manual result schema and backend
 4. `R2` - manual result UI and workflow
+5. `R3` - rule-window-aware result fields, after R2 review
 
 For every gate:
 
diff --git a/docs/planning/trials/result-creation-r2.md b/docs/planning/trials/result-creation-r2.md
index eca74759..e0efcb80 100644
--- a/docs/planning/trials/result-creation-r2.md
+++ b/docs/planning/trials/result-creation-r2.md
@@ -28,6 +28,8 @@ R2 consumes, but does not redefine or weaken, the R1 decisions for:
 
 R2 maps stable `errorCode` values to localized presentation and never inspects
 backend message strings to determine behavior.
+When R1 supplies typed validation details, R2 uses their stable reason and safe
+field context to identify the rejected section or lisätieto row.
 
 ## Scope
 
@@ -56,8 +58,10 @@ backend message strings to determine behavior.
   - Cancel returns to the event workspace.
   - Dirty cancel uses a localized application confirmation dialog before
     discarding values.
-  - Browser-back and internal navigation use a route-blocking application
-    confirmation where technically supported.
+  - Internal navigation uses a route-blocking application confirmation.
+  - Browser Back leaves the form without application confirmation; robust Back
+    interception is deferred until it can use a deterministic history-state
+    design with browser-level tests.
   - Refresh and tab/window close use browser-native unsaved-change protection
     with browser-controlled wording.
   - Clean browser back returns to the event workspace without confirmation.
diff --git a/docs/planning/trials/result-creation.md b/docs/planning/trials/result-creation.md
index 1e4ad78a..3b04b02d 100644
--- a/docs/planning/trials/result-creation.md
+++ b/docs/planning/trials/result-creation.md
@@ -179,6 +179,9 @@ Existing `UNAUTHENTICATED` and `FORBIDDEN` authorization codes remain in use.
   outcomes, and owns structured success/failure logging.
 - The Server Action performs its existing admin/session guard and passes the
   service code through as `errorCode` without interpreting message text.
+- Validation failures may also include a typed, safe `details` issue with the
+  validation area/reason and affected lisätieto code/part. Raw entered values
+  are not exposed through validation details.
 
 ## Date-only invariant
 
diff --git a/docs/planning/trials/result-fields-by-rule-window.md b/docs/planning/trials/result-fields-by-rule-window.md
new file mode 100644
index 00000000..937e7e33
--- /dev/null
+++ b/docs/planning/trials/result-fields-by-rule-window.md
@@ -0,0 +1,108 @@
+# Follow-up R3 — Rule-window-aware Result Fields
+
+## Status and sequencing
+
+This is the second result-creation follow-up after the current R2 implementation
+and validation work. It is planning only and does not authorize implementation.
+
+R2 must be completed and reviewed before this work begins. The initial R3
+change introduces the rule-window structure and verifies only the current
+2023+ field set. Exact historical field-set audits remain separate follow-up
+work.
+
+## Purpose
+
+Make manual trial result creation and editing choose their visible score, era,
+and lisätieto fields from the event's persisted `trialRuleWindowId`. This keeps
+the current form aligned with the corresponding dog-trial PDF without coupling
+form behavior to PDF coordinates.
+
+The current mismatch is structural:
+
+- PDF rendering already selects a renderer by rule window, while the admin form
+  uses one global field list.
+- The 2023+ renderer does not print the current form's `tja` and `pin` score
+  fields.
+- The current PDF consumes only part `a` for lisätieto codes `25` and `27`,
+  while the form exposes parts `a`, `b`, and `c`.
+- Lisätieto input types differ for codes `19`, `23`, `26`, and `59`.
+- Historical templates contain different score and lisätieto sets.
+
+## Scope
+
+- Add `trialRuleWindowId` to the admin event-detail contract and propagate the
+  stored value through the DB and service mappings.
+- Add a semantic admin result field-set registry covering every seeded rule
+  window ID.
+- Keep PDF coordinates and drawing logic inside the PDF rule-set modules. The
+  shared semantic configuration defines field availability and value kinds,
+  not layout.
+- Configure `trw_post_20230801` as the first verified field set:
+  - drive visible entry score fields, era fields, and lisätieto rows from the
+    configuration;
+  - omit current-window score fields not consumed by the 2023+ PDF;
+  - represent codes `25` and `27` with the PDF-consumed `a` part without showing
+    the implementation suffix to the administrator;
+  - correct lisätieto value kinds to match the current renderer; and
+  - retain shared registration, owner, judge, result-status, trial-type, and
+    other metadata required by persistence or PDF generation.
+- Register other known, null, and unknown rule windows through one explicitly
+  unverified fallback matching the current form behavior. Show a localized
+  warning instead of presenting the fallback as template-verified.
+- Apply the selected field set to both the full-page create form and the
+  existing edit modal.
+- Preserve hidden values when editing an existing result. Selecting a narrower
+  field set must not silently clear compatibility data or source-projected
+  lisätieto rows.
+- Keep backend write shapes and their existing validation semantics unchanged.
+  This gate controls admin presentation and does not add rule-window-specific
+  server rejection.
+- Update the durable admin-trial documentation and add a user-visible
+  `CHANGELOG.md` entry when the behavior is implemented.
+
+## Exclusions
+
+- No Prisma schema or migration changes.
+- No new production dependency.
+- No PDF coordinate or template changes.
+- No claim that 2005–2011 or 2011–2023 admin field sets are exact.
+- No removal or migration of stored compatibility fields.
+- No rule-window-specific validation in Koiratietokanta ingestion.
+- No redesign of result creation or the existing edit modal.
+
+## Acceptance criteria
+
+- Admin event details return the event's persisted `trialRuleWindowId`.
+- Create and edit resolve their field set from that stored ID rather than from
+  the browser date.
+- A 2023+ event displays the verified score, era, and lisätieto configuration.
+- Codes `25` and `27` persist with part `a`, appear as single rows, and reach
+  the existing PDF pivot correctly.
+- Current-window lisätieto value kinds match the 2023+ renderer.
+- Other known, null, and unknown windows retain the existing generic editing
+  capability and display an unverified-field-set warning.
+- Editing through a narrower field set preserves hidden existing values.
+- Existing create/update request contracts and server validation behavior do
+  not change.
+
+## Targeted validation
+
+- Contract, DB-mapping, and service tests for `trialRuleWindowId` in admin event
+  details.
+- Field-registry tests covering every seeded rule-window ID and fallback
+  behavior.
+- 2023+ parity tests for visible score fields, era fields, lisätieto codes,
+  parts, ordering, and input kinds.
+- Create-form and edit-modal tests for rule selection, the fallback warning,
+  and hidden-value preservation.
+- Regression tests for request serialization, current validation feedback, and
+  PDF part-`a` mapping.
+- Targeted web, contracts, server, and DB type checks and tests, plus targeted
+  lint without cycle lint.
+
+## Later historical audit
+
+After R3 is reviewed, separately compare the 2005–2011 and 2011–2023 PDF
+templates and renderers with stored legacy/API data. Replace the unverified
+fallback for each window only after its score fields, supported era behavior,
+lisätieto rows, value kinds, and preservation behavior have dedicated tests.
diff --git a/docs/tech-debt.md b/docs/tech-debt.md
index b5258ee4..fefe4a57 100644
--- a/docs/tech-debt.md
+++ b/docs/tech-debt.md
@@ -26,6 +26,15 @@ Use this format for new entries:
 
 ## Entries
 
+## 2026-07-23 - Add deterministic dirty-form browser Back interception
+
+- Area: Admin AJOK manual-result navigation guard.
+- Issue: Dirty result forms guard explicit internal navigation and full-page unloads, but browser Back intentionally remains unguarded because asynchronous `popstate` recovery can race App Router navigation.
+- Impact: Browser Back can discard an unsaved manual result without application confirmation.
+- Suggested fix: Design a deliberate history-state guard that preserves Next.js history state, handles repeated traversal, and removes its sentinel cleanly before every confirmed navigation.
+- Trigger to revisit: When browser Back confirmation becomes a required result-entry acceptance criterion and can be covered in a real browser.
+- Ticket: BEJ-103 follow-up.
+
 ## 2026-07-20 - Audit date and time field semantics
 
 - Area: Prisma schema, PostgreSQL storage, imports, and API contracts.
diff --git a/packages/contracts/admin/trials/manage/create-admin-trial-entry.ts b/packages/contracts/admin/trials/manage/create-admin-trial-entry.ts
index a527e907..de7d9e46 100644
--- a/packages/contracts/admin/trials/manage/create-admin-trial-entry.ts
+++ b/packages/contracts/admin/trials/manage/create-admin-trial-entry.ts
@@ -9,3 +9,27 @@ export type CreateAdminTrialEntryResponse = {
   trialEventId: string;
   trialEntryId: string;
 };
+
+export type AdminTrialEntryValidationIssue = {
+  area: "entry" | "eras" | "additional_info";
+  reason:
+    | "invalid_write_shape"
+    | "invalid_koetyyppi"
+    | "invalid_huomautus"
+    | "invalid_entry_integer"
+    | "invalid_entry_number"
+    | "missing_eras"
+    | "invalid_era_number"
+    | "duplicate_eras"
+    | "non_continuous_eras"
+    | "invalid_era_integer"
+    | "invalid_era_number_field"
+    | "invalid_lisatieto_code"
+    | "duplicate_lisatieto_key"
+    | "invalid_lisatieto_era"
+    | "duplicate_lisatieto_era_value"
+    | "invalid_lisatieto_order";
+  value?: string;
+  koodi?: string;
+  osa?: string;
+};
diff --git a/packages/contracts/admin/trials/manage/index.ts b/packages/contracts/admin/trials/manage/index.ts
index 75b239c3..be292274 100644
--- a/packages/contracts/admin/trials/manage/index.ts
+++ b/packages/contracts/admin/trials/manage/index.ts
@@ -25,6 +25,7 @@ export type {
 export type {
   CreateAdminTrialEntryRequest,
   CreateAdminTrialEntryResponse,
+  AdminTrialEntryValidationIssue,
 } from "./create-admin-trial-entry";
 export type {
   DeleteAdminTrialEventRequest,
diff --git a/packages/contracts/index.ts b/packages/contracts/index.ts
index 01876e47..337c668f 100644
--- a/packages/contracts/index.ts
+++ b/packages/contracts/index.ts
@@ -300,6 +300,7 @@ export type {
   CreateAdminTrialEventResponse,
   CreateAdminTrialEntryRequest,
   CreateAdminTrialEntryResponse,
+  AdminTrialEntryValidationIssue,
   DeleteAdminTrialEventRequest,
   DeleteAdminTrialEventResponse,
   DeleteAdminTrialEntryRequest,
diff --git a/packages/server/admin/trials/manage/__tests__/create-trial-entry.test.ts b/packages/server/admin/trials/manage/__tests__/create-trial-entry.test.ts
index b5b8d861..d35ed830 100644
--- a/packages/server/admin/trials/manage/__tests__/create-trial-entry.test.ts
+++ b/packages/server/admin/trials/manage/__tests__/create-trial-entry.test.ts
@@ -185,4 +185,35 @@ describe("createAdminTrialEntry", () => {
     });
     expect(writeMock).not.toHaveBeenCalled();
   });
+
+  it("returns safe row context for invalid lisatieto ordering", async () => {
+    await expect(
+      createAdminTrialEntry(
+        {
+          ...input,
+          lisatiedotRows: [
+            {
+              koodi: "25",
+              osa: "b",
+              nimi: null,
+              jarjestys: 25.1,
+              eraValues: [{ era: 1, arvo: "1" }],
+            },
+          ],
+        },
+        admin,
+      ),
+    ).resolves.toMatchObject({
+      status: 400,
+      body: {
+        code: "INVALID_TRIAL_ADDITIONAL_INFO",
+        details: {
+          area: "additional_info",
+          reason: "invalid_lisatieto_order",
+          koodi: "25",
+          osa: "b",
+        },
+      },
+    });
+  });
 });
diff --git a/packages/server/admin/trials/manage/create-trial-entry.ts b/packages/server/admin/trials/manage/create-trial-entry.ts
index 242c5ce8..a8aca584 100644
--- a/packages/server/admin/trials/manage/create-trial-entry.ts
+++ b/packages/server/admin/trials/manage/create-trial-entry.ts
@@ -88,6 +88,7 @@ export async function createAdminTrialEntry(
         ok: false,
         error: "Trial result fields are invalid.",
         code: ISSUE_CODES[parsed.issue.area],
+        details: parsed.issue,
       },
     };
   }
diff --git a/packages/server/admin/trials/manage/internal/__tests__/parse-admin-trial-entry-write-input.test.ts b/packages/server/admin/trials/manage/internal/__tests__/parse-admin-trial-entry-write-input.test.ts
index 47c1760e..e172d611 100644
--- a/packages/server/admin/trials/manage/internal/__tests__/parse-admin-trial-entry-write-input.test.ts
+++ b/packages/server/admin/trials/manage/internal/__tests__/parse-admin-trial-entry-write-input.test.ts
@@ -180,6 +180,8 @@ describe("parseAdminTrialEntryWriteInput", () => {
       issue: {
         area: "additional_info",
         reason: "duplicate_lisatieto_era_value",
+        koodi: "11",
+        osa: "",
       },
     });
   });
@@ -193,6 +195,8 @@ describe("parseAdminTrialEntryWriteInput", () => {
       issue: {
         area: "additional_info",
         reason: "invalid_lisatieto_order",
+        koodi: "11",
+        osa: "",
       },
     });
     expect(
diff --git a/packages/server/admin/trials/manage/internal/parse-admin-trial-entry-write-input.ts b/packages/server/admin/trials/manage/internal/parse-admin-trial-entry-write-input.ts
index ffedf754..4bdea3bb 100644
--- a/packages/server/admin/trials/manage/internal/parse-admin-trial-entry-write-input.ts
+++ b/packages/server/admin/trials/manage/internal/parse-admin-trial-entry-write-input.ts
@@ -1,4 +1,7 @@
-import type { AdminTrialEntryWriteData } from "@beagle/contracts";
+import type {
+  AdminTrialEntryValidationIssue,
+  AdminTrialEntryWriteData,
+} from "@beagle/contracts";
 import type { AdminTrialEntryWriteDataDb } from "@beagle/db";
 
 export type AdminTrialEntryWriteValidationReason =
@@ -19,11 +22,8 @@ export type AdminTrialEntryWriteValidationReason =
   | "duplicate_lisatieto_era_value"
   | "invalid_lisatieto_order";
 
-export type AdminTrialEntryWriteValidationIssue = {
-  area: "entry" | "eras" | "additional_info";
-  reason: AdminTrialEntryWriteValidationReason;
-  value?: string;
-};
+export type AdminTrialEntryWriteValidationIssue =
+  AdminTrialEntryValidationIssue;
 
 const VALID_KOETYYPIT = new Set(["NORMAL", "KOKOKAUDENKOE", "PITKAKOE"]);
 const VALID_HUOMAUTUKSET = new Set(["LUOPUI", "SULJETTU", "KESKEYTETTY"]);
@@ -101,8 +101,12 @@ function failure(
   area: AdminTrialEntryWriteValidationIssue["area"],
   reason: AdminTrialEntryWriteValidationReason,
   value?: string,
+  context?: Pick<AdminTrialEntryValidationIssue, "koodi" | "osa">,
 ): { ok: false; issue: AdminTrialEntryWriteValidationIssue } {
-  return { ok: false, issue: { area, reason, ...(value ? { value } : {}) } };
+  return {
+    ok: false,
+    issue: { area, reason, ...(value ? { value } : {}), ...context },
+  };
 }
 
 // Validates and normalizes the result shape shared by create and update writes.
@@ -193,14 +197,25 @@ export function parseAdminTrialEntryWriteInput(
     }
     lisatietoKeys.add(key);
     if (options.mode === "create" && !isNullableInteger(row.jarjestys)) {
-      return failure("additional_info", "invalid_lisatieto_order");
+      return failure("additional_info", "invalid_lisatieto_order", undefined, {
+        koodi,
+        osa,
+      });
     }
     if (row.eraValues.some((value) => !eraNumbers.includes(value.era))) {
-      return failure("additional_info", "invalid_lisatieto_era");
+      return failure("additional_info", "invalid_lisatieto_era", undefined, {
+        koodi,
+        osa,
+      });
     }
     const lisatietoEraNumbers = row.eraValues.map((value) => value.era);
     if (new Set(lisatietoEraNumbers).size !== lisatietoEraNumbers.length) {
-      return failure("additional_info", "duplicate_lisatieto_era_value");
+      return failure(
+        "additional_info",
+        "duplicate_lisatieto_era_value",
+        undefined,
+        { koodi, osa },
+      );
     }
   }