Skip to content

Dashboard ​

"Vercel, but for Substrat." The tenant-facing self-service surface — where a customer's admin runs their own org. Sign up, get a tenant; provision apps (vertical instances) into it; manage members, domains, connections, and the plan. Seeing only their own tenant, gated by customer sign-up, not staff SSO.

It is the counterpart to the Console: the Console is the operator's back office (all tenants, run the platform); the Dashboard is the customer's home (one tenant, run my org). Same platform, opposite audience and blast radius.

The bet: the Dashboard is itself a Substrat vertical ​

The load-bearing decision is that the Dashboard is built as a Substrat vertical — the platform, dogfooded on itself — which is what makes the hard part (authorization) fall out of the kernel instead of being re-invented. The Vercel analogy maps almost one-to-one:

VercelSubstrat
Team / accountTenant
ProjectVertical instance — "Acme HR" is a Meridian instance
Deployment / versiona registered vertical version bound to a scope
EnvironmentScope — a tenant holds several
Team membersprincipals + role assignments
Domainshostname bindings
Integrationsconnections (Scrive, Fortnox)
"New Project from a template"create instance (catalog → provision)
Preview deploymentpreview — a version bound to a scope with data, at its own URL
Preview / staging environmenta pinned preview + custom domain — there is no staging channel, only prod

Concretely: a customer is a tenant; sign-up bootstraps that tenant, one dashboard scope (the customer's home), and the signer as its owner. A customer's apps are scopes in that same tenant. The dashboard scope's own operations are the account actions — every self-service affordance in the UI is a real vertical operation whose first line is a permission check. They fall into a handful of groups:

  • App lifecycle — provision-app, mark-app-active, mark-app-failed, list-apps, app-events, update-app, delete-app.
  • Data & previews — snapshot-app, delete-app-snapshot, export-app-data, restore-app-data.
  • Hostnames — bind-app-hostname, unbind-app-hostname.
  • Environment — set-app-env, list-app-env, delete-app-env.
  • Identity — set-app-auth, get-app-auth.
  • Members & invites — init-team, invite-member, accept-invite, preview-invite, resend-invite, revoke-invite, list-members, remove-member, leave-self, delete-team.
  • Connections — begin-connection.

Provisioning an app is assertAllowed(ctx.check('dashboard:provision-app')) then a tenant-narrowed provisionScope into the caller's own tenant. The permission half is the kernel's: a caller without the key is refused before anything is created. The tenant half is the credential's: the Dashboard presents a tenant token the control plane mints per tenant, and the plane refuses a request that names another — so the narrowing is the server's, not a promise the Dashboard keeps about itself. The token also names the team member it was minted for, so the audit log records the person who acted beside the Dashboard that carried it, and Audit › Activity shows them by name ("via Dashboard"). The design note §4 has the detail.

Auth ​

Login is AuthHero OIDC through the shared @substrat-run/oidc-rp relying party. Unlike the Console's staff-roster gate, the Dashboard does a JIT tenant bootstrap: a new user's first sign-in provisions their own tenant and dashboard scope, and makes them its owner.

The app detail: four tabs ​

Opening an app lands on its detail page, whose tab bar is the four nouns every service page in the field has — Overview · Deployments · Data · Settings — rather than one tab per feature in merge order. Everything read-only about the running version is a fact about the version, not a noun of the instance, so it lives inside a tab: Previews and Schema are sections of Data, Permissions is a section of Settings, beside the day-to-day configuration surfaces (Environment, Domains, Integrations). The two cross-app views — Observability and Audit — belong to the team, so they are pages in the left menu with an app filter rather than tabs. Old tab URLs keep working: snapshots and previews open Data → Previews, model opens Data → Schema, permissions opens Settings → Permissions, and env / domains / integrations open their Settings sections; apps/:id/audit and apps/:id/observability redirect to the team-level page, already narrowed to that app.

Overview ​

Real fields from the app row: the vertical, the running version (the version the app's scope is actually pinned to — what the router serves, not a hardcoded label), status, created-by, scope id, and a live activity timeline read from the app's own audit trail. A Production card lists one public URL per surface the vertical fronts (K-26), each with a copy button and a Visit. Beside it an API card surfaces the app's OpenAPI document (/openapi.json) and an API docs link into the app's Scalar reference — which rides the app's own session, so you sign in to the app first.

Owner seat ​

Next to them sits the Owner seat card: whether anyone has signed in to claim this instance, read live from the app's own identity directory (the platform relays it through the vertical's /internal/owner-seat route). Provisioning mints the seat empty — the platform knows the principal it minted, not the login the tenant's issuer will emit — and for 15 minutes after provision the first person to sign in at the app's address becomes the owner. That is the install flow, where you open the app seconds later; the card shows the deadline while it is open. Once the window has closed, a plain sign-in claims nothing, and the card says so. While the seat is unclaimed — window open or closed — Get claim link mints a short-lived /?claim=<token> link, shown once with a copy button and stored nowhere on the platform: open it yourself, or send it to the person who should own the instance. Minting again retires the earlier link (the card names the outstanding one's expiry). A claimed seat shows its owner and offers no link — the vertical refuses to mint one for a seat that is no longer pending. An app whose vertical keeps no owner seat says that instead of a state. The rule itself — the window, the claim, why a re-provision never re-opens a claimed seat — is on the vertical-auth reference; the two hooks a vertical wires to answer the card are in Deploying.

Data ​

Everything that is this scope's data, in four sections — Tables · Schema · Previews · Export & import — each keeping its own URL (data/previews …) the way Settings does.

Tables is a read-only browser of the app's own database: the vertical's tables on one side (with the _substrat_* spine grouped apart), a paged view of the selected table on the other, and a collapsible SQL console for the one read-only SELECT the table browser can't express. Read-only is enforced below the seam — raw writes would bypass the event log and forge invariants — and every read is audited. Both read the app's data as stored, personal data included: the vertical's own rows and the payloads of events classed as personal, which the Observability Events explorer withholds from its payload groupings. That is deliberate. They are the owning team's own query tools, and the same personal data sits in the domain tables anyway. Every table read and every console query is recorded in the platform's access log, statement included. The explorer has two known limits: the PII class is per event, so an event classed none that carries personal data is still grouped by payload field, and grouping by actor lists principals, which are pseudonymous ids. Schema is the emitted entity model of the version this app runs — the ER diagram, entity cards and declared lifecycles, rendered by the same @substrat-run/model-view core substrat model view uses — with a field coverage card above it naming the declared fields no operation can return. It sits next to the tables because the reader who opens a table to see its rows is the one who asks what its columns mean. Previews is described below. Export & import: Export downloads the app's data as a .dump.json the CLI accepts (personal data redacted unless it's a staff/CLI full-fidelity export); Import replaces the app's data with an uploaded dump, behind a danger dialog and always after the platform forks a safety preview first. Import is for a team owner or admin (dashboard:restore-app-data): a restore replaces the app's data and its permission state, so a member, who otherwise runs the team's apps, sees Export only and is refused with a 403.

Deployments ​

For a customer who builds a vertical (not just instantiates one from the catalog), the Deployments tab is the builder-facing mirror of the staff console's Verticals view — narrowed to the verticals this workspace owns (the ones it pushed with the CLI). Per vertical: each version's admission state, and whether prod — the one channel (dev/staging retired) — points at it. "Running" is the version this app's scope is pinned to (what the router dispatches on), not the vertical's prod channel — they diverge when prod moves after install. A builder self-serves prod promotion right here for an owned, private vertical; a listed vertical's prod promotion is a platform decision (the marketplace gate). A non-production environment is not a second channel to promote — it is a preview below. Every read and promotion is checked to be one of the caller's own verticals — the dashboard's shared-plane credential can't be turned into a lever on another tenant's deployment. Beside promotion, a Bind version action pins this scope to any admitted version of its vertical — the per-scope catch-up (and the primitive behind a canary or a test environment); it carries the same Snapshot data first safety copy as an update.

When prod points somewhere other than where this app is pinned, Update to latest rebinds it. Two safety affordances sit alongside it. A Snapshot data first checkbox (on by default) takes a copy before a migration-crossing update, so a bad upgrade has a rollback point — a code-only update snapshots nothing, because the platform compares migration digests, not the checkbox. And after a migration, a time-boxed Back out offer appears while the pre-migration bookmark is inside the window the platform honors (~24h): rewinding the whole database to just before the migration — discarding everything written since — an honest first-hours backout, not a merge. For anything older, restore a preview instead.

Previews & environments ​

There are two preview surfaces, because a preview does two jobs — a data test copy of one install, and a non-production environment for a vertical you build.

Per-app previews (an install's Data → Previews section) are test copies of that app's data. Create preview forks the app's entire database into an independent copy with a retention choice (1/7/30 days, or keep until deleted); the list shows each copy's provenance, its own URL, and a live expiry countdown; expired copies are reaped by the platform's scheduled sweep. A preview is unmistakably not the live app: it receives no production traffic, integrations are off, and deleting it is safe by construction — the platform refuses to hard-delete anything that isn't a copy. The same machinery backs the Snapshot data first checkbox in Deployments (above) and the safety copy taken before a data import. Authorization is the same key that manages apps (dashboard:provision-app), checked in-scope before any platform effect; the fork itself runs inside the app's own deployment, so no app data crosses to the platform.

Builder environments (on the Deployments side, for a vertical you push) are the same primitive turned outward: a preview is a version bound to a scope with data, at its own URL, and it is how you run every non-production environment now that there is only a prod channel. From here a builder can, for a vertical they own (private or listed — publishing widens who may install, not who may preview their own code):

  • Create a preview of any pushed version — a fork of prod, or an --empty clean room for a vertical with no prod scope yet. The PR-preview CI creates and updates these automatically; the list mirrors what the substrat preview CLI shows.
  • Pin a preview (no expiry) and attach a custom domain to it — turning it into a long-lived test environment at a stable address like crm-test.ahero.se. The domain binds to the scope (Settings → Domains works on a preview scope too), and a merge-to-main job rebinds that scope to the head of main so the environment always runs the latest code.

The full workflow — sticky-per-PR + per-build URLs, the pinned test environment, canary rollout, and the release candidate — is Environments & previews.

Settings ​

Configuration, not daily-driver surfaces — gathered under one tab with its own sections, each keeping its own URL (settings/environment …) so deep links survive:

  • General — rename the app, read its kind, and the danger zone (deleting an app takes it offline and deletes its data, along with every snapshot and test environment copied from it; a backup is taken first where the platform has a backup store, and the audit history is retained). It also carries the Identity card: the substrat:auth choice made at install (which issuer the app trusts), readable and editable after the fact — the client secret is write-only.
  • Environment — the former Env tab. Not a free-form key/value editor, but a form generated from the vertical's declared envSpec: each field carries the manifest's label, description, placeholder, and required/secret flags. The spec is read from the registry (where registerVertical stored it), so a pushed builder vertical gets a config form exactly like a builtin, without the dashboard bundling its code. Values are per app; secret values are write-only — masked, never returned by the API, left blank to keep. Delivery follows the app's shape: a hosted vertical reads its per-tenant config at runtime rather than through per-app worker secrets.
  • Domains — custom-hostname binding (K-26 multi-surface). One scope can front several surfaces, and the hostname decides which surface the vertical serves. A platform hostname is minted from the app's label and is live immediately (it rides the wildcard cert); a custom domain lands pending and walks DNS validation + certificate issuance, going live only when active. The default hostname can't be removed here — deleting the app retires it. Backed by dashboard/bind-app-hostname / unbind-app-hostname.
  • Integrations — third-party connections (Scrive, Fortnox), begun with dashboard/begin-connection and its signed OAuth handshake.
  • Permissions — the declared permission surface of the version this app runs — keys, roles, and entity-grant shapes — read live from the manifest registry, plus the version-to-version diff when an update is available. It only displays: approving a widened role is the permission-diff checkpoint, and it happens when you press Update on Deployments, not here.

Billing: what the team has used ​

Billing in the left menu shows what the team has used over its last 30 closed UTC days (today is not included). It meters usage and does not charge for it: the page says nothing here is charged yet, and carries no prices or payments. It is for a team owner or admin; anyone else sees "Ask a team owner or admin to view usage", as does a caller the platform refuses.

At the top, a summary of four figures: Requests (estimated from sampled router datapoints, with how many of the 30 days are covered), Model tokens (as the providers reported them, with how many calls reported any), Stored (the size of the team's app databases, with how many scopes were sampled) and Build time (successful hosted builds, with their count). A figure marked ≥ is a lower bound: the read was partial, capped or short of a source, and an unavailable source reads "Not available" rather than zero.

Under the summary, a daily usage chart draws one bar per closed day for requests, model tokens or stored bytes, stacked by app; a day with no reading is hatched, never drawn as zero. Under Meter details each meter gives its coverage, whether it is an estimate, how fresh it is, and a breakdown per app (and model) by the app's name, cut at 50 entries when longer. Build time counts hosted builds that produced a release, from leaving the queue to the release being collected; queue time and failed builds are not counted. Record retention is stated beside each meter.

Entitlements are not on this page: the team's own grants are under Settings → Entitlements, which an owner or admin can read. The HTTP read behind Billing is in the control-plane API reference.

Team-level pages: Observability and Audit ​

Two views are about the team's apps rather than one instance, so they are pages in the left menu with an app filter rather than tabs on each app. The app page links into both already narrowed.

  • Observability — every app on the team on one chart, under one time range (1h, 24h or 3d), with an app selector that decides the mode rather than merely filtering rows. Its menu children are Pulse · Processes · Logs · Findings, and each answers in the mode it makes sense in: on All apps Pulse draws one line per installation, followed by a row per app and the worst-first health list; narrowed to one app it is the same chart at tenant grain, and Logs and Processes open for that app. Processes has two views. State machines draws each lifecycle the running version declares, with what moved through it over 24 hours, 7 days or 30 days: moves per transition and who made them, how many instances sit in each state and how long they stay (median and p90), the ones stuck longest, and the share of starts that reached each state, optionally against the previous period. A transition the model declares but nobody took is dashed, and one the model does not declare is drawn apart. Flow is the app's wiring. A request — a row in Logs › Requests, or a log line's request id — opens in a panel over the page: the request and its result, the state change it made (linked to the process map and to that record's history), its log lines and emitted events on a time axis, the consumers that handled what it emitted and how long after the response, and its full log lines. The outbound calls the request made with fetch sit on the same axis and in their own list: host and path, method, status, time to the response, and how the call ended. A call the platform's egress policy refused reads refused by the platform, not as the destination's 403. Headers, bodies and query strings are never recorded, and only path segments that are plain lowercase words, small numbers or versions are kept; every other segment, ids included, is written [redacted]. Not recorded: calls made inside a Durable Object, calls still running after the response, and calls through a fetch the app's code saved while it was loading. Database and model calls are not recorded as timings yet. The panel is part of the address, so a request can be linked to. A record whose entity declares a lifecycle opens with that lifecycle drawn above its event history: where its time went (one segment per state, to scale), and one column per transition naming who moved it and by which operation. Each transition opens the request that made it. A record is addressable too, so a link can open one's timeline over the page. ⌘K (or the top-bar field) opens one overlay for getting anywhere: apps, each app's process maps, every page, and — inside an app — a pasted request or record id, which opens that request or record. Tab switches it to Support, which opens the support conversation. A sub-view never carries its own window, so two panels always answer about the same slice. On the one-app bar chart, clicking a bucket sets a cursor — one instant worth looking at — which rides the URL beside the app and the sub-view and narrows the panels below to the minutes around it; the All-apps line chart carries no cursor, because a cursor is a fact about one scope.
  • Audit — the platform's control-plane admin log for this team: every privileged action against its apps, append-only, newest first; an entry opens to its before/after state where the platform captured one, and the domain event that caused it when one did. Narrowed to one app, it also shows the permission checks that app refused — who was refused which permission on which operation, and a link to the request — with an Outcome filter (All · Allowed · Refused). With All apps, Refused asks you to pick one: refusals are kept in each app's own log. It is a team page because the log is written at the tenant grain and some entries — role changes, entitlements — name no app at all, which a per-app tab could never show.

Process map: duration targets and edge latency ​

The state machine shows observed time in each state, but has no declared per-state duration target or target comparison. A single static wall-clock number would misstate the existing service-level targets: they vary by desk and priority, can count business hours, and pause while a conversation is snoozed. Add an optional state target to the lifecycle contract only when a vertical needs a static wall-clock dwell target and names what to compare against it (for example, completed stays' p90 or each instance still in the state).

An edge shows counts by operation and actor kind, but no p95 operation duration. The outbox has the operation and invocation id, while invocation log lines have duration; there is no durable duration fact joined to the outbox. The log retention is shorter than the map's 30-day window, and asynchronous moves need not have a request line. An operation-wide p95 would also include calls that did not take that edge. Add edge p95 only after there is a bounded, tenant-scoped invocation-duration read whose retention covers the map window, or a durable per-invocation timing fact joinable to the outbox.

Findings: triage repeated problems ​

Observability → Findings is a tenant-wide inbox with Open · Acked · Resolved · Suppressed tabs. Use it when you need to track a recurring problem across requests; use Logs to investigate an individual occurrence.

Findings are recorded when their evidence is written: an ops failure creates a recurring finding, a failed schedule run an invariant finding, and a stale freshness verdict a drift finding. A row carries severity, first and last seen, the observed codes, an evidence reference and the version a regression appeared under. The team sees its own findings, without fleet counts or evidence text from other tenants.

You can acknowledge, resolve or reopen a finding. Suppress rules can narrow the matching scope and expire within at most 90 days; matching anomalies continue to be recorded. A suppressed finding is held by its rule, so revoke the rule instead of trying to change its status. Revocation leaves the existing finding suppressed until its next occurrence opens it again. Mutations are audited. Quiet open findings can be resolved as stale by retention, with an audit record, rather than silently disappearing. Resolved and suppressed findings can later be pruned once they are past the retention horizon.

The list is paged by status. A partial or cut list is labelled as such, so a count over loaded rows is not presented as the team's total. A platform that cannot provide Findings shows an unavailable state, rather than an empty inbox.

AI explanations and process notes ​

A finding can be explained in a few sentences: open AI explanation on its row and choose Explain this finding. The process map has the same thing under its diagram, AI note, which describes where records go and wait in the period shown. Every paragraph a model wrote carries an AI marker and a provenance line, for example Written 15:58 from 212 failure records, 2 versions · 3 sources. The dashboard counts that line from the records it read, not the model, and each source links to the page where you can check it.

Nothing is sent until you choose to write. Opening the block only reads the text already filed for that finding or map, so loading a page costs nothing. When a finding's evidence has moved since its explanation was written (a new occurrence, a changed count), the text is marked as written against older data and offers Rewrite; acknowledging or resolving the finding does not count as new evidence. A process note covers a window that moves with the clock, so it is offered for a rewrite after a while instead: an hour for the 24-hour map, six hours for 7 days, a day for 30 days.

What reaches the model is a fixed list of fields: the finding's kind, severity, codes, counts, timestamps, versions and likely cause; for a failure, who refused it and up to three error messages; for a process map, its counts and declared state names. Error messages pass a redaction step first, which removes what looks like a key, a token, a password, a URL's credentials, an email address or a phone number. Tenant, scope and person ids are never sent, and neither are the ids of the records in a state. The block names the provider beside the button. The platform pays for these calls, so each person can write 20 a day and each team 100, counted in UTC days. A unit is taken before the model is called, so a call that fails still counts. Texts are kept for 90 days.

Whether a deployment offers this is the AI_EXPLANATIONS setting. It is on in the hosted platform. Where it is off (a self-hosted deployment that sets nothing), the toggles are not shown. The privacy policy describes what is sent (AI features in the dashboard).

Ask ​

Where AI explanations are offered, the ⌘K overlay has a third mode, Ask, next to Jump and Support (Tab moves between them). Ask a question about your team, and the assistant answers in a few sentences. It reads the dashboard as you: every read the dashboard makes is a tool it can call (your team's apps and their activity, members and invites, the audit log, domains, observability metrics, traffic, logs and requests, deployments and their releases, failures and previews, findings and suppress rules, and each app's process map), and each one checks your role exactly as the page does. A part of the dashboard your role cannot read is refused to it as well. It only reads; it changes nothing.

Application owners can also publish an application description for Ask. Set substrat.concept in the application's package.json to a relative Markdown file, for example "concept": "spec/concept.md", and push a new version. Publication is opt-in: having a concept file alone does not expose it. The entire selected file becomes readable to dashboard members who can read the app (including installing teams for a listed application), so choose a user-facing document if the design contains internal decisions. The file must stay inside the application directory and fit within 64 KiB in UTF-8.

Ask reads the description belonging to the app's running version, lists its sections, and reads the relevant section in bounded pages. It names the section in its answer. A missing description is reported as unavailable; it is never filled in from the latest source tree. Description reads redact secrets and contact details before splitting the text into pages. The description explains intended behavior: current permissions, configuration, and data still come from the dashboard's other reads. Documentation is read-only and cannot instruct the assistant to take actions. This uses the existing AI availability and answer budget; it does not enable AI for a deployment where Ask is off.

Each answer carries the AI marker, the reads it made (Read apps (3) · Read app requests (20+)) and when it was written. A follow-up question is asked with the conversation so far. The conversation lasts as long as the overlay is open: nothing records it yet. Each question uses one of the same daily AI answers as explanations do, however many reads it takes. Free text from your apps (log lines, error messages) is redacted before the model sees it; the team's own roster, including members' addresses, is not.

Status ​

Built and connected — self-service sign-up bootstraps a tenant, the catalog offers real entries, and provisioning runs through the tenant-narrowed control-plane seam (an app becomes a live scope; deleting one deprovisions it for real). Most of the designed surface is now shipped: the app lifecycle, builder Deployments, a read-only Data browser with export/import, Previews, per-app Environment, custom Domains, team members (invite / accept / remove / leave, with a Team view), and third-party connections (an Integrations view). Usage is visible in Billing, and charging is not built: no price, invoice or payment appears there. The plan remains on the roadmap the design note lays out. It is served as a React SPA bundled into its worker; the account menu lives in the sidebar footer.