How to Handle a Pop Quiz on CS Fundamentals

How do you handle a pop quiz on CS fundamentals?

Cover six high-value topics in depth, not the whole curriculum in breadth: virtual memory, TCP vs UDP, HTTP basics, SQL fundamentals, ACID transactions, and big-O analysis. For each, practice explaining the topic out loud in 90-120 seconds, then practice answering one common follow-up. Pop-quiz questions are graded on fluency and reasoning, not encyclopedic recall.

What interviewers are actually testing

The pop quiz on CS fundamentals is not testing whether you memorized your operating systems textbook. It's testing three things:

1. Did you actually learn this stuff — or did you cram it for the final and forget it the next semester?
2. Can you reason about systems — can you connect the textbook concept to a real-world implication?
3. Can you communicate technically — can you explain a concept clearly to someone who already knows it?

That third one matters most. A candidate who explains TCP three-way handshake confidently in 90 seconds beats a candidate who can recite ten extra details but stumbles through the explanation.

According to NACE employer surveys, "communication of technical concepts" consistently ranks as the top-cited weakness in new-grad CS candidates — ahead of coding ability, ahead of theoretical knowledge. Pop-quiz rounds are partly screening for this exact skill.

The high-leverage six

If you only prepare six fundamentals topics, prepare these. They cover roughly 70% of pop-quiz questions in new-grad CS loops.

1. Virtual memory and paging. What it does, why it exists, what happens on a page fault. The follow-up: "What's the cost of swapping to disk?"

2. Processes vs threads. Memory model difference, context-switch cost, when to use each. The follow-up: "What's a race condition and how do you prevent one?"

3. TCP vs UDP. When to use each, the three-way handshake, how TCP handles packet loss. The follow-up: "Why does HTTP run over TCP?"

4. HTTP basics. Common verbs, status code categories, what happens between typing a URL and the page rendering. The follow-up: "What's the difference between HTTP and HTTPS?"

5. SQL fundamentals. JOIN types, indexing, what makes a query slow. The follow-up: "When would you NOT add an index?"

6. Big-O analysis. Time vs space, common complexity classes, how to analyze nested loops and recursion. The follow-up: "What's amortized analysis and when does it matter?"

Master these six and you'll handle the bulk of fundamentals questions confidently. Everything else (caching, file systems, compilers, formal language theory) is upside, not foundation.

The 90-second explanation drill

For each of the six topics, practice this drill:

1. Define it in one sentence. "Virtual memory is the abstraction that lets each process see a private, contiguous address space, regardless of what's physically in RAM."
2. Say why it exists in one sentence. "It exists so multiple programs can run without stepping on each other's memory and so programs can use more memory than the machine physically has."
3. Give one concrete mechanism in two sentences. "The OS maintains page tables that map virtual addresses to physical ones. When a program accesses a virtual address that's not in RAM, a page fault triggers the OS to load it from disk."
4. Name one tradeoff in one sentence. "Page faults are expensive — disk access is roughly 100,000x slower than RAM — so heavy swapping kills performance."

Four sentences, ninety seconds. Practice each topic until you can deliver this fluently without notes.

The "I don't know" recovery move

You will hit a topic you don't know. The recovery move:

1. Say so — "I haven't worked with that directly."
2. Reason from adjacent knowledge — "Based on the name and what I know about [related concept], I'd guess it works like X..."
3. Frame it as a hypothesis — "...but I'd want to verify that. Can you tell me if I'm on the right track?"

This shows the three things they're actually testing — honesty, reasoning, and communication — without pretending you know something you don't. Bluffing is the fastest way to lose a fundamentals round; reasoning under uncertainty is one of the fastest ways to win one.

The drill schedule

A two-week prep schedule for fundamentals:

Week 1 — Depth on the six. One topic per day, 30 minutes each. Read the canonical source (an OS textbook chapter for virtual memory, an RFC for TCP, a SQL tutorial for indexes), then practice the 90-second explanation drill out loud three times.

Week 2 — Breadth and follow-ups. Add lighter coverage of caching, concurrency, networking layers, and database normalization. Practice the follow-up questions from your list. Do mock pop-quizzes with a friend or recording yourself.

Two weeks of focused prep is enough to handle nearly any new-grad pop quiz comfortably. Five weeks of unfocused cramming often produces less.

How to practice out loud

The single biggest upgrade for fundamentals prep is talking through topics out loud, not silently reading. Why:

• Pop-quiz answers are graded on verbal fluency, not internal understanding.
• You discover what you actually understand vs what you just recognize when you have to produce sentences in real time.
• It surfaces the awkward transitions where you know the concept but can't explain it in order.

Record yourself answering each topic on day one of prep. Listen back. You'll cringe. Re-record on day three; you'll cringe less. By day seven you'll sound like a candidate who actually knows their stuff.

When the question is outside the six

If the pop quiz lands on a topic outside your prepared list, fall back to the structural answer:

1. Acknowledge specifically what you know and don't know. "I haven't used [specific tool], but I have a working understanding of [adjacent concept]."
2. Reason in public. Walk through the question step by step.
3. Ask one clarifying question if the question is ambiguous.
4. Land on a defensible answer even if it's hedged.

The interviewer is not looking for a perfect answer to a question outside your background — they're looking for how you behave when you don't immediately know the answer. The behavior is the signal.

Companies where this matters more

Pop-quiz fundamentals come up more often at:

• Quant finance and HFT firms (heavy on networking, OS, low-level memory)
• Database and infra companies (heavy on SQL, distributed systems, consistency)
• Embedded systems and OS-level roles (obvious)
• Security-focused companies (cryptography, networking, OS)
• Some legacy enterprise CS interview loops (just by tradition)

Less often at:

• Pure frontend / product roles
• Startup full-stack roles (more practical, less theoretical)
• ML and data-science new-grad roles (more focus on math and ML-specific topics)

Per the Levels.fyi blog interview reports, candidates can usually predict whether a fundamentals round will appear by reading the team description and the JD carefully. If the role mentions distributed systems, performance, or infrastructure, prep heavier.

About the author: Alex Chen is the founder of InterviewChamp.AI and writes about the modern tech interview from the inside — what changed, what works for new grads, and where the old playbook fails.