20 practical guides
Software Engineering Guides
Learn the engineering choices behind dependable applications, from HTTP and access control through concurrency, testing, performance, delivery, and careful refactoring.
Built for developers who want concrete workflows and tradeoffs rather than one architecture presented as the answer to every system.
HTTP requests and responses
Follow an HTTP exchange from URL through method, headers, body, status, caching, and browser handling.
Practical REST API design
Design resource-oriented HTTP APIs with explicit semantics, validation, pagination, compatibility, and operational behavior.
GraphQL versus REST
Compare GraphQL and REST by client needs, schema ownership, caching, performance, security, and operating cost.
Authentication and authorization
Separate identity proof from permission decisions and apply both at every trusted server-side operation.
Session cookies versus JWTs
Compare server sessions and JSON Web Tokens by browser security, revocation, scale, claims, and operational needs.
Database transaction design
Choose transaction boundaries from business invariants, concurrency risks, failure behavior, and external side effects.
Preventing web race conditions
Find read-modify-write races, stale responses, duplicate work, and lost updates across browser, server, and database boundaries.
Idempotent API endpoints
Make repeated requests produce one intended effect through method semantics, operation keys, atomic storage, and replay rules.
Useful API error responses
Create stable error contracts that help clients recover while protecting credentials, private resources, and internal details.
TypeScript narrowing
Refine union and unknown values through runtime evidence, discriminated unions, predicates, and exhaustive handling.
React Server Components
Understand server and client component boundaries, rendering payloads, serialization, interactivity, and data access tradeoffs.
Simple state management
Place state near its owner, derive instead of duplicate, separate server and client data, and add shared stores only for measured needs.
Effective unit tests
Test observable behavior with focused examples, controlled dependencies, clear failures, and deliberate boundary coverage.
Integration versus end-to-end tests
Choose test boundaries by failure risk, realism, speed, diagnosis, and the contracts between application parts.
Debugging web memory leaks
Reproduce retained-memory growth, compare heap evidence, trace retaining paths, and verify cleanup in browsers and servers.
Profiling web performance
Measure loading and interaction, locate browser bottlenecks, make targeted changes, and verify user-visible performance gains.
Safe feature flag design
Use typed flags, controlled targeting, observable rollout steps, tested fallbacks, and planned removal to reduce release risk.
Reviewing pull requests
Review intended behavior, trace consequential paths, challenge assumptions, assess tests, and leave actionable evidence-based feedback.
Safe database migrations
Change production schemas and data through compatible phases, bounded backfills, measured validation, and realistic recovery plans.
Refactoring legacy code
Characterize existing behavior, create narrow boundaries, make reversible changes, and verify refactoring against real system evidence.