Build a Production Frontend

The client can present identity and cannot enforce it. Where the credential lives is a trade between two attacks, not a preference: a script-readable token is reachable by any XSS on the page, and a cookie is attached automatically to requests your code did not initiate. Whichever you choose, the frontend still has to survive expiry mid-action without discarding the work in progress.

A dozen widgets, each with its own data, its own refresh cadence and its own failure mode. Fetched independently they produce a dozen spinners resolving at different moments; fetched together the slowest one holds the whole screen. The real question is which of them are the same server state seen twice.

Every keystroke is a request that may be answered after the one that followed it. Responses arrive in network order, not request order, so the last answer to land can belong to a query the user has already changed — and the result looks like a rendering bug rather than an ordering one.

Tens of thousands of rows, sortable and filterable. Rendering them all makes style, layout and memory scale with rows nobody can see; virtualising them breaks find-in-page, anchor links and the table semantics assistive technology relies on, so the accessibility work has to be redone deliberately rather than inherited.

Uploads are the one interaction that reliably outlives the view that started it. It needs real progress, cancellation, retry of a partial transfer, and a decision about what happens when the user navigates away — and the same file dropped twice must not become two records.

A socket is a second source of truth arriving on its own schedule. It delivers at least once, out of order across reconnects, and goes silent in a way that looks identical to nothing having happened. The UI has to reconcile it against a cache that was populated by a different transport.

Editing must continue when the network does not, which means queued mutations, an ordering guarantee across them, and an answer for the draft that was written against a record someone else has since changed. Offline is not a network state — it is a conflict-resolution requirement.

Every custom control — the combobox, the dialog, the tab set, the sortable header — has a specification for keys, focus and announcement that a component library may implement partially. Automated audits find missing labels and bad contrast; they cannot find that focus was dropped when a panel closed.

Translated strings are longer, shorter, and sometimes right-to-left, which makes fixed-width layouts and concatenated sentences break in ways the source language never shows. Dates, numbers and currencies are the tenant's locale and the user's locale, and those are not always the same one.

A timestamp rendered in the browser's zone and a timestamp rendered on the server in UTC disagree, which is a hydration mismatch and a support ticket at once. "Today" is a different range for two users looking at the same dashboard, and a date-only value has no timezone at all — converting it is the bug.

Tokens stream in, tools report progress, results arrive partial, and the user may cancel mid-answer. Every one of those is a UI state that a request-response component model does not have — and a model proposing an action is never the same thing as that action being authorized.

Each organisation supplies colours and a logo. Applied as inline overrides they defeat the cascade and multiply specificity; applied as custom properties on the root they invalidate the computed style of everything that inherits them on every change. And a tenant colour that fails contrast is an accessibility regression you shipped on their behalf.