Engineering brush-up tracker

You learned these for exams — this is where they actually bite

• Big-O where it actually bites — Not proving bounds — spotting the accidental O(n²) before it reaches real data. Read (7 min)
• Concurrency, for real — Race conditions, deadlocks, optimistic locking, and how an event loop differs from threads. Read (9 min)
• Memory in a managed runtime — How GC behaves in Node/JVM/Python, and what a genuine leak looks like. Read (8 min)
• Networking past the OSI chart — TLS handshakes, connection pooling, keep-alive, and why p99 is a different story from p50. Read (8 min)

You know SQL — these are the parts that separate junior from senior

• Indexing strategy — When an index helps, when it taxes every write, and why composite column order matters. Read (9 min)
• Transactions and isolation levels — Read committed vs repeatable read vs serializable — which anomalies each still allows. Read (9 min)
• Query plans and N+1 — Read EXPLAIN well enough to catch the pattern in review, not in an incident. Read (9 min)
• SQL vs NoSQL, the honest version — Not "NoSQL is faster" — the real trade-offs for a specific access pattern. Read (8 min)
• Caching and invalidation — Cache-aside vs write-through, TTL choices, and deciding how stale is acceptable. Read (9 min)

The gap between "I built a CRUD app" and "I can design a system"

• The two warm-up designs — A URL shortener and a rate limiter, on paper, before reading anyone else’s answer. Read (11 min)
• CAP, applied — Which side you would pick for a specific product, and what you tell users when it degrades. Read (8 min)
• Load balancing and horizontal scale — Sharding, replication, stateless services, and how one scaling decision forces the next. Read (10 min)
• Queues and async processing — When decoupling is worth it, at-least-once vs exactly-once, and idempotent consumers. Read (10 min)
• Reading real engineering writeups — Real constraints and real regrets, not toy diagrams. Read (6 min)

Solidify the layer you touch every day

• REST vs RPC vs GraphQL — When each genuinely fits, beyond syntax preference. Read (8 min)
• OAuth 2.1, JWT and PKCE — Explain the full authorization-code flow out loud, without notes. Read (11 min)
• Versioning and backward compatibility — Change an API without breaking clients you cannot deploy or contact. Read (8 min)
• Rate limiting and idempotency — Token buckets, idempotency keys, and retries that are safe to repeat. Read (9 min)
• Timeouts, retries and circuit breakers — Exponential backoff with jitter, circuit breakers, and errors a client can act on. Read (9 min)

What is standard now, not what was standard when you started college

• Containers, properly — Namespaces, cgroups and layers — what Docker actually does, not just the CLI. Read (9 min)
• CI/CD as the default — Automated tests and deploys as baseline, with a rollback you have actually tested. Read (8 min)
• Observability — Logs, metrics and traces — debugging production without adding print statements. Read (10 min)
• Serverless vs containers vs VMs — Cold starts, cost curves and operational load — when each is genuinely right. Read (8 min)
• Infrastructure as code — Clicking through a cloud console does not survive a second environment. Read (8 min)

Usually skipped in college, assumed in every real job

• The OWASP Top 10, by shape — Injection, XSS, CSRF, broken access control — know the shape of each, not the name. Read (12 min)
• Encryption basics — Symmetric vs asymmetric, hashing vs encryption, and how a TLS certificate earns trust. Read (9 min)
• Secrets management — Why a .env in git is a breach waiting to happen, and what a vault plus rotation solves. Read (8 min)
• Least privilege — Design so one leaked token cannot do everything. Scope it, expire it, audit it. Read (8 min)

The habit that stops the brush-up from going stale again

• One engineering blog post a week — Production lessons, not tutorials. Read (5 min)
• Follow what ships in your stack — Know what changed in your language and framework, and why they changed it. Read (5 min)
• Read one open-source codebase — Study the structure and the taste, not just the API. Read (7 min)
• Explain something out loud monthly — Gaps surface within about two minutes of talking. Read (5 min)

This sticks when you build, not when you read

• Rebuild one old project properly — Same idea, production standards — tests, real auth, a real database, deployed. Read (7 min)
• Ship an API with auth and a real database — The whole loop end to end, running somewhere other than your laptop. Read (9 min)
• Add a queue to something — Producer, consumer, retries, dead-letter queue — then kill the consumer mid-job. Read (8 min)
• Dockerize and automate an existing project — Compose file, tests in CI, deploy on merge. Read (8 min)
• Load-test it and fix the bottleneck — Find the first thing that breaks under load, fix it, measure again. Read (9 min)