Deep, plain-English, laddered engineering reference guides. Most guides are a 10-rung ladder from beginner to mastery: a rubric (rate yourself 1-10), a concepts ladder (the route up), a dictionary (every term), and 10 lessons in a consistent house style (Intuition / What's actually happening / The workflow / Produce the artifact / Pitfalls / Terms used / Going deeper). A handful are hands-on lab tracks (L01-L10 exercises).
150 guides across 13 areas.
- Concurrency & Parallelism — Reasoning About Things Happening at Once
- C# / .NET — ASP.NET Core, EF Core, LINQ
- Data Structures & Algorithms in Practice — The Diagnosis Behind "It's Slow"
- Debugging as a Discipline — Systematic Fault Isolation
- Go — Language and Concurrency
- How the Web Works — End to End
- Java — Language and JVM
- JavaScript — The Language Deeply
- Javascript Fundamentals
- Networking — Fundamentals to Production
- Operating Systems for Developers — Reading What Your Code Asks the Machine
- Python — Language and Ecosystem
- Reading a Large Codebase Cold — Getting Productive in an Unfamiliar Repo Fast
- Regex & Text Processing — The Underrated Force Multiplier
- Software Engineering Fundamentals
- TypeScript — Typing JavaScript at Scale
- Accessibility (a11y) by Design — Building Interfaces Everyone Can Operate, Designed In Not Bolted On
- Browser Performance
- CSS
- D3.js — Data-Driven Documents
- Design Systems — Building and Running the Single Source of Truth for UI
- Frontend Architecture Tradeoffs
- Frontend Build Tooling
- Frontend Fundamentals
- GSAP — Professional Web Animation
- Micro-Frontends — Independently Deployed UIs
- Module Federation — Runtime-Composed Frontends
- Monorepos — One Repo, Many Packages
- Next.js — Production React Framework
- p5.js — Creative Coding
- React — From Components to Architecture
- React Native — Cross-Platform Mobile
- Shadow DOM — Encapsulated Components
- TanStack — Query, Router, Table & the Headless Stack
- Three.js — 3D on the Web
- Vue
- Web Performance — Core Web Vitals & the Frontend Critical Path
- Web Platform Apis
- Web Workers — Off-Main-Thread JavaScript
- Babel — JavaScript Compiler
- Electron — Desktop Apps with Web Tech
- pnpm — Fast, Disk-Efficient Package Manager
- Vercel — Frontend Cloud Platform
- Vite — Frontend Build Tool
- Webpack — Module Bundler
- API Design
- API Design Beyond REST — GraphQL, gRPC & tRPC
- Authorization — RBAC, ABAC & Policy-as-Code
- Backend Architecture Patterns — From Monolith to Event-Driven
- Backend Architecture Tradeoffs
- Backend & Application Performance — Measure First, Optimize the Bottleneck
- Background Jobs & Idempotency — Work That Survives Being Retried
- Caching & Invalidation — Speed Without Lying
- Writing Design Docs & ADRs — Thinking on Paper Before You Build
- Distributed Systems Fundamentals — When the Network Stops Being Invisible
- Domain-Driven Design & Bounded Contexts — Aligning Code to the Business
- Engineering Safely — Blast Radius, Reversibility & Dangerous Operations
- Express — Node Web Framework
- Message Queues & Event-Driven Architecture — Decoupling Systems in Time
- Microservices — Service Boundaries & Inter-Service Communication
- Node.js — Server-Side JavaScript
- REST — Designing HTTP APIs
- Socket.IO — Realtime Engine for Node
- System Design — From Requirements to Architecture
- Web Auth & Identity — OAuth2/OIDC, Sessions & JWT
- WebRTC — Peer-to-Peer Media & Data
- WebSockets — The Realtime Transport
- Data Engineering & Warehousing — Moving and Shaping Data for Analytics
- Data Modeling & Consistency — The Schema Is the Contract That Outlives Everything
- Database Internals — The Layer Beneath Your ORM
- Indexes
- MongoDB — Document Database
- NoSQL Stores
- Pinecone — Vector Database
- PostgreSQL — Advanced Relational
- Database Query Optimization — Making Slow Queries Fast in Practice
- Redis — In-Memory Data Store
- Relational Databases
- SQL Server — Microsoft RDBMS
- AWS - Amazon Web Services at Staff Level
- CI/CD Pipelines — Continuous Integration & Delivery
- Cloud Cost & FinOps
- AWS CloudFront — CDN
- Docker — Containers
- Environments — Local, Staging & Production Done Right
- Git — Version Control Deeply
- Git Workflow & Trunk-Based Development — Integrating Cleanly With a Team
- GitHub Actions — CI/CD
- IIS — Internet Information Services
- Jenkins — Automation Server
- Kubernetes — Container Orchestration
- Release Management — Feature Flags & Safe Deploys
- Secrets & Key Management — Keeping Credentials Out of Code
- Tailscale — Mesh VPN
- Terraform — Infrastructure as Code
- Google Analytics (GA4) — Product Analytics
- Incident Response & Blameless Postmortems — From Page to Postmortem Without Losing Composure
- Lighthouse — Web Quality Auditing
- New Relic — Observability Platform
- OpenTelemetry & the Observability Discipline
- Profiling & Benchmarking — Measure Before You Optimize
- Sentry — Error & Performance Monitoring
- SLOs, Error Budgets & Alerting — What To Do When the Numbers Move
- Software Quality & Metrics — Measuring What "Good" Looks Like Without Gaming It
- SRE — Reliability Engineering as a Discipline
- Code Review — Both Sides: Giving and Receiving Review That Ships Better Software
- Integration, E2E & Contract Testing — Testing Across Boundaries
- Jest — JavaScript Testing Framework
- Playwright — End-to-End Testing
- Quality Assurance — Strategy, Process & Release Quality
- Test-Driven Development — Building the Habit, Then Knowing When to Break It
- Testing in CI & Flaky-Test Reliability — A Green Build You Can Actually Trust
- Testing Library — User-Centric UI Tests
- Testing Strategy & the Test Pyramid — Deciding What to Test, at Which Level, and Why
- Writing Good Tests — Test Design & Doubles
- OWASP Top 10 in Practice — Shipping the Fix
- Privacy & Compliance Law for Engineers
- Security Headers & Transport Hardening — Cheap Fixes, Expensive Ignorance
- Supply-Chain Security — Trusting (and Verifying) Your Dependencies and Build
- Threat Modeling as a Practice — Designing Security In
- Agile & Team Delivery Process — How Teams Actually Ship, Beyond the Framework
- Decision-Making Under Uncertainty — Betting Well Without Complete Information
- Engineering Communication & Collaboration — How Writing, Meetings & Influence Scale a Staff Engineer
- Estimation & Work Breakdown — From Vague Feature to Credible Plan
- Occupational Hazards — How Not to Blow Up Your Own Codebase
- Problem Reasoning & Engineering Judgment — From Reacting to the Ask to Architecting the Question
- Processes — How to Not Blow Everything Up
- Risk Management for Engineers — Seeing the Iceberg Before You Hit It
- Systems Thinking — Seeing the Whole, Not the Parts
- B2B / Enterprise UX Patterns — Designing for the Expert Daily User
- Design for Engineers — Closing the Design-to-Code Gap When You Don't Have a Designer
- Interaction Design & Microinteractions — Making an Interface Feel Alive
- UI & Visual Design — The Craft That Makes a Screen Feel Right
- UX Design Fundamentals — User-Centered Design for Engineers Who Make UX Calls
- 2D Game Development — Sprites, Tiles, and Physics in a Plane
- 3D Game Development — Math, Transforms, and Worlds in Space
- Game AI — Agents, Pathfinding, and Believable Behavior
- Game Architecture — ECS, Scene Graphs, and Game State
- Game Design & Genres — Mechanics, Loops, and Categories
- Game Development Fundamentals — The Loop, Input, and First Playable
- Game Engines — Unity, Unreal, and Godot Compared
- Game Graphics & Rendering — From Triangles to Frames
- Game Performance & Optimization — Hitting Frame Budget
- Game Physics & Collision — Simulating Motion and Contact
- Game Programming Patterns — The Canonical Toolkit
- Multiplayer & Game Networking — Sync, Lag, and Authority
- Phaser.js — 2D Game Development