How to Handle a Pop Quiz on CS Fundamentals

Short answer: Prep six high-value topics in depth instead of the whole curriculum: virtual memory, TCP vs UDP, HTTP basics, SQL fundamentals, ACID transactions, and big-O. Practice explaining each out loud in 90 seconds, then rehearse one likely follow-up. Pop-quiz rounds grade fluency and reasoning, not recall, so a new grad who talks fluently in Python or Java beats one who memorized ten extra facts. When you hit a topic outside your prep, reason from adjacent knowledge instead of bluffing.

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. As of the 2026 hiring cycle, pop-quiz questions are graded on fluency and reasoning, not encyclopedic recall. The goal is to talk fluently in your own voice, not to win a trivia contest. These rounds show up across the new-grad loop, whether the role leans toward a system design discussion or a straight coding screen.

If you'd rather hear yourself explain virtual memory or the TCP handshake out loud before the real round, run a practice fundamentals quiz and rehearse the answer in your own words first so you walk in already knowing what landing the explanation feels like.

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" 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 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. A page fault is the event that fires when a program touches a virtual address whose data isn't currently in RAM, forcing the OS to fetch it from disk. 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. A process is an isolated program with its own private memory space; a thread is a unit of execution that shares its process's memory with sibling threads. 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. TCP is the connection-oriented transport protocol that guarantees ordered, reliable delivery, while UDP is the connectionless protocol that trades those guarantees for lower latency. 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. An index is an auxiliary data structure (usually a B-tree) that speeds up reads on a column at the cost of slower writes and extra storage. 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?" If counting loops and stating the dominant term still feels shaky, work through our companion guide on how to explain time complexity in an interview until the cost claim comes out clean.

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.

CS fundamentals cheat sheet: the six topics at a glance

This table is the fast-reference version of the high-leverage six. Use it the morning of a technical round to confirm you can hit each one-line answer and its most common follow-up.

| Fundamentals topic | One-line answer to lead with | Most common follow-up | Prep priority | |---|---|---|---| | Virtual memory | "Each process sees a private, contiguous address space backed by page tables." | "What does a page fault cost?" | High | | Processes vs threads | "Processes isolate memory; threads share it and context-switch cheaper." | "What's a race condition?" | High | | TCP vs UDP | "TCP is reliable and ordered; UDP is fast and best-effort." | "Why does HTTP run over TCP?" | High | | HTTP basics | "Stateless request/response over TCP, with verbs and status-code classes." | "HTTP vs HTTPS?" | Medium | | SQL fundamentals | "JOINs combine tables; indexes trade write speed for read speed." | "When would you NOT index?" | Medium | | Big-O analysis | "Count the loops, multiply nested work, keep the dominant term." | "What's amortized analysis?" | High |

A quick way to read the table: the three High-priority rows (virtual memory, threads, big-O) show up across nearly every kind of new-grad loop, so drill those first. The Medium rows are still worth a pass but skew toward backend, infra, and data roles.

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 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 same move works on coding rounds too. See how to handle "I don't know" in an interview and how to handle a coding problem you've never seen for the full recovery scripts.

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 knows their stuff. I'd record the TCP handshake first, by the way. It's the one people think they know and then describe out of order on the second clause, every time.

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. Reasoning out loud is a trainable skill on its own; our guide on how to think aloud during a coding interview breaks down the cadence, and the broader CS new grad interview loop walkthrough shows where the fundamentals round usually sits in the day.

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. For where this round fits alongside the coding screen, our coding interview cheat sheet and technical phone screen tactics for CS new grads cover the rest of the day.

Key terms

A quick glossary of the fundamentals vocabulary that shows up most in pop-quiz rounds. Knowing the precise one-line definition is half the battle. Being able to say it fluently is the other half.

Virtual memory

The OS abstraction that gives each process a private, contiguous address space mapped to physical RAM (or disk) through page tables. The classic POSIX-style mechanism behind "why doesn't program A clobber program B's memory?"

Page fault

The trap that fires when a process accesses a virtual page not currently resident in RAM, prompting the OS to load it from disk. A minor fault hits a page already in memory; a major fault requires a disk read, which is roughly 100,000x slower than RAM.

Process vs thread

A process owns an isolated memory space; threads live inside a process and share its heap while keeping separate stacks. Threads context-switch more cheaply but expose you to race conditions.

Race condition

A bug where the outcome depends on the unpredictable timing of two or more threads touching shared state. The standard fixes are mutual exclusion (a mutex or lock) and avoiding shared mutable state altogether.

TCP three-way handshake

The SYN, SYN-ACK, ACK exchange that opens a reliable TCP connection, specified in RFC 793. It's the canonical "explain TCP" follow-up, and it's why HTTP (which needs ordered, lossless delivery) runs over TCP rather than UDP.

ACID

Atomicity, Consistency, Isolation, Durability: the four guarantees a relational database transaction provides. Be ready to give a one-line example of each; "atomicity means the whole transfer commits or none of it does" is the kind of answer that lands.

Database index

An auxiliary structure, usually a B-tree, that turns a full-table scan into a fast lookup on a column. The trade-off, slower writes and extra storage, is exactly the "when would you NOT add an index?" follow-up.

Big-O notation

The upper-bound description of how an algorithm's time or space grows with input size. Interviewers grade whether you can justify the dominant term, not whether you can recite a table.

For a candidate hundreds of applications deep into the 2026 cycle and still chasing the offer that ends the search, the win condition here isn't memorizing this glossary. It's walking into the room able to say each answer in your own voice. If you want to rehearse the full fundamentals round and hear your explanations graded before it counts, see how live coaching turns a shaky pop quiz into a confident one, the same approach that starts at a $3 trial.

About the author: Sam K. 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.