The only interview framework
engineered for how SWEs actually think.
BASIC — Breakdown, Assess, Structure, Implement, Check — was built from the ground up for algorithm problems and system design interviews. Not adapted from HR storytelling. Not borrowed from consulting. Designed by engineers, for the exact sequence your brain needs when the problem is technical and the clock is running.
STAR tells you to describe a Situation. BASIC tells you to decompose the problem. That difference is everything when you're staring at a LeetCode prompt or whiteboarding a distributed system.
Every other framework was built for a different job.
STAR was designed in the 1980s for behavioral interviews — describing past situations. It's great at that. But when you're solving a graph problem live, or designing a rate limiter on a whiteboard, "Situation, Task, Action, Result" gives you nothing. BASIC was purpose-built for the moment when you need to think clearly under pressure about a technical problem you haven't seen before.
Algorithms from day one
Breakdown = parse the prompt. Assess = compare brute force vs optimal. Structure = define the invariant. Implement = code to plan. Check = dry-run and complexity. This is how algorithm problems actually get solved.
System design from day one
Breakdown = clarify requirements. Assess = trade-off matrix. Structure = architecture sketch. Implement = walk the request flow. Check = bottleneck review. This is what design interviewers actually score.
Naturally expands
Because BASIC maps to how engineers think — decompose, evaluate, plan, execute, verify — it extends to behavioral prep, AI-assisted research, debugging, and any domain where structured reasoning beats improvisation.
BASIC vs every other method — side by side
Honest comparison. We're not pretending the others are useless. We're saying BASIC covers more ground, more reliably, for the problems software engineers actually face.
| Capability | BASIC | STAR | Polya's 4 Steps | Ad-hoc / No method |
|---|---|---|---|---|
| Algorithm problem solving | Built for it — pattern selection, invariants, dry-run | Not applicable | General problem-solving; no SWE-specific steps | Depends entirely on prior exposure |
| System design | Requirements → trade-offs → architecture → stress test | Not applicable | Vague at architecture scale | Works if experienced; fails under pressure |
| Behavioral storytelling | BASIC backstage + STAR onstage = strongest combo | Purpose-built for this | Not designed for narratives | Hit or miss |
| Live coding communication | Each step naturally prompts explanation to interviewer | No coding support | No communication layer | Silent coding is negative signal |
| Trade-off reasoning | Dedicated Assess step forces explicit comparison | No comparison mechanism | "Devise a plan" — one step, underspecified | Usually skipped under time pressure |
| Self-verification | Dedicated Check — dry-run, edge cases, complexity | Result is retrospective, not verification | "Look back" — similar but less specific | "Submit and pray" |
| Recovery when stuck | Return to Breakdown with sharper knowledge | No recovery mechanism | Re-read the problem | Panic restart |
| Cognitive load management | Each step offloads one category of mental work | 4 buckets reduce some load | 4 steps help | Everything in your head at once |
| Works across all interview types | Coding, design, behavioral, research, debugging | Behavioral only | Math/algorithm only | Depends on the person |
Where BASIC was built to dominate
These aren't afterthoughts. These are the problems BASIC was designed to solve from the first line of research.
Coding interviews
Parse the prompt → compare brute force vs optimal → define the invariant → code to plan → dry-run and state complexity. This is what BASIC was born for. Every step maps directly to what coding interviewers score: decomposition, trade-off reasoning, plan-before-code, clean implementation, and self-verification.
System design
Clarify scope → weigh SQL vs NoSQL, sync vs async → sketch the architecture → walk the request path → stress-test for bottlenecks. System design interviewers don't score your box-drawing speed. They score your reasoning sequence. BASIC makes that sequence explicit and repeatable.
Behavioral prep
BASIC doesn't replace STAR for behavioral answers — it makes STAR better. Use BASIC backstage to pick the right story, assess which signal it sends, structure the narrative arc, rehearse the delivery, and check that it actually answers the question. Then go onstage with STAR.
AI-assisted research
Frame the question → evaluate sources → plan the synthesis → execute research → verify claims. AI tools generate confident-sounding text fast. BASIC ensures you don't trust it blindly. The verification discipline matters more in 2026, not less.
Core docs
The opinionated, no-filler version of the framework. This is where to start.
What BASIC is and how to use it
The five steps, how they connect, and why the order matters more than the labels.
Why BASIC works for software engineers
The cognitive science and engineering practice behind the framework. Not motivational — evidence-based.
BASIC vs STAR — the honest comparison
When STAR wins, when BASIC wins, and why using both is the strongest move.
BASIC for LeetCode and coding rounds
Pattern selection, invariant definition, implementation discipline, and the dry-run advantage.
BASIC for system design
Requirements, trade-offs, architecture, request flows, and bottleneck analysis.
BASIC for behavioral interviewing
Story selection, signal assessment, narrative structure, and follow-up resilience.
Where it started
The original deep-dive articles that seeded the research archive.
Why BASIC works for software engineers
The foundational argument: why a five-step sequence beats ad-hoc reasoning in every interview format.
Why BASIC beats STAR for SWE use cases
The honest comparison — where STAR still wins, and the five areas where BASIC is strictly better.
A first-person BASIC story — start to offer
A realistic composite narrative following the framework from first practice session to final round.
BASIC for LeetCode — the reliable way
Why treating LeetCode as a memory contest is the wrong move, and how BASIC changes the game.
BASIC for system design — architecture-scale thinking
System design is not a bigger coding interview. It requires a different operating system. Here's why BASIC fits.
Series and archives
500+ posts organized by theme and year.
Why BASIC Works
101 posts in this series.
BASIC vs STAR
101 posts in this series.
First-Person Journey
46 posts in this series.
LeetCode
151 posts in this series.
System Design
101 posts in this series.
2026
30 posts.
2025
157 posts.
2024
158 posts.
2023
155 posts.
Diagrams
Clean, SVG-based diagrams — 50 framework visuals + 98 concept maps. All viewable at full resolution.
