← All resources

Resources · Interview primer · Junior

Interview primer,
junior level.

For your first roles (0–2 years). A comprehensive checklist: how the rounds work, CS fundamentals, one language deep, web + SQL basics, git & tools, easy live-coding, and behavioral stories. Tick a topic once you're confident on it.

10Modules

Junior0–2 years

50Questions

↗ Prep improving+1 point for every box you tick

Coverage

Readiness Score

0%

topics prepped

How rounds work0/4

Data structures0/7

Algorithms & Big-O0/5

Language core0/6

Async basics0/4

Web fundamentals0/6

Progress saves automatically in this browser — come back any time and pick up where you left off.

What to prioritize

Where to spend your first weeks of prep.

Focus first

Data structures + Big-O
One language, cold
Easy problems by pattern
HTTP / REST basics

Don't skip

Narrating while you code
Knowing your own resume
2–3 STAR stories
Questions to ask them

1How interviews actually work

0/4▶

Early on, half the battle is knowing what each round is testing so you prepare the right thing.

The typical loop

Recruiter screen → online assessment / take-home → technical rounds → behavioral → team fit.

Tech Interview Handbook — the whole process, free.

What each round grades: coding = problem solving + clean code; behavioral = communication + ownership.

Coding interview cheatsheet.

Always ask the recruiter what the rounds are and what language/stack is expected.

Coding interview prep guide.

How to handle a take-home: scope it, write tests, a clean README, don't over-engineer.

2Data structures

0/7▶

You must be fluent in the core data structures: their operations, costs, and when to reach for each.

Know each cold

Arrays & dynamic arrays — indexing O(1), why append is amortised O(1).

Big-O Cheat Sheet.

Hashmaps & sets — average O(1) lookup; collisions; when order isn't guaranteed.

GfG — Hashing.

Stacks & queues — LIFO/FIFO, and the problems each unlocks.

Linked lists — singly/doubly; when they beat arrays; the pointer dance.

GfG — Linked list.

Trees & binary search trees — traversal orders; BST invariant.

Heaps / priority queues — O(log n) push/pop; the top-k use.

Graphs — adjacency list vs matrix; when a problem is secretly a graph.

GfG — Graphs.

3Algorithms & Big-O

0/5▶

Every answer ends with "…so it's O(n)". Be able to state and justify the complexity.

The essentials

Big-O for time and space; the common classes O(1) → O(n!) and where each shows up.

Big-O Cheat Sheet.

Sorting: know merge/quicksort exist, their average cost, and stability — you rarely re-implement them.

VisuAlgo — Sorting.

Binary search on a sorted array; the boundary conditions.

LeetCode — Binary Search.

Recursion & the call stack; converting recursion to iteration.

Python Tutor — visualise the stack.

When a hashmap turns O(n²) into O(n) (the Two Sum insight).

Resources — Algorithms (DSA core).

4Your language — core

0/6▶

Pick one strong language and know its fundamentals without hesitation.

Fundamentals (JS or Python)

Variables & scope; value vs reference; mutability.

javascript.info / Real Python.

Functions, default/keyword args, first-class functions.

javascript.info — Functions.

Collections: arrays/lists, dicts/objects, sets — iterate & transform (map/filter/reduce).

javascript.info — Array methods.

Error handling: try/catch/finally; throwing and catching the right thing.

javascript.info — Error handling.

Equality & type coercion gotchas (== vs ===, truthiness).

javascript.info — Comparisons.

String manipulation basics — the bread and butter of easy problems.

Real Python — Strings.

5Your language — async & a bit deeper

0/4▶

Async shows up even in junior live coding. Know the mental model and the common trap.

Async & closures

Callbacks → promises → async/await: the evolution and why await reads cleaner.

javascript.info — Async/await.

Fetch several things in parallel vs sequentially (the loop-of-awaits trap).

MDN — Promise.all.

Closures — what they are and a real use (a counter, a debounce).

javascript.info — Closures.

(Python) list comprehensions, f-strings, and the mutable-default-arg trap.

Hitchhiker's Guide — Gotchas.

6Web fundamentals

0/6▶

Full-stack juniors are expected to know how the web works end to end.

HTTP & the browser

The request lifecycle: DNS → HTTP → server → response → render.

MDN — HTTP overview.

HTTP methods & status codes (2xx/3xx/4xx/5xx) — what each family means.

MDN — Status codes.

REST basics: resources, verbs, JSON request/response shape.

restfulapi.net.

Cookies, sessions vs tokens (JWT) — how a site remembers you.

jwt.io — Introduction.

CORS in one sentence; why a browser blocks a cross-origin call.

Client vs server rendering; what runs where.

MDN — Client-Server.

7Basic SQL & data

0/4▶

Even junior full-stack rounds check that you can query a database.

Query basics

SELECT/WHERE/ORDER BY/LIMIT; filtering.

GROUP BY + COUNT/SUM/AVG; INNER vs LEFT join.

SQLBolt — Joins.

Primary key vs foreign key; what a relationship is.

W3Schools — Foreign key.

SQL vs NoSQL in one sentence each.

Resources — SQL (Junior).

8Git & dev tools

0/4▶

You'll be asked how you work day to day — version control fluency is assumed.

Everyday workflow

Branch, commit, merge vs rebase; resolving a conflict.

Learn Git Branching — interactive.

Pull requests & code review etiquette.

Google — Code review.

What CI/CD is at a high level; why tests run on every push.

GitHub Actions — basics.

Reading a stack trace and using a debugger/breakpoints.

Chrome DevTools — Debugging.

9Live coding & approach

0/5▶

The bar is clean code + thinking out loud, not tricks. Narrate before you type.

Practice + narration

Solve the essential easy problems by pattern; narrate the approach first.

Resources — LeetCode Patterns.

Clarify the problem & state assumptions before coding.

Coding cheatsheet.

State complexity at the end; test one normal + one edge case (empty, single).

NeetCode — Roadmap.

Practice in a bare editor with no autocomplete.

CoderPad sandbox.

What to do when stuck: restate, shrink the input, brute force first, then optimise.

10Behavioral & logistics

0/5▶

Junior behavioral rounds check communication and coachability. Prepare stories and know your resume.

Be ready to talk

"Tell me about yourself" — a crisp 60-second story of who you are and what you've built.

Behavioral guide.

Draft answer

Shape (60s) — present → past → why here. "I'm a [role] who most recently built [project/thing] using [stack]."

Then one line on a highlight: "The part I'm proudest of is [specific outcome]." Close with "I'm looking for [what this role offers]." Keep it under a minute and don't recite your whole resume.

STAR format for 2–3 stories (a project, a challenge, a teamwork moment).

The Muse — STAR method.

Draft answer

S/T — one sentence of situation + your task. A — the bulk: what you did, decisions and why. R — the result, ideally a number.

Prep three: [a project you shipped], [a hard bug], [a teamwork/conflict moment]. Time each at ~90 seconds.

Know every line of your resume and every project deeply — expect "walk me through this".

"Why do you want to work here?" — one specific, researched reason.

Behavioral guide.

Prepare 3 questions to ask them (team, stack, first 90 days).

Questions to ask.

Junior bar = fundamentals, clean easy problems, and clear communication · narrate everything. All links open in a new tab.