This document outlines the most helpful CSE classes at the University of Washington for building the skills you need in technical interviews—especially those focused on data structures and algorithms (DSA). You’ll learn which classes to prioritize, what background they assume, how they help you debug and think like an engineer, and what to focus on once you’ve taken them.
Why Should You Take These Classes?
The short answer? Because they teach you transferrable skills. Most of us don’t naturally know how to debug complex C memory errors, or how to reason through a dynamic programming problem from scratch. These classes give you the tools to think like an engineer—how to break problems down, write scalable code, and catch your mistakes before they spiral. They’re not just about passing; they shape the way you think, which is exactly what interviewers are looking for.
Also, let’s be honest—interviewing is partly a game, and the more exposure you have to different kinds of problems, the more patterns you’ll recognize when you sit down for a leetcode interview. These classes help build that base.
Classes to Take for Interviews
If you’re only going to take two classes to prep for interviews, I’d recommend these two:
- CSE 332 (or 373 for non-major): This is the bread and butter. It covers core data structures like graphs, heaps, tries, and more, along with how to analyze their runtimes. You’ll implement data structures yourself, which helps during interviews when you need to figure out which data structure to use for an optimal solution.
- CSE 421: This class is all about actually solving problems with algorithms. You’ll get comfortable with greedy strategies, dynamic programming, and graph algorithms—all the patterns that show up on LeetCode over and over. A lot of the theory behind those “standard” patterns everyone memorizes? You’ll actually understand where it comes from after this class.
Highly Recommended Classes
If you want to go beyond just the basics—and build skills that show up in interviews and internships—these are the classes I’d recommend.
CSE 391 — Command Line and Git Basics
If you’ve never really used the command line or Git, take this class. It’s a quick and low-effort way to get familiar with tools you’ll use constantly during an internship.
Knowing how to navigate files, use a shell, and push commits properly will make everything smoother. You don’t need to be a CLI wizard, but being comfortable in a terminal makes you 10x faster when working in real environments. If you already know Git and the CLI, feel free to skip it.
CSE 451, 452, 461 — Systems-Focused Courses
These are the classes that help you level up your debugging, systems thinking, and overall engineering maturity.
Why These Classes Matter
After CSE 351, a lot of people swear off systems. C and assembly scare them off. But I’d encourage you to stick with it—these courses are absolutely worth it, and they teach skills you’ll use constantly.
You’ll definitely learn domain-specific content (like how a scheduler works in OS or how network protocols handle data flow), but that’s not even the most important part.
The Real Value: Debugging Skills
The biggest thing you’ll walk away with is how to debug effectively. This is one of the hardest things to learn—and one of the most valuable.
Whether you’re stuck on a LeetCode runtime error or trying to fix a weird bug during your internship, these classes prepare you to trace through complex systems and figure out what’s going wrong.
For example, Amazon has internal debugging tools like Hubble and Kumo, and the skills you gain from 451, 452, and 461 map directly to using tools like these. You can pick up debugging elsewhere, sure—but I’ve talked to a couple of CSE undergrads, and most agree that these courses are where they learned it best.
Writing Design Docs
One of the most underrated but valuable parts of CSE 451 and CSE 452 is that you write a design document before you write any code.
This forces you to plan out your solution in detail, consider edge cases, and think critically about what you’re about to build. That’s exactly what you’ll be expected to do during technical interviews (where outlining your approach clearly matters) and during internships (where most companies, like Amazon and DoorDash, require design docs before implementation).
What You’ll Code In
Each course also gives you experience coding in different languages:
- CSE 451 (Operating Systems) — C
- CSE 452 (Distributed Systems) — Java
- CSE 461 (Networking) — Java / Python
During / After Taking These Classes
Once you’ve wrapped up some of these courses, you’ll be in a good position to start seriously grinding interview prep. But classes only go so far—at some point, you just need to do the work. Read the next article for more on how to LeetCode effectively— Elijah does a great job breaking it down.
Just remember, these classes set the foundation. Leetcode is the application.