A Public-Facing Portal
Updated
IntermediateWhat you'll learn
~55 min- Sign applicants in with Login.gov (the federal government's public sign-in service) over OpenID Connect, asking for an assurance level with current `acr_values` URNs (the parameter that names the identity-proofing and sign-in strength you require), and refuse the deprecated values in code
- Build the applicant's view of a case as an allowlist, so a column added to the internal record tomorrow cannot reach the public page
- Say which accessibility standard binds your agency (Section 508 for federal agencies, ADA Title II for state and local governments), and keep the audit in lesson 14 as the gate
- Move traffic from the legacy page to the new one with a deterministic canary (a small, fixed share of users on the new version first) that is sticky per applicant and reversible at 0 percent
Every lesson so far served staff. This one serves the people the case is about: a “where is my case” page where an applicant signs in and sees a status, the date it last changed and what happens next. Three things change when the reader is the public. Sign-in comes from a service the agency does not run. The page must show a few fields and no others, even as the case record grows. And the cutover cannot be a weekend: thousands of people with no training and no help desk will find out about your mistakes first.
Before the detail — Artifact: a Login.gov authorization request built on lesson 03’s sign-in with acr_values, an allowlisted applicant view, and a hash-based canary router, each with tests. Acceptance test: the authorization URL carries exactly the acr_values asked for plus the prompt=select_account that Login.gov requires, and refuses the deprecated values; a field planted on the internal record does not appear in the view; the router sends the same applicant to the same side every time, and nobody to the new side at 0 percent. Status: reusable guidance; the tests and fixtures are this module’s, the sign-in values and accessibility dates come from the cited sources.
The portal reads the same case records as everything before it, which means CUI (controlled unclassified information; in a commercial shop, customer PII under contract) is in scope for the running system and for any copy of it. The agent in this lesson works only from the committed fixtures in fixtures/portal/ (invented people, invented notes) and from test output. Give it no database credentials, and do not paste a real applicant’s record into a prompt. The CUI determination from lesson 01 decides what else is allowed.
| Problem | The pattern | Where your platform lesson lands it | You decide |
|---|---|---|---|
| Who is the applicant | OIDC authorization code with PKCE, state and nonce (lesson 03), with acr_values naming the assurance wanted; SAML is the alternative | 34: Entra ID is the workforce provider, so the public provider stays Login.gov · 35: a load balancer can run the OIDC flow for you (check that it can add acr_values before choosing it) · 36: same app code, provider unchanged | The assurance level, and whether a stronger sign-in is required for any action |
| What the page may show | An allowlist built field by field, with public wording written by a person | Unchanged on every platform | Who approves each new public field |
| How the public moves over | A deterministic percentage split on the applicant’s stable id; blue-green is the alternative | The router is in the app; the platform lessons hold what can sit in front of it | The ramp, who may raise it, and the rollback trigger |
| Prove the page is accessible | The axe and keyboard checks from lesson 14 on every public route | Nothing platform-specific: the scan runs in your pipeline (37) | Which standard binds you, and who signs the conformance report |
Plan the change with your agent
Open your AI CLI and make the planning read-only where your tool can enforce it, so the plan is enforced by the tool and not by a sentence. Claude Code and GitHub Copilot CLI: open the tool, then switch to plan mode inside the session (Shift+Tab or /plan), which blocks edits while it plans (in Claude Code, only when the session was not started with approval prompts off); Antigravity CLI: switch the same way, but its plan mode waits for your approval of an outline and its documentation does not say it blocks edits, so run git status before you approve (the tool modes table has each tool’s details); Codex CLI: codex --sandbox read-only, then /plan or Shift+Tab (Codex has no plan flag at launch, so the sandbox flag does the enforcing; leaving /plan does not lift that sandbox, so once you approve the plan, switch to Auto with /permissions before the build) (lesson 02 holds the dated equivalents table). Ask your agent to plan the three portal modules:
We are adding a public "where is my case" status portal next to the legacy lookup. Read src/lib/auth/oidc.ts and fixtures/portal/, and plan login-gov.ts, status-view.ts, and canary.ts under src/modernization/portal/. Ask me anything unclear before writing code.What to check in the plan before you approve
login-gov.tsreusesstartLogin()fromsrc/lib/auth/oidc.tswithout modifyingoidc.ts, addsacr_valuesandprompt=select_account, and refuses deprecatedial/*andloa/*values in code before creating any session state.status-view.tsbuilds{ status, lastUpdated, nextStep }strictly from an allowlist and a human-written public wording table, never by cloning the internal case record and deleting known fields.canary.tsroutes each signed-in applicant to'legacy'or'next'using a deterministic hash of${salt}:${applicantId}over 10,000 buckets, sending everyone to'legacy'at0percent and everyone to'next'at100percent.- Unit tests run entirely offline against the synthetic fixtures in
fixtures/portal/and include planted-fault checks (such as adding unexpected internal fields to a case record).
If the first plan builds the public status view by stripping assignedTo, score, and notes from the internal case object, correct it before approving:
Build ApplicantView with an explicit allowlist of status, lastUpdated, and nextStep mapped from a public wording table, never by deleting fields from the record.- Typed in the terminal:
claude - Mode:Plan mode (Shift+Tab)
- You type in the session: We are adding a public 'where is my case' page next to the legacy status lookup. Plan login-gov.ts, status-view.ts and canary.ts under src/modernization/portal/. Read oidc.ts and the fixtures first. Do not edit.
- The tool replies: Read src/lib/auth/oidc.ts and fixtures/portal/cases.json.
Plan:
1. login-gov.ts calls startLogin() and sets acr_values and prompt=select_account (the Login.gov authorization page marks prompt required) on the URL it returns. PKCE, state and nonce stay in one place. A deprecated value throws before any state is created.
2. status-view.ts builds { status, lastUpdated, nextStep } field by field. Status and next step come from a table of public wording; an internal status with no entry reads as 'In review'. The record has an index signature, so any column can appear tomorrow: the planted-field test covers that.
3. canary.ts hashes
${salt}:${applicantId}into 10,000 buckets. Tests: sticky, monotone as the percentage rises, nobody at 0, everybody at 100. Open question for you: the fixtures link a case to a person byapplicantSub, and dbo.Intake has no such column. Lesson 24 froze that table for the positional export, so the link needs a table of its own. I have not written anything. - You type in the session: Approved. Implement all three and run the portal tests.
- The tool replies: npx vitest run tests/unit/portal.test.ts ✓ Login.gov sign-in: the authorization request > carries acr_values as current values, with PKCE, state and nonce from lesson 03 ✓ ... > carries what the Login.gov page lists as required: prompt=select_account, response_type=code, openid scope, 22+ character state and nonce ✓ ... > the hspd12 value is the one that requires PIV/CAC, and it is passed through to the request ✓ ... > refuses the deprecated ial/* value instead of sending it ✓ applicant view: an allowlist > does not leak a field added to the internal record tomorrow ✓ canary cutover router > is sticky: the same applicant gets the same answer every time ✓ canary cutover router > 0 percent sends everyone to legacy and 100 percent sends everyone to next Test Files 1 passed (1) Tests 16 passed (16)
- You type in the session: Simplify toApplicantView: just strip assignedTo, score and notes from the record and return the rest.
- The tool replies: I tried it so you can see the result. The change fails 4 of 16 tests: × does not leak a field added to the internal record tomorrow expected [ 'applicantSub', 'caseId', 'fraudWatchlistHit', 'queue', 'reviewerEmail', 'status', 'supervisorOverride', 'updatedAt' ] to deeply equal [ 'lastUpdated', 'nextStep', 'status' ] Deleting the three fields I know about passes today and leaks every field someone adds later: reviewerEmail, fraudWatchlistHit and the applicant's own sign-in subject came straight through. I have put the allowlist version back; 16 passed.
Illustrative session; exact output varies by tool and agency configuration.
Sign-in: Login.gov over OpenID Connect
Login.gov offers two protocols, and its own documentation points to one: OpenID Connect (OIDC) for new work. “Login.gov supports version 1.0 of the specification and conforms to the iGov Profile” (Login.gov OIDC); SAML 2.0 is also supported, and the SAML page itself recommends “OpenID Connect (OIDC) over SAML” (Login.gov SAML). If your agency already runs a SAML service provider, keeping it is a legitimate choice; the rest of this module is OIDC, and lesson 03’s flow is the one you extend.
Two details differ from the workforce sign-in. Client authentication: Login.gov prefers private_key_jwt for web apps (the app proves who it is by signing a short assertion with a private key, instead of sending a client secret), and it does not support client_secret_param or the implicit flow (Login.gov OIDC). Lesson 03’s clientFor passes a client secret, so the portal builds its configuration with a signing key instead. And the request names the assurance level it wants.
Asking for assurance
IAL (identity assurance level) is how strongly the person’s identity was proofed; AAL (authenticator assurance level) is how strong the factors used to sign in were. Login.gov now takes both as values in acr_values, the standard OIDC parameter whose value is a space-separated list. The identity-proofing choices are URNs, and the sign-in strength choices are idmanagement.gov addresses. Both lists in the reference implementation src/modernization/portal/login-gov.ts from gov-dev-reference-app below come from the authorization page, and the older ial/1, ial/2 and loa/* values are listed there as deprecated:
// src/modernization/portal/login-gov.ts (excerpt)export const IDENTITY = { authOnly: 'urn:acr.login.gov:auth-only', verified: 'urn:acr.login.gov:verified', verifiedFacialMatchRequired: 'urn:acr.login.gov:verified-facial-match-required', verifiedFacialMatchPreferred: 'urn:acr.login.gov:verified-facial-match-preferred',} as const;// ...export const AUTHENTICATOR = { aal2: 'http://idmanagement.gov/ns/assurance/aal/2', phishingResistant: 'http://idmanagement.gov/ns/assurance/aal/2?phishing_resistant=true', hspd12: 'http://idmanagement.gov/ns/assurance/aal/2?hspd12=true', // requires a PIV/CAC credential} as const;| Value | What the page says it means |
|---|---|
urn:acr.login.gov:auth-only | sign-in only, no identity proofing |
urn:acr.login.gov:verified | identity proofed; meets IAL1 but not IAL2 |
urn:acr.login.gov:verified-facial-match-required | IAL2 |
urn:acr.login.gov:verified-facial-match-preferred | listed; the page’s wording is the authority |
.../aal/2 | a second factor, and not a remembered device (with no AAL value, the default still requires a second factor) |
.../aal/2?phishing_resistant=true | “We currently support security keys, face or touch unlock, and PIV/CAC.” |
.../aal/2?hspd12=true | “This specifies that a user has been authenticated with an HSPD12 credential (requires PIV/CAC).” |
The PIV/CAC mapping is the one that surprises people. PIV/CAC are the smart cards federal employees and contractors carry. Two values touch them, and they do opposite jobs. phishing_resistant=true accepts a PIV/CAC card as one of three kinds of authenticator, next to security keys and face or touch unlock, so it does not make a card mandatory. hspd12=true does: the authorization page says it “requires PIV/CAC” (HSPD-12 is the federal directive behind those cards), so a person without one cannot complete that sign-in. Use hspd12=true only for an action that truly needs a government card, which a public status page for applicants does not; the portal here sends phishing_resistant=true or nothing. Keep the URN acr_values; the page also lists the old ial/* and loa/* values as deprecated. Source: https://developers.login.gov/oidc/authorization/, fetched 2026-11-05, with no date on the page.
The page also marks prompt required, and it “must be select_account”. startPortalLogin therefore sets it beside acr_values, after lesson 03’s startLogin has added PKCE, state and nonce; oidc.ts is not touched. The same page lists response_type=code (the library’s default), scope with openid, a state and a nonce of at least 22 characters (the library’s random values are longer), and client_id. The test checks each of those on the built URL.
The builder takes one identity value and at most one authenticator value, refuses anything else, and delegates the rest to lesson 03:
REFERENCE CODE src/modernization/portal/login-gov.ts (excerpt): acrValues() and startPortalLogin() open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
// src/modernization/portal/login-gov.ts (excerpt)export interface AssuranceRequest { identity: (typeof IDENTITY)[keyof typeof IDENTITY]; authenticator?: (typeof AUTHENTICATOR)[keyof typeof AUTHENTICATOR];}
/** The acr_values string: values separated by a space. Anything not in the two tables above is refused. */export function acrValues(request: AssuranceRequest): string { const values = [request.identity, ...(request.authenticator ? [request.authenticator] : [])]; for (const v of values) { if (/\/(ial|loa)\//.test(v)) throw new Error(`acr_values: ${v} is a deprecated value`); if (!KNOWN.has(v)) throw new Error(`acr_values: ${v} is not a value this portal sends`); } return values.join(' ');}
export async function startPortalLogin(config: oidc.Configuration, identity: Identity, redirectUri: string, request: AssuranceRequest) { const acr = acrValues(request); // refuse before any state is created const { url, pending } = await startLogin(config, identity, redirectUri); url.searchParams.set('acr_values', acr); url.searchParams.set('prompt', 'select_account'); // Login.gov: required, and it must be this value return { url, pending };}For a status page, verified with the default second factor is the starting point: the applicant is proofed, the case is theirs, and the strong tier stays available to the actions that earn it. Whether passing one identity value and one authenticator value together is accepted is for the authorization page to confirm; the test below only proves what the portal sends. The reference configuration for the signing key in gov-dev-reference-app is one line:
// src/modernization/portal/login-gov.ts (excerpt)/** Login.gov wants a signed assertion from the web app, not a client secret in the request (private_key_jwt). */export function loginGovConfiguration(server: oidc.ServerMetadata, clientId: string, privateKey: CryptoKey) { return new oidc.Configuration(server, clientId, undefined, oidc.PrivateKeyJwt(privateKey));}The key itself is a secret in the platform’s store (lesson 08 and the platform lessons hold where it lives), never a file in the repository.
What the applicant may see
The internal case record is wide: who it is assigned to, the score, free-text notes, whatever the next sprint adds. The public page needs three facts. There are two ways to get from one to the other. Delete what you know is sensitive (a denylist), or build the view from what you know is allowed (an allowlist). The denylist is correct on the day it is written and wrong on the day someone adds a column; the allowlist is wrong only in the direction of showing too little.
REFERENCE CODE src/modernization/portal/status-view.ts (excerpt): allowlisted ApplicantView and public wording lookup open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
// src/modernization/portal/status-view.ts (excerpt)export interface ApplicantView { status: string; lastUpdated: string; nextStep: string }
// Public wording lives here, written by a person. Internal status codes and staff free text never pass through.const PUBLIC: Record<string, { status: string; nextStep: string }> = { RECEIVED: { status: 'Received', nextStep: 'We will review your application. No action is needed from you.' }, IN_REVIEW: { status: 'In review', nextStep: 'A caseworker is reviewing your application. No action is needed from you.' }, NEEDS_DOCUMENTS: { status: 'We need more information', nextStep: 'Upload the documents listed in your notice.' }, DECIDED: { status: 'Decision made', nextStep: 'Your decision notice has been mailed to you.' },};const FALLBACK = PUBLIC.IN_REVIEW; // an internal status with no public wording reads as "in review", never as itself
export function toApplicantView(record: InternalCase): ApplicantView { const words = PUBLIC[record.status] ?? FALLBACK; return { status: words.status, lastUpdated: record.updatedAt.slice(0, 10), nextStep: words.nextStep };}
/** The signed-in applicant sees their own case or nothing; the caller cannot tell "not yours" from "no such case". */export function statusFor(record: InternalCase | undefined, sub: string): ApplicantView | undefined { return record && record.applicantSub === sub ? toApplicantView(record) : undefined;}Three choices in those lines carry the design. The status and the next step are looked up, not copied, because an internal status such as ESCALATED_FRAUD_REVIEW and a caseworker’s free text are both information the applicant should not get from a status page. A case that does not belong to the signed-in applicant returns the same nothing as a case that does not exist, so the page cannot be used to learn which case numbers are real. And lastUpdated is the UTC calendar date; if your office reports dates in local time, decide that once, here.
The link from the sign-in sub (the stable subject identifier the provider puts in the ID token) to a case does not exist in dbo.Intake. Lesson 24 froze that table’s column positions for Intake_Nightly_Export, so the link is its own new table, an addition that no existing dependent reads. Record the decision as a rule:
| ID | Rule | Citation | Side effects |
|---|---|---|---|
| R-70 | the public status page shows only status, last-updated date and next step, built from an allowlist and public wording a person wrote | decisions/D-70-public-status-view.md:4 | none |
| R-71 | an applicant is routed to the legacy or new page by a stable hash of their sign-in subject, so the same person sees the same page until the percentage changes | decisions/D-71-canary-routing.md:4 | none |
Two unknowns go in unknowns.md with owners, because the plan cannot proceed on a guess. U-70: does the legacy lookup also answer people who are not signed in (a case number plus a last name)? If yes, removing it is a service change the program owner decides, not a migration detail. U-71: how does an existing applicant’s case get tied to their Login.gov account the first time they sign in? The answer decides whether linking is a mail-a-code step, a staff action or a self-service match, and each has its own PII exposure.
The look, and the law
USWDS, the U.S. Web Design System, is the federal government’s open-source design system of ready-made page components and styles. Its releases are on GitHub; the version and date seen when this lesson was checked are in the status box below, with what could not be confirmed. A state or local team may use it by choice. A design system gives you consistent markup to start from; it does not give you a conformance claim, and the page you ship is still the thing that gets tested.
Which rule binds you depends on who you are, and lesson 14 holds the full treatment, the axe-core scan and the keyboard tests:
| Who you are | Rule | Edition of WCAG (Web Content Accessibility Guidelines) |
|---|---|---|
| Federal agency | Section 508 | WCAG 2.0 Level AA |
| State or local government | ADA Title II web rule | WCAG 2.1 Level AA, due 2027-04-26 for populations of 50,000 or more |
Building to 2.1 AA is the target that meets both. For a public portal the practical consequence is where the scan runs: on every public route in the pipeline, with the signed-in view tested through a stubbed session so the scan sees what an applicant sees. A passing scan supports evidence for a conformance claim; the claim and the report that carries it belong to the people your agency names.
Commercial readers: a customer portal sits under the same kind of obligation through the ADA and contracts, uses the same OIDC pattern with a consumer identity provider, and ships the same three artifacts. The federal delta is the sign-in provider, the named accessibility standard, and the date. The handoff artifact is the test output and the signed report. What is not equivalent: a social or consumer sign-in does not carry identity-proofing levels, and a hash split is a rollout control, not an authorization to go live.
Moving the public over
Two patterns from Martin Fowler’s site cover this. Blue-green: “The fundamental idea is to have two easily switchable environments to switch between” (BlueGreenDeployment, 2010). Canary: “Canary release is a technique to reduce the risk of introducing a new software version in production” (CanaryRelease, 2014). Blue-green flips everyone at once and flips back the same way. A canary sends a small share first. For a page applicants use once a week, the canary wins on one point: a defect reaches the few before it reaches the many.
Sticky matters as much as small. A random coin flip per request would show an applicant the legacy page, then the new one, then the legacy one, with two different words for the same status. The router hashes the sign-in subject (not the email, which is PII) with a salt that stays fixed for the whole rollout, into 10,000 buckets. The bucket stays sticky only while the salt is not rotated between ramps: change the salt and every applicant is re-bucketed, so people already on the new page can land back on the legacy one. Here is the reference hash bucketing and routing logic in src/modernization/portal/canary.ts from gov-dev-reference-app:
// src/modernization/portal/canary.ts (excerpt)export function bucket(applicantId: string, salt: string): number { return createHash('sha256').update(`${salt}:${applicantId}`).digest().readUInt32BE(0) % BUCKETS;}
/** percentNext: 0 sends everyone to legacy (rollback), 100 sends everyone to next. Fractions work: 0.5 is 50 buckets. */export function route(applicantId: string, percentNext: number, salt: string): Target { if (!(percentNext >= 0 && percentNext <= 100)) throw new Error(`percentNext must be 0..100, got ${percentNext}`); return bucket(applicantId, salt) < percentNext * (BUCKETS / 100) ? 'next' : 'legacy';}Because the bucket does not change, raising 5 percent to 25 only adds people; nobody on the new page is moved back. Rollback is percentNext = 0, one value, with no deploy. Before sign-in there is no subject to hash, so the split runs after the callback, and the page everyone lands on first is the one that redirects. Keep the callback on one hostname so a split behind it changes no registration with the provider.
Run it against 10,000 invented subject ids and the share is close to what you asked for: 467 at 5 percent, 940 at 10 and 2,415 at 25, from node on the committed code. Parity from lesson 23 and the agent bench from lesson 25 decide whether the ramp may start; a mismatch awaiting a ruling holds it at 0.
Prove it
From gov-dev-reference-app, with nothing but Node and the pinned dependencies:
1. The suite. npx vitest run tests/unit/portal.test.ts passes 16 tests: seven on the authorization request, four on the view, five on the router.
2. The authorization URL. The first test builds the URL from a stub issuer (fixtures/portal/stub-issuer.json, no network) and asserts the expected parameter output:
acr_values urn:acr.login.gov:verified http://idmanagement.gov/ns/assurance/aal/2?phishing_resistant=trueprompt select_accountresponse_type codescope openid emailcode_challenge_method S256state, nonce the values startLogin() returned in `pending`Passing http://idmanagement.gov/ns/assurance/ial/2 throws acr_values: ... is a deprecated value, and so does the call to startPortalLogin, before any state exists.
3. The planted field. The leak test adds reviewerEmail, fraudWatchlistHit and supervisorOverride to a record and requires the view’s keys to be exactly lastUpdated, nextStep and status, and none of the planted values, the staff name, the notes or the applicant’s own subject to appear in the serialized view.
4. The planted fault. Replace the body of toApplicantView with a copy that removes assignedTo, score and notes and returns the rest. Expected: Tests 4 failed | 12 passed (16), and the leak test prints expected [ 'applicantSub', 'caseId', …(6) ] to deeply equal [ 'lastUpdated', 'nextStep', 'status' ]; the eight keys are applicantSub, caseId, fraudWatchlistHit, queue, reviewerEmail, status, supervisorOverride, updatedAt. Restore the allowlist and the suite returns to 16 passed.
5. A second fault, for the router. Mix Math.random() into the hashed string. Expected: Tests 2 failed | 14 passed (16), the sticky test and the only-adds-people test. Remove it and the suite returns to 16 passed.
R-70’s test of record is the leak test; R-71’s is the sticky test. Add both to lesson 24’s tested-elsewhere.json.
Availability, authorization, agency approval, region support, and price are five separate facts; none of the first four is established here for any service named in this lesson, and none of this lesson’s sources give a price. Sign-in: the Login.gov OIDC, SAML and authorization pages cited above carry no date, so the values were read on 2026-11-05 and should be read again before you register a client. The authorization page, re-read 2026-11-05, requires prompt (“This must be select_account”), lists the service-level and AAL URNs as separate groups with multiple values space-separated, and says of hspd12=true “(requires PIV/CAC)”; whether Login.gov may be used as a workforce provider is not established by those pages. USWDS: the GitHub releases page showed 3.14.0 as “Latest”, dated “18 Aug”, with no year in the text that was read; the year is unverified, no 4.x line was found, and the digital.gov release-notes address returned 404. Recheck the release on the day you ship. Accessibility: the Section 508 text was read in the eCFR (36 CFR Part 1194, last amendment on record 2018-03-23), and the Title II dates come from the interim final rule in 91 FR 20902; whether a final rule has followed it, and any litigation, were not checked. Which cloud features can split traffic, and whether a load balancer’s OIDC rule can add acr_values, were not checked for this lesson. Recheck the cited sources and your agency’s authorization boundary before you rely on any of it.
A teammate shortens the view function to copy the internal record and delete assignedTo, score and notes. The tests you have today pass. What is the right response?
The canary is at 10 percent. A defect appears, and the team sets the router to 0 percent. What happens to the applicants who were on the new page, and what would a per-request random split have done?
Practice status — a public status page that signs applicants in, shows a few fields and moves over in steps
| Practice | Status | Also called |
|---|---|---|
| OIDC authorization code with PKCE, state and nonce for the public sign-in | common baseline | authorization code flow |
acr_values naming the assurance level, current values only | common baseline | step-up; assurance request |
private_key_jwt client authentication for a web app | common baseline | signed client assertion |
| view model as an allowlist with public wording from a table | strong optional | data minimization; response allowlisting; serializer allowlist |
| deterministic hash split on a stable id, with a fixed salt | common baseline | percentage rollout; sticky bucketing; feature-flag rollout |
| blue-green as the alternative cutover | common baseline | red-black deployment |
| an axe scan and keyboard test on every public route | strong optional | automated accessibility regression test |
Scale: required | common baseline | strong optional | reference-shop (seen only at organizations that publish their own practice) | emerging
Key takeaway
A public portal is three small decisions that each have a test. Ask the sign-in service for the assurance you need with the current values, and refuse the retired ones in code. Build the applicant’s view from an allowlist, so the record can grow without the page growing with it. Move people in with a hash of their stable id, so each applicant sees one page and the way back is a single number. The accessibility audit in lesson 14 gates the pages themselves. Lesson 33 applies the same method to the reports that sit behind the case record.
- LEADERSHIP DECISION
- which assurance level the status page requires, who approves each new public field, and who may raise the canary percentage or order it back to zero
- PRACTITIONER ACTION
- add the sign-in builder, the allowlisted view and the router with their tests, and run the lesson 14 scan on every public route before the ramp starts
- SUCCESS MEASURE
- audit finding avoided: no internal field on the public page, and the percentage returns to 0 with one change
Legend: LEADERSHIP DECISION = what a leader decides · PRACTITIONER ACTION = what the engineer does next · SUCCESS MEASURE = how you know, in calendar time, assessor-hours or cost, contract or revenue risk, or audit finding avoided