Boost Your Coding Interview Skills With an Effective Study Plan

Create a winning study plan to excel in coding interviews. Retain knowledge under pressure and collaborate seamlessly with interviewers. By Ryan Brodsky.

Leave a rating/review
Save for later

Are you preparing for a coding interview — and feeling overwhelmed by the prospect of showcasing your programming skills under pressure? Don’t worry, you aren’t alone. Most candidates find technical interviews uncomfortable. After all, coding under pressure is nothing like working on your personal projects.

But the good news is that with a well-designed study plan, you can prepare yourself to demonstrate your unique value to a company, even with standardized coding challenges. In this article, you’ll learn how to create a study plan that maximizes your chances of acing your technical interview and landing your dream job.

A man sitting in front of an open book studying for a coding interview, surrounded by symbols

Don’t just study; study effectively. Image by Bing Image Creator

What You’ll Learn:

  • Your real goal when preparing for a coding interview.
  • How to use spaced repetition to internalize the skills you’ll need for the technical interview.
  • Tips to effectively prepare for things to go wrong — or too right!

In the following sections, you’ll explore how to create a study plan that helps you remember all of those design systems and algorithms you’re studying and prepares you to shine in your coding interview.

Step One: Build a Process, Not a Portfolio

Performing well in a coding interview isn’t about collecting the biggest list of LeetCode challenges; nobody cares about the 327 challenges you completed while you practiced. They only care how you perform during the 328h challenge — at the interview.

When you’re working on the endless series of data structures and algorithms listed for the hot tech companies you’re applying for, your focus should be on developing a repeatable, sustainable process for approaching the problems you’ll tackle for that company.

Everyone has their own way of doing things, but most successful processes include these key elements:

  • Defining the constraints of the problem: “What can I assume about my inputs?”
  • Clarifying how you’ll handle edge cases: “What should I return as the maximum element if I’m given an empty array?”
  • Using pseudo-code to define the logical steps of the problem.
  • Identifying possible helper functions to break the process down into more concrete steps.
  • Testing your code after writing X number of lines.

Companies don’t want to know that you can reverse a binary tree; they want to present you with challenges that force you to reach into your mental toolkit and pull out all your finest problem-solving techniques. And that’s why binary trees are on the list: They are simple to explain and have difficult-to-implement methods readily available.

Your goal for each code challenge isn’t to get to the right answer as quickly as possible. It’s to demonstrate that you have a process for defining and solving code challenges, as well as how you think about optimizing performance once you have a working solution.

Remember, while practicing for code challenge interviews, always remember your goal is perfecting your problem-solving process until it becomes second nature.

Step Two: Use Spaced Repetition to Engage Your Long-Term Memory

Have you ever sat down to take a test feeling pretty confident… and then blanked as soon as you saw the first problem? It’s a common and confusing experience caused by failing to transfer the information you learned from short-term to long-term memory. And sadly, many learning strategies do nothing to prevent this from happening.

A person's silhouette with a glowing brain and a calendar in the background

Spaced repetition helps you remember what you learn long-term. Image by Bing Image Creator

It’s natural to organize your study plan according to the most common data structures and algorithms, then tackle them one at a time. You devote one week to sorts, the next to graphs, and so on. After all, that’s how most learning experiences are organized.

However, learning science could not be clearer that this is the wrong way to go.

Say you’re working with binary trees, for example. It’s typical to write the basics of the structure one time. You might copy and paste what you’ve already written between challenges, or just keep writing each new challenge in the same file. Once you’ve gotten through the binary trees section of your study plan, you move on to more interesting and engaging challenges.

What you end up with is a castle made of sand. You’ve only done each part once; as time goes by, the memory fades. You move on to other structures and other algorithms, and eventually, you’ll lose most of what you learned through disuse.

When you’re actually working on the challenges, it’s easy to remember what you need to do because it’s all in short-term memory.

But if you’ve never needed to recall the answers after briefly forgetting them for a while, then the first time you’ll search your brain for them will be during the interview itself: the highest-stress environment possible!

Instead, you need to practice your skills by giving yourself time between challenges to forget, then reconstruct the knowledge. That’s called spaced repetition.

Spaced repetition might feel harder and more frustrating, but it’s the most scientifically effective way to add new skills and knowledge to your long-term memory.

How to Use Spaced Repetition in Your Coding Interview Study Plan

To use spaced repetition, avoid going deep into one topic and then moving on. Instead, move from topic to topic in a semi-programmed sequence to give yourself time away from each subject before revisiting it.

Spaced repetition is a delicate balancing act of waiting long enough between iterations for your knowledge of each subject to slip from your short-term memory, but not so long that your memory of the topic is completely gone.

Each time you recall the subject matter successfully, you can increase the amount of time until your next repetition. Your first repetition of a concept should be relatively soon after you’ve just learned it. You then reschedule your next repetition sooner or later, depending on how well you did. If you nail a problem three times in a row, then you won’t need a fourth repetition for a while.

If this sounds complicated, don’t worry; there are plenty of apps to help, though most of them take the form of flashcards and specific questions rather than families of questions like “binary tree problems” or “searching algorithms.”

Alternatively, you could develop your own system with sticky notes and columns for how frequently you want to review a given problem type, along with room to note your last encounter with the challenge.

For example, set up on a whiteboard columns for “daily,” “every three days,” “weekly,” and “bi-weekly” review sessions. Each topic gets its own sticky note. If you get the problem right, move the sticky note from the “daily” column to the “every three days” column. If you get it wrong, slide it back into a more frequent column or keep it where it is.

Tip: Now that I’m describing it, this actually sounds like a fun variation on a to-do list application. If you have one of those hanging around from your first few projects, maybe soup it up into a spaced repetition study aid app!

Step Three: Practice Getting Stuck

Did you ever consider that it’s possible to do too well in a technical interview? When programmers cruise through a coding challenge, interviewers don’t have the chance to learn much about them or to witness the problem-solving process they want to see in a candidate.

However, you can turn this to your advantage, too. If the questions are easy for you, try thinking of a new twist or feature that would make you intimidated to keep going — and work on that next. Unless you get stuck at the very outset of the challenge, it’s a good thing to hit that wall and have to work your way past it.

This is the whole point of the interview — it means you’ve gotten to the good part. You get to show them the process you’ve been working so hard on! You’ll demonstrate your resilience in the face of genuine difficulty and collaborate with the interviewer. Here’s your chance to develop the rapport that makes them think, “I can work with this person!”

Don’t be afraid to ask your interviewer questions about specific syntaxes or to talk your way through problems. Saying, “I know I need to…” provides the interviewer a chance to either interject and give you some leading clues or explain why you’re going down a dead end and offer an alternative.

Either way, you’re making the experience collaborative and demonstrating the partnership they can expect when you’re consulting with your future teammates.

Step Four: Apply the Concept to a Project

The challenges in technical interviews often feel abstract and disconnected from the job. Even battle-hardened developers acknowledge the uselessness of coding-interview-style algorithms. For example, Max Howell, the creator of Homebrew, the near-universal package installer for Mac users, was rejected by Google for not being able to reverse a binary tree on the spot.

One way to make knowledge stick is to plug it into the broader context of your programming knowledge. Ideally, this would mean using what you’ve learned in one of your side projects.

Abstract image of a woman putting knowledge into something practical

Applying your knowledge to something practical is a great way to remember it. Image by Bing Image Creator

For example, you could solidify your understanding of sort functions before your coding interview by using them in place of a built-in .sort method in an app that lets users access or request sorted data.

Tip: If it bothers you to keep your manual sort in the function, just comment it in and out depending on the state of the side project.

You might also challenge yourself to add new wrinkles to the challenge that are uniquely suited to the context of the project as well.

For example, if you’re sorting a list of objects, challenge yourself to create a more complicated ranking system that compares multiple values, like so:

  • Add a tiebreaker value when the main sorting values are tied.
  • Allow users to create a valuation function that weights several of the object’s keys to determine a final rankable score.
  • Provided a scoring function as a string in the format of a calculus function, create a sorting function that applies the function to each object in the array and sorts them according to the resulting output of the user’s scoring function.

Following up With Concrete Applications After Your Interview

Whether your coding interview was successful or not, one tactic that helps you stand out from other candidates is getting back to your interviewer later with a useful application of the concepts you covered during the interview. This demonstrates that you are eager to learn from them and creative enough to apply what you’ve learned in a project.

For example, writing a recursive function compiling all permutations of nodes in a search trie sounds like a nightmare code challenge. And yet, one of my favorite coding side projects does exactly that — only in the context of the British panel game show, Eight Out of Ten Cats Does Countdown.

Ignoring the delightfully English absurdity of the title, it’s a show in which contestants are given seven letters and challenged to find the largest possible words that can be spelled with those letters. So, I wrote an application that creates a search trie of all words in the dictionary, then traverses that data structure when given the seven letters of a round of the game.

While I’m skeptical I’d be able to pass a code challenge phrased as “compile all permutations of traversable nodes in a search trie” on the spot, the application nonetheless proves I was able to do it in a creative and unique context when given a realistic amount of time.

We all know that not every problem can or should be solved in the space of an hour under direct observation with a job on the line. A custom-made project applying the “failed” algorithm in a novel context will show that you’re able to work with concepts of that difficulty level — and that you don’t give up easily.

If the algorithm isn’t particularly suitable for a project, consider creating a suite of unit tests around the given problem, or doing a benchmarking performance comparison between different alternative answers. This type of in-depth analysis of the problem is more indicative of the kind of rigor you’ll bring to the job — and arguably demonstrates more value than being able to solve things quickly on the spot.

Key Takeaways

While there’s no replacement for practicing as many different algorithms as you can, creating a study plan helps you spend your time preparing for your coding interview more productively. To do this:

  • Focus more on your problem-solving processes than on the solutions to any specific coding challenge.
  • Use spaced repetition to solidify what you remember about the topics you study.
  • Prepare to get stuck in your technical interview. See it as an opportunity, not a failure.
  • Practice by using your knowledge in actual projects – even after a coding interview. Especially if the interview didn’t go as well as you’d hoped.

    By collaborating with the interviewer, you’ll go a long way toward demonstrating your value and helping interviewers see you as an effective future colleague who’s capable on their own and a productive team member.

About the Author

Ryan Brodsky is an educational leader who has been teaching new programmers since 2017. He is passionate about helping developers from different backgrounds learn the skills they need to succeed in their careers.