3 modules · 45 topics
Production engineering
Understand how interfaces, services, and infrastructure behave in production.
Frontend Engineering
From HTML, CSS, and JavaScript to application state, rendering architecture, accessibility, security, and production diagnosis.
- 01
The browser: from a URL to an interactive page
Follow navigation, resource discovery, rendering, and main-thread work to locate the dependency delaying a useful page.
- 02
HTML, forms, and document contracts
Use semantic structure, native forms, validation, and progressive enhancement as reliable contracts between users, browsers, and servers.
- 03
CSS: cascade, layout, and resilient presentation
Understand cascade ownership, intrinsic sizing, responsive layouts, stacking contexts, and the real costs of animation.
- 04
JavaScript: execution, asynchronous work, and memory
Reason about tasks, microtasks, object identity, workers, cancellation, reachability, and memory diagnosis.
- 05
TypeScript, modules, and the build graph
Model valid states, validate runtime boundaries, understand module graphs, and ship reproducible compatible assets.
- 06
Components, state ownership, and React scheduling
Place facts under clear owners, model transitions, preserve component identity, and distinguish rendering priority from parallel computation.
- 07
Requests, caches, and consistency in the interface
Handle stale responses, scoped caches, optimistic updates, concurrency conflicts, ambiguous writes, and changing paginated data.
- 08
Navigation, SPAs, and application boundaries
Explain why client navigation arose and preserve URLs, history, focus, route errors, and ownership as applications grow.
- 09
CSR, SSR, SSG, and incremental regeneration
Choose rendering time and location around freshness, personalization, hydration, cache scope, and deployment capabilities.
- 10
Streaming, Server Components, and useful boundaries
Design streaming and server/client boundaries around independent work, error isolation, serialization, and browser code budgets.
- 11
Accessibility and design systems as engineering contracts
Build reusable semantics, keyboard behavior, overlays, announcements, localization, and compatibility into shared components.
- 12
Browser security and trust boundaries
Separate origins, CORS, XSS, CSP, sessions, CSRF, private caching, and third-party authority into explicit security decisions.
- 13
Performance, auditing, and production diagnosis
Connect user experience to load and interaction traces, work through a concrete regression, and verify production outcomes by cohort.
- 14
Realtime, browser storage, and offline behavior
Choose transports, replay with versions, bound local storage, and define safe offline writes and service-worker upgrades.
- 15
Testing, release safety, and architectural evolution
Test meaningful invariants, control asynchronous failures, preserve old clients, and evolve frontend architecture through observable seams.
Backend Engineering
From request execution and trusted contracts to data correctness, distributed processing, and production recovery. Follow the mechanisms, failure schedules, and implementation tradeoffs behind reliable backends.
- 01
Requests, protocols, and the server boundary
Trace HTTP and gRPC from the connection to the handler, including proxy trust, deadlines, and protocol guarantees.
- 02
Concurrency, scheduling, and backpressure
Connect event loops, workers, cancellation, queues, and global pool budgets to useful work under overload.
- 03
API contracts, representation, and pagination
Design commands, errors, compatible representations, and stable list traversal with explicit consistency semantics.
- 04
Identity, authorization, and tenant isolation
Carry verified identity and resource permissions through queries, caches, jobs, and shared infrastructure.
- 05
Domain rules, data models, and ownership
Model invariants, historical facts, constraints, state transitions, and the owner of each durable decision.
- 06
Storage engines, indexes, and query plans
Read storage and query costs through WAL, MVCC maintenance, access paths, plans, and representative cardinalities.
- 07
Transactions, MVCC, and concurrency control
Work through last-unit races, snapshot isolation, write skew, locks, version checks, and ambiguous commits.
- 08
Caches, freshness, and invalidation
Make cache identity, stale-fill races, stampedes, eviction, and cache-outage capacity part of one contract.
- 09
Deadlines, retries, and idempotent operations
Bound failure amplification and resolve uncertain mutations using budgets, receipts, stable operation IDs, and reconciliation.
- 10
Queues, streams, and transactional messaging
Understand durable acceptance, outbox and inbox transactions, ordering, redelivery, replay, and backlog drain.
- 11
Replication, partitioning, and identifiers
Reason about replica lag, failover, shard ownership, routing epochs, global operations, and identifier guarantees.
- 12
Coordination, leases, and durable workflows
See why expired owners need fencing and how persistent workflow state handles cross-system uncertainty and compensation.
- 13
Search indexes and derived data
Build a search read model with permission-aware retrieval, versioned updates, deletion rules, rebuild boundaries, and reconciliation.
- 14
Realtime delivery, batch jobs, and resumable work
Choose polling, SSE, or WebSockets and make reconnects, snapshot gaps, slow consumers, and export checkpoints explicit.
- 15
Service boundaries and safe evolution
Use ownership to choose modules or services, then evolve schema, events, caches, and deployments without breaking overlap.
- 16
Testing, observability, and capacity reasoning
Connect invariants to race tests, useful telemetry, critical-path diagnosis, realistic load, and operating budgets.
- 17
Worked production reviews
Review a recoverable checkout and an isolated large-tenant export using concrete budgets, crash schedules, and recovery evidence.
DevOps
From supervised processes and traffic routing to repeatable artifacts, infrastructure, Kubernetes, and reliable production operations.
- 01
Processes and the first deployment
Process identity, supervision, shutdown, resource budgets, and the limits of a single host.
- 02
DNS, TLS, and the traffic path
Follow DNS, TCP, TLS, proxies, load balancers, and private routes to isolate a failing request.
- 03
Git, CI, and artifact promotion
Change graphs, CI trust boundaries, build provenance, and promotion of one verified artifact.
- 04
Containers and image builds
Understand image layers, isolation, resource limits, build inputs, secrets, and process lifecycle.
- 05
Cloud identity, networks, and managed services
Choose compute and storage models, scope cloud identities, and design network and failure boundaries.
- 06
Terraform, state, and infrastructure changes
Configuration, state bindings, plans, locks, drift, imports, refactors, and partial apply recovery.
- 07
Kubernetes reconciliation and workloads
Trace reconciliation, scheduling, workloads, resource budgets, storage, and workload identities.
- 08
Services, probes, and graceful traffic changes
Connect Service routing, readiness, liveness, endpoint propagation, and graceful replacement.
- 09
Helm, GitOps, and safe releases
Chart contracts, reconciliation ownership, progressive delivery, and compatible schema evolution.
- 10
Capacity, autoscaling, and overload
Model throughput and headroom, understand HPA feedback, and protect constrained dependencies.
- 11
Platform security and the software supply chain
Trace build trust, provenance, runtime privileges, workload credentials, and compromise recovery.
- 12
Observability, SLOs, and incident response
Define useful SLIs, reason about telemetry, diagnose boundaries, and coordinate recovery.
- 13
Backups, disaster recovery, and stateful operations
Plan RPO/RTO, application-consistent restores, failover authority, and recovery verification.