Immediate Access Shutdown for Profile Updates and Global Session Revocation (3 Rules)

A healthtech signup flow can pass its captcha and still leave a dangerous gap: an account is banned in the profile database while an already-issued session keeps working. That is an access-control incident waiting for a clock to run out. Short answer: model a ban as an auditable profile-state transition, then revoke every session as a separate, explicit lifecycle action. Keep the short-lived access credential and its refresh capability under different risk controls, and make “this device” and “all devices” distinct operations. The incident lesson: a profile flag is not a kill switch The operational constraint is immediate shutdown. When abuse review marks a user as banned, the system must stop new work and invalidate existing access without relying on a browser logout button. I have been paged for missed jobs and duplicate deliveries; the same lesson applies here: a state change is only useful if every consumer observes it. The invariant is simple: every authentication action is a checkable, auditable, recoverable state transition. Signup protection (including captcha verification) is one transition. Session creation, verification, refresh, and revocation are four more. Treating them as one giant “auth request” makes it impossible to answer an audit question such as “which session was active after the ban?” Write the ban first, with an audit record that ties the user to the operator, reason, and request ID. Then issue the global revoke command. The ordering matters because a revoke without a durable profile state can be undone by an automatic refresh; a profile update without revocation leaves the old bearer credential alive until expiry. That sounds obvious. It is often missed. How should profile state updates trigger global session revocation? Use two explicit calls and one transaction boundary in your own service. PATCH /v1/auth/user/update/{user_id} changes the profile state. POST /v1/auth/session/revoke_all_for_user/{user_id} invalidates sessions on every device. They are separate verbs because they have separate audit semantics and retry behavior. The caller should attach an idempotency key to the write path, persist the decision before making the network call, and record both responses. A retry after a timeout must replay the same decision, not create a second ban event or silently switch from one user to another. On HTTP 429, honor Retry-After and back off; a tight loop during an abuse spike can become its own denial-of-service. In practice, I keep the audit row, the chosen user ID, the policy version, and the idempotency keys in one durable record, then let a worker replay the exact pair of calls until both outcomes are known. That worker also emits a metric for “profile updated, sessions still active,” because a green response from the first call is not evidence that the shutdown is complete; support staff need a bounded, observable handoff between those two states. Here is a compact Go handler. The surrounding application owns authorization, audit storage, and the policy that decides whether a profile is banned. The API calls are deliberately limited to the two operations relevant to shutdown. package main import ( "bytes" "context" "encoding/json" "fmt" "io" "net/http" "os" "strconv" "time" ) func call(ctx context.Context, baseURL, method, path, key, idem string, body []byte) error { for attempt := 0; attempt < 4; attempt++ { req, err := http.NewRequestWithContext(ctx, method, baseURL+path, bytes.NewReader(body)) if err != nil { return err } req.Header.Set("Authorization", "Bearer "+key) req.Header.Set("Content-Type", "application/json") req.Header.Set("Idempotency-Key", idem) resp, err := http.DefaultClient.Do(req) if err != nil { return err } data, readErr := io.ReadAll(resp.Body) resp.Body.Close() if readErr != nil { return readErr } if resp.StatusCode == http.StatusTooManyRequests { wait := time.Duration(1