One core, two surfaces

The site and the app read the same truth. Change it once, and both move together.

Measured, not claimed

Four figures from a platform built as one.

The build — one core, two surfaces, one gate

The same four pieces that make this real. Read them in order: the truth, the two faces that obey it, and the gate that lets neither ship slow.

// MatchTop · the core — one definition both surfaces obey.
// Written once. The portal and the field app read the same truth — they cannot drift.

type Case = {
  id:       Uuid,
  status:   "open" | "review" | "closed",
  locale:   Locale,        // one language list, honoured by both surfaces
  updated:  Instant,       // stamped at the edge — one clock for web and app
}

service Portal {
  get  case(id)           -> Case
  list cases(for: Holder) -> Case[]
}

<!-- the web surface · server-rendered at the edge, zero JS to read a case -->
<article class="case" lang="{{ case.locale }}">
  <h1>{{ t("case.title", case.id) }}</h1>
  <p class="status status--{{ case.status }}">{{ t("status." + case.status) }}</p>
  <time datetime="{{ case.updated }}">{{ t.date(case.updated) }}</time>
</article>

// same Case. same locale list. no bundle to boot before the page can be read.

// the app surface · the same contract, compiled. A wrong field will not build.
#[derive(Deserialize)]
struct Case {
    id: Uuid,
    status: Status,     // an enum, not a loose string — the compiler holds the line
    locale: Locale,
    updated: Instant,
}

impl Case {
    /// Works offline: the last truth we fetched is still the same shape.
    fn is_open(&self) -> bool {
        matches!(self.status, Status::Open | Status::Review)
    }
}

"""MatchTop · the gate — one standard over both surfaces.
Standard library only. It runs in your pipeline, and it can say no to either face."""

import sys

BUDGET = {"first_paint_ms": 100, "js_kb": 0, "a11y": "AA"}   # promised, so measured


def gate(surface: str, got: dict) -> None:
    fails = [k for k, limit in BUDGET.items()
             if _worse(got[k], limit)]              # every promise is a test
    if fails:
        print(f"HELD · {surface} · " + ", ".join(fails))
        sys.exit(1)                             # neither the site nor the app ships below the line
    print(f"GREEN · {surface} · measured, and worthy of your name on it")

What cannot be copied

Why one house for the whole beats two vendors stitched at a seam.

This is not a discount for buying two things at once. It is a different shape: a single system with two faces, not two systems taped together. A shop that sells the site and sub-contracts the app cannot hand you one core — they do not have one. That is the part that cannot be out-bid.

Held in confidence

Before a line is written, how your work is kept. This part is not negotiable.