How to use this checklist
Patterns, not problem roulette
Timed classics + concurrency
Foundations → tech → mocks
Tradeoffs you can say aloud
Mocks over new topics
Analogy: preflight checklist
This checklist is a pilot’s preflight: coding patterns, LLD locks, HLD tradeoffs, behavioral scars, company overlay. Green on all five → you’re cleared for the loop.
Comprehensive backend checklist
Tick these only when you can deliver them under a clock. Links jump to Lattice posts with interview-answer sections where we added them.
- Delivery — framework, numbers, pitfalls
- API & net — API design, networking, realtime
- Data — modeling, indexing, CAP, consistency
- Stores — Postgres, Mongo, Dynamo, Cassandra, Redis
- Async & cache — queues, Kafka, caching
- Scale patterns — scalability, sharding, reads, writes, contention
- Practice designs — URL shortener, Ticketmaster, feed, chat — question breakdowns
Coding patterns checklist
Pattern-first. For each row: know the template, complexity, and one follow-up. Full map: DSA roadmap.
- Two pointers & sliding window — invariants before code
- Binary search — including search-on-answer
- Stacks & heaps — monotonic stack + top-K
- Linked lists — reverse, merge, cycle
- Trees & BST — DFS/BFS + BST range invariants
- Graphs — BFS/DFS, topo, union-find sparks
- Intervals & greedy
- Backtracking + DP
- Prefix, tries & matrices
LLD classics checklist
Framework first — LLD delivery — then timed classics. Overview: LLD interview overview.
- Core — OOP & principles, patterns, guidelines / STAR
- Concurrency — basics → correctness → coordination → scarcity
- Must-do classics — parking lot, rate limiter, elevator
- Booking / inventory — movie booking, BookMyShow, inventory, locker
- Games / files — tic-tac-toe, chess, filesystem, logger, library
HLD building blocks checklist
In a 45-minute design, these are the Legos. Know the 90-second version of each; deep-dive only where the prompt hurts.
- Requirements & math — FR/NFR, QPS, storage — delivery, numbers
- API surface — API design (five minutes max)
- Data model + indexes — modeling, indexing
- Consistency story — CAP, models, contention
- Read path — cache, scale reads, CDN
- Write path — scale writes, sharding, queues
- Async — queues, Kafka, sagas / multi-step
- Live updates — realtime, networking
- Ops close — metrics, one bottleneck, one intentional tradeoff
Tech stack tradeoffs — when to pick what
Say the access pattern first, then the store. Interviewers punish brand-name shopping.
| Reach for | When | Watch out | Lattice |
|---|---|---|---|
| PostgreSQL | Relational data, joins, multi-row ACID, flexible query | Write ceiling on one primary; cross-region multi-primary is hard | Postgres |
| Cassandra | Write-heavy, query-known, multi-DC AP-ish workloads (timelines, IoT) | No ad-hoc JOINs; bad partition keys; tombstones | Cassandra |
| DynamoDB | Known access patterns at huge scale on AWS; key-value + GSI | Hot partitions; not for analytics; model keys first | DynamoDB |
| Redis | Cache, sessions, rate limits, locks, leaderboards, light pub/sub | Memory cost; not default system of record for money | Redis |
| Kafka | Durable event log, replay, many consumer groups, high throughput streams | Ops + partitioning complexity; overkill for simple job queues | Kafka |
Final week — mock schedule
Assume a loop in ~7 days. Swap company guides for your target. Protect sleep.
- Day −7: Coding timed set (2 mediums) + skim this checklist gaps only
- Day −6: One LLD classic timed (parking or rate limiter) + concurrency follow-up verbal
- Day −5: HLD warm-up — URL shortener in 45m; review API + data + scale
- Day −4: Harder HLD — Ticketmaster / feed / chat; force contention + realtime answers
- Day −3: Coding weak-pattern day + one behavioral STAR pack out loud
- Day −2: Full mock day — coding + HLD or LLD matching the company loop; read company guide
- Day −1: Light review only — numbers, tradeoff table, 2 STAR stories; no new topics
- Day 0: Loop. Trust the framework. Deliver working systems.
Next: prep plan for round order · foundations for depth · practice designs for reps.
Coding bar — what “done” looks like
Backend loops still grade DSA hard. You are not done with a pattern until you can do all three: name the invariant, code the template from memory, solve a twist under time.
- Arrays/hash — Two Sum family, anagrams, consecutive sequence
- Windows / pointers — 3Sum, min window, rain water
- Binary search — rotated array + search-on-answer
- Stacks/heaps — monotonic stack + top-K + merge-K
- Lists / trees / graphs — reverse/cycle/LCA/islands/topo/Dijkstra deep dives
- DP / BT / intervals — coin change, edit distance, subsets, merge intervals
LLD bar — design then lock
Clarify → entities → APIs → code the mutation path → narrate a race. Coarse lock first; upgrade path second.
- Must drill: parking, rate limiter, BookMyShow, library, inventory
- Concurrency spine: map → correctness → coordination / scarcity
- Every classic now has
complete-solution+concurrency-cases(Python + Java)
HLD bar — numbers, bottlenecks, tradeoffs
Open with requirements + capacity. Pick storage with a reason. Draw the hot path. Name the failure. Offer the next scale lever.
Behavioral bar — scars with metrics
- Build a 8–12 story bank mapped to conflict, ambiguity, ownership, failure, mentorship, impact
- Use STAR timing — most airtime on Action + Result
- Staff packs: career, impact, conflict, delivery/AI Q&A banks
- Backend flavor: incidents, migrations, on-call, cross-team API contracts, data correctness bugs
Company overlays
Skills first, then company shape. Each guide now has backend-focus, round scripts, Lattice path, rubric, week-before plan.
- Amazon — LPs + Bar Raiser; stories must map to principles
- Google — HC packet; depth on coding + design clarity
- Meta — speed + product sense; coding rigor
- OpenAI — mission fit + strong coding/design fundamentals
- Intuit — craft demo + AI fluency + HLD on the craft service
- LinkedIn — articulate/dry-run coding · monitoring HLD · deep STAR
- Microsoft — L63 depth-first DSA · align-before-code · DDIA/HLD