Build one inspection workflow at a time. State the request and storage contract first, then prove the accessible browser path and deployed route. Each project includes failure cases to test, so a passing demo cannot hide a broken write or release gate.
Projects
- Practice project: trace a case page across the stack
- Project: build a case intake path from form to stored record
- Project: ship a case page with measured release gates
Related track
Web Development Tutorial; Web Development: Quizzes.
Integrated projects
- Project: paginated inspection feed with safe writes — Build a reviewer feed that survives new rows, duplicate requests, and concurrent updates.
- Project: offline inspection draft and photo intake — Keep a draft through disconnects, then reconcile its version and safely process a photo.
- Project: live review board with ordered status — Show current case state, then apply only authorized and newer events.
- Project: release and recovery drill for a content service — Stage a schema change, direct-route smoke check, backup restore, and rollback decision.
Identity and integration projects
- Project: account access and recovery boundary — Trace login, recovery, session revocation, and record permission as separate decisions.
- Project: webhook contract and browser verification — Keep an external event safe, preserve old API clients, and prove the user journey after release.
Inclusive and global delivery projects
- Project: inclusive case review — Make queue actions, archive confirmation, form errors, and zoom behavior work as one task.
- Project: localized guide release — Publish a translated guide with stable route identity, correct values, and mixed-direction checks.
Platform and trust projects
- Project: typed review console — Build a case route that validates raw API data, survives request races, and loads its optional editor on demand.
- Project: private page trust review — Audit response policy, note rendering, dependencies, and telemetry for a private case page.
Search and quality projects
- Project: private case search — Build a search route that handles index lag, ranking, filters, cursors, and permission revocation.
- Project: release evidence and capacity — Create a small, repeatable release gate for case review correctness and realistic load.
Layout and runtime projects
- Project: adaptive review interface — Build a case workspace that survives intrinsic-size pressure, varied host widths, theme changes, and font fallbacks.
- Project: responsive import worker — Process a case measurement file without blocking input or retaining obsolete browser resources.
API mutation project
Project: conflict-safe case API — Build a case mutation route with conditional writes, bounded retries, durable report operations, and structured errors.
Rendering and forms projects
- Project: server-rendered case queue — Build a first-render snapshot, scoped client cache, and conflict-aware optimistic case action.
- Project: recoverable case intake form — Build a working native form with raced validation, honest autosave, and upload acceptance states.
Navigation and delivery projects
- Project: history-safe review journey — Make a case queue survive direct links, Back, Forward, page restoration, and delayed content.
- Project: edge cache and critical resource release — Ship public guides and private dashboards with correct variants, bounded staleness, and measured image priority.
Streams and interaction projects
- Project: streamed case activity and export — Build a bounded activity reader and large export flow that distinguish partial data from completion.
- Project: accessible operations workspace — Build a readable queue, stable assignment suggestions, non-drag reordering, and restrained async feedback.
Operations and synchronization projects
- Project: case-save incident evidence — Instrument a complete case save, derive a user-facing SLO, and rehearse containment with a queue backlog.
- Project: multi-tab offline case review — Keep edits, snapshots, and collaboration signals coherent across two tabs, disconnection, and replay.
Authorization and lifecycle projects
- Project: tenant-safe case export — Enforce object and tenant scope through listing, cache, queued generation, status, and download.
- Project: verified data expiry — Carry one approved deletion decision through active stores, exports, backups, and browser identity changes.
Capability and viewport projects
- Project: field intake with capability fallbacks — Build optional camera, place, copy, and share actions without making permission a prerequisite for case intake.
- Project: mobile review overlay and scroll — Keep a case-review feed, menu, modal editor, and reorder controls usable with touch, keyboard, and on-screen keyboard.
Accessible content and privacy projects
- Project: accessible inspection report — Publish a report whose images, chart, clip, and route structure remain useful without sight, sound, color, or pointer hover.
- Project: privacy-safe support and measurement — Gate optional vendor paths, minimize event schemas, and enforce preference changes across tabs and jobs.
Notification delivery project
Project: private urgent assignment alerts — Build opt-in push alerts with account-bound subscriptions, safe text, expiry, and an authorized inbox.
Passkey and checkout projects
- Project: passkey account lifecycle — Build registration, sign-in, credential removal, and recovery around server-verified challenges.
- Project: checkout reconciliation — Build a server-priced order, hosted payment attempt, verified event handler, and partial-refund ledger.
File and email projects
- Project: private evidence file lifecycle — Build a bounded resumable upload, inspection worker, protected preview, and expiry workflow.
- Project: account email delivery — Build a durable notice outbox, safe account link, provider feedback loop, and sender rollout check.
Release and GraphQL projects
- Project: assignment panel release experiment — Stage a feature flag, prove the old path after new writes, and audit experiment exposure.
- Project: tenant-safe GraphQL case API — Build a typed case graph with request-local batching, query budgets, idempotent mutations, and stable cursors.
Browser compute and peer projects
- Project: bounded local scan analysis — Deliver a versioned Wasm worker with memory limits, stale-result protection, and explicit fallback.
- Project: private peer consultation — Build an authorized audio room with bounded signaling, relay recovery, and durable server notes.
Motion and regional recovery projects
- Project: case board motion and route continuity — Move cards and open details without making animation own state, focus, or history.
- Project: two-region case service recovery — Design regional read freshness, single-writer failover, private cache scope, and placement evidence.
Graphic and editor projects
- Project: accessible inspection map and export — Build structured region marks with SVG selection, Canvas preview, safe export, and an equivalent text path.
- Project: versioned case note editor — Build a bounded rich note with IME-safe input, stable selection, sanitized paste, undo, and conditional autosave.
Embedded and build projects
- Project: embedded attachment viewer contract — Build a scoped supplier viewer with a safe frame, checked messages, short-lived channel, and full-page fallback.
- Project: frontend artifact promotion and rollback — Release a pinned dashboard build with dependency review, asset integrity, regional manifest checks, and rollback.
Offline and key custody projects
- Project: offline case review across upgrades — Keep unsent inspections readable through worker updates, database upgrades, quota pressure, and account changes.
- Project: encrypted local draft lifecycle — Bind private draft ciphertext to its owner and record, then exercise unlock, rotation, backup, and device loss.
Component and compatibility projects
- Project: interoperable case-decision control — Build a form-capable case decision element that survives late upgrade, host moves, and theme changes.
- Project: progressive case export release — Ship an optional local-save path with a server fallback, selective compatibility code, and a device release gate.
Background work and abuse projects
- Project: permit report job recovery — Admit one report, survive duplicate workers, quarantine old payloads, and expose honest cancel state.
- Project: public permit endpoint abuse controls — Protect recovery, search, and export without disclosing accounts or blocking shared-office reviewers.
Model-backed application project
Project: permission-bound maintenance summary — Build an authorized, budgeted, streamed summary with safe retrieval and a reversible release gate.
Media playback project
Project: private inspection clip playback — Build a reviewable clip player with coherent seeks, bounded buffering, private assets, captions, and fallback.
Browser extension project
Project: permit checklist browser helper — Build a narrow-permission extension that reads one case, survives worker restart, and validates every message.
Geospatial search project
Project: authorized facility map and nearby search — Build a tenant-scoped facility map with correct coordinates, indexed radius search, and a complete text route.
Federated identity project
Project: federated permit reviewer sign-in — Build a two-provider sign-in flow with one-use callbacks, verified identity, controlled renewal, and safe linking.
API migration project
Project: permit API client migration — Move case status and duration contracts across two browser releases and a monthly integration.
Edge and origin project
Project: edge permit case delivery — Put a bounded edge layer before public map assets and private case operations without weakening origin authority.
Realtime board project
Project: live permit case board — Build an authorized case channel with replay, bounded fanout, expiring presence, and deploy-safe reconnect.
Network cutover project
Project: permit domain cutover and transport recovery — Move a permit portal to a new origin while preserving DNS, certificate, protocol, and request safety.
Live data change project
Project: permit data change under live traffic — Release a duration-field backfill and queue index while preserving connection capacity and write correctness.
Application cache project
Project: permit cache recovery and consistency — Keep case reads correct through stale fills, hot-key expiry, eviction, and source failures.
Ingress rollout project
Project: permit ingress cutover and safe retry — Route known hosts through trusted proxies while draining nodes and bounding upload and write retries.
Browser diagnosis project
Project: permit browser regression investigation — Trace a slow approval, growing photo-panel memory, and repeated table layout across a measured release.
React review queue project
Project: React permit review queue state — Keep case drafts attached to the right record while search, approval, and hydration cross distinct boundaries.
Vue review queue project
Project: Vue permit review queue — Build one review queue with derived counts, cancelable details, owned mutations, and stable hydration.
Angular operations queue project
Project: Angular permit operations queue — Build a case queue with signal-derived views, component contracts, stale-request control, and safe hydration.
Svelte review project
Project: Svelte permit review and approval action — Build a queue with derived results, keyed drafts, a server-owned approval action, and private load data.
Next.js delivery project
Project: Next.js permit delivery and cache boundary — Build a private queue with a small client island, explicit freshness, deduplicated approvals, and a streamed panel.
Express service project
Project: Express permit API lifecycle — Build a private case API with ordered trust checks, bounded reads, controlled errors, and a drain protocol.
Django permit service project
Project: Django permit review service — Build a permission-scoped case queue and replay-safe approval with measured ORM and async boundaries.
FastAPI permit service project
Project: FastAPI permit service boundaries — Build a scoped permit API with strict contracts, transactional commands, and recoverable notifications.
Laravel permit workflow project
Project: Laravel permit review workflow — Build a policy-scoped case flow with bounded queries, replay-safe approvals, and a recoverable outbox.
Flask permit service project
Project: Flask permit service boundaries — Build a scoped Flask permit flow with bounded reads, replayable approval, and durable notification intent.
Rails permit workflow project
Project: Rails permit review workflow — Build a scoped Rails permit queue, one replayable approval transaction, and recoverable notification delivery.
CMS publication project
Project: CMS Publication Reconciliation — Build a public projection, private preview, media ledger, and repeatable publication repair path.
Spring Boot permit service project
Project: Spring Boot Permit Service Boundaries — Build a scoped Spring MVC permit API with bounded JPA reads and recoverable approval delivery.
Project: Native Node Permit Gateway
Bound request bytes, response flow, CPU work, and outbound calls beneath server frameworks.
Project: PHP Permit Review Intake
Control PHP input, session identity, database writes, and upload ownership under any framework.