Most people waste time in their efforts. This tutorial will go through everything you need to read, observe, and do in order to go into your interview with confidence.

This guide also assumes that you've already landed the interview and are preparing for on-sites, though the advice here is definitely applicable for technical phone screens as well.

So first, a word on timing.

How Long Do I Need?

If given a choice, I’d obviously advocate long-term technical preparation— the longer the better. As a general recommendation, roughly 2-3 months to get fully prepared. This lets you get in around 60-120 challenges, which seems to be the amount you need to do to build the algorithmic intuition.

Obviously this depends on work experience, familiarity with computer science fundamentals, and proximity to interviews themselves.

It may take 3-6 months for a new bootcamp grad with zero exposure to data structures and algorithms to get fully ramped. On the other hand, it could take take 1-2 weeks for a low-level Senior Systems Engineer.

Could you pass a whiteboard technical interview from absolute scratch with a month’s prep? Depends on you, but it's certainly doable-- just be sure you’re applying the 80/20 principle and hitting the major themes.

If there’s only a month left, the recommendation would be to do 1-2 problems a day the right way, and perhaps include some light reading. We'll get to that in how to study individual coding problems.

How to Use Sample Coding Problems

The way most people study/prepare with coding problems isn't conducive. The average person will go on a site like AlgoDaily or Leetcode, and will look at a problem for 30 seconds to a few minutes.

Often they'll then jump to the solution after getting stuck, read the solution, and call it a day. If this sounds familiar, don't sweat it.

Trying to memorize the solution doesn't really work. Here's a more effective way, and it's why AlgoDaily was designed the way it was:

0. First, choose a cadence. One interview challenge a day seems to be the ideal amount. If you do 2 or 3 a day in the manner described, you'll be spending 3-4 hours doing it, which is quite ambitious unless you have all day to spend.

It's also mentally tiring, and you likely won't derive a whole lot of marginal benefits past the 3rd or 4th problem. At a certain point, you'll probably begin to eagerly jump towards obvious solutions, which causes you not to understand where your strengths and weaknesses are.

The below process nudges your thought process towards retaining the patterns, and eventually will help you solve problems you've never seen prior.

1. Commit to about 20-30 minutes of trying to solve it by yourself before going to the solution. Really try to get some semblance of a correct output. Brute force it if you have to - just try to reason about any kind of working solution, no matter how slow the code will run. It will help you get the necessary foundation to optimize later.

2. If you get stuck, start by look at a single hint. Then keep trying to solve it. Repeat until there are no more hints.

3. No hints? Start going through the walkthrough or solution very slowly. As soon as you get unstuck, STOP READING, and try to solve it on your own again.

4. Use the bit of insight to start trying to code again.

Anytime you get stuck again, repeat step 1. Even though you’ve read a part of the solution, the vast majority of learning comes from the struggle of thinking through it yourself. That is what will help you retain it for next time.

Here's some additional steps that really made the difference in my prep:

5. Write the solution again in another programming language. This forces you to think through the abstractions again, and helps with retention.

6. Save the problem, and revisit in increasingly long spurts. So you might do it again in 2 days, then revisit in a week, then a month.

Some questions to ask at each step:

• What have I learned thus far? Is there anything I should know for next time?
• What pattern or technique did the solution derive from?
• What hint did I need? How far was I from solving it myself?
• If asked this same question tomorrow, can I readily solve it without any assistance?

What Should I Know? Give Me a Checklist!

The biggest challenge with technical interviews is that almost anything under the sun can fall under the term "technical". If we're specifically talking about software engineering jobs, then the scope shrinks considerably, but the world of programming is still huge.

Here's an attempt at all the topics to cover for technical interviews. Be sure to go to the previous section for a guide on how to study these topics.

These lists are prioritized from most important to least important. Ultimately, it's a pretty minor subset of all the algorithms and data structures we know of. The great thing is that this is pretty fixed over time, as the academic underpinnings of Computer Science don't change too much.

Big O notation

You must get this part, as it forms the foundation for understanding algorithmic performance and how to choose a data structure.

At least the very least, know the underlying theory and why it's important (hint: scaling, good decision making, trade-offs, etc.)-- a good starting point is this guide.

The point here of this is that interviewers want to know you can avoid poor-performing code. Imagine if Facebook took an hour to find your friends, or if Google took a day to display search results..

Data structures

• Hashtables - Arguably the single most important data structure known to mankind. Make sure you can implement one from scratch.
• Stacks / Queues are essential, know what FILO and FIFO are.
• Linked Lists - Know about singly linked lists, doubly linked lists, circular.
• Trees - Get to know basic tree/node construction, traversal and manipulation algorithms. Learn about the subsets-- binary trees, n-ary trees, and trie-trees. Lower-level or senior programmers should know about balanced binary trees and their implementation.
• Graphs - Get to know all implementations (objects and pointers, matrix, and adjacency list) and their pros and cons.

Algorithms

• Sorting - get to know the details of at least two n*log(n) sorting algorithm, I recommend Quicksort and Mergesort.
• Binary Search - it's surprisingly common to end using some form of binary search in a final problem solution. Check our guide out for a lovely introduction.
• Tree/Graph traversal algorithms: Breadth-first Search and Depth-first Search are musts. Also know inorder, postorder, preorder.
• Advanced - for the most part optional, but if you wanted to go beyond the basics, I'd recommend Dijkstra, A*, Traveling Salesman, Knapsack Problem.

Math (rare)

• Basic discrete math (logic, set theory, etc.)
• Counting problems
• Probability (permutations vs. combinations)

Programming Languages

• Know the ins-and-outs of your language (I'm fond of JS). The language you choose should be one that you have mastered, or know best. The interview is not the time to be figuring out how to write a for-loop or what is truthy.
• Don't worry about choice of language. There is some controversy around this point-- if you're going for a Frontend role, perhaps Javascript is a better language than Python (and vice-versa for a backend role). But for the most part, the interviewer is conducting the interview because they are looking for your algorithmic reasoning skills and thought process. I've had interviewers not know the ins-and-outs of ES6 JS, and I just kindly explained parts that were unintuitive to them (like why you don't need return statements in certain arrow functions).
• Helps a lot to know one of Python, C++, Java

OOP Design

• Polymorphism
• Abstraction
• Encapsulation/Inheritance

Systems Design

This tutorial to systems design for new engineers is a great starting point on how best to practice for such interviews.

• Scoping/User Cases/Constraints
• Component Design
• OOP Design
• Database Schema Design
• Vertical Scaling
• Horizontal Scaling
• Caching
• Load Balancing
• Database Replication
• Database Partitioning
• Map-Reduce
• Microservices
• Concurrency
• Networking
• Abstraction
• Estimation

Note: Systems Design is a huge interview topic in itself. I highly recommend the System Design Cheatsheet and reading Designing Data-Intensive Applications.

Best Materials To Prep

Embarking on a coding interview journey? You'll need the right tools and materials.

The AlgoDaily Approach

Daily Challenges and Newsletters

• Recommendation: If you haven't checked out AlgoDaily, you're missing out.
• Why: AlgoDaily's daily newsletter and premium challenges offer a structured way to master algorithms. The platform provides comprehensive walkthroughs and visualizations that can demystify even the most complex topics.

Bite-Sized Learning

• How: Try solving just one problem today.
• Why: This will give you a taste of AlgoDaily's approach, which is designed to make complex algorithms digestible through small, daily commitments.

Leveraging the Materials

The Challenge of Academic Texts

• Observation: Many find the idea of diving into a thick, academic textbook intimidating.
• Why: These books often come packed with dense theory, which can be overwhelming. We try to avoid that by making it visual, light, and intuitive.

A Structured Approach

Step 0: Set Up Practice Time

• How: Dedicate a specific time each day solely for working on this area.
• Why: Making it a habit ensures that you'll consistently chip away at the material.

Step 1: Establish a Cadence

• How: For textbooks, aim for 10-15 pages per day, akin to AlgoDaily's one-problem-a-day model.
• Why: A steady pace makes the challenge more manageable without causing burnout.

Step 2: Pre-Scan the Material

• How: Before diving into a chapter, glance over the headings and summary.
• Why: This gives you a mental framework on which to hang the new information, making it easier to understand and remember.

Step 3: Take Notes

• How: As you read, jot down key points in an outline format.
• Why: Taking notes encourages active reading and provides you with a quick reference for future study. Plus, these notes could be a valuable addition to your professional portfolio.

More Advanced Prep and Materials

At startups and smaller companies, or for specialized roles or research positions,you may get more specific questions. As an example, for a Javascript Engineer role, you may be asked: What is hoisting in Javascript?

Questions like that rely heavily on experience, and are often harder to hack or learn in a short period of time. For these, google.com is key -- it's pretty easy to find a quick and dirty list of Must Know Data Engineering Interview Questions and to do a few quick passes.

For these lists of questions, since the answers are pretty short, the best way to study might be flash-card style. There are tons of flash-card applications online. Or you could pull in a friend to conduct a mock interview. Speaking of which:

Mock Interviews Are Key

Conducting mock interviews is one of the most effective ways to prepare for the real thing. The more closely you can simulate an actual interview experience, the better off you'll be when it counts. Here are some tips on getting the most out of mock interviews:

Mirror the Format

Structure your practice interviews to match the format you'll face. If it's a technical phone screen, have a friend call you and ask coding questions. For onsite whiteboard sessions, stand at a board with a marker and work through algorithms.

Mock interviews help you practice thinking and communicating under pressure. The environment should resemble the real deal.

Use Real Interview Questions

When possible, have your interviewer ask genuine questions from real interviews at your target companies. Practicing with real questions in a mock setting builds muscle memory for the concepts you'll encounter. Don't spill the questions ahead of time though! Simulate working through them cold.

Receive Feedback

Ask your mock interviewer to provide detailed feedback on your performance. Were you able to explain your approach clearly? Did you miss any edge cases in your code? Could your coding style be improved?

Use this feedback to shore up your weaknesses before the live interview. Have the interviewer focus on aspects you want to improve, like communication skills.

Treat it Seriously

Take the mock interview as seriously as you would the real thing. Don't dismiss mistakes you make - reflect on them. Let yourself feel some pressure and use it as a growth experience.

Putting effort into practice interviews ensures you gain maximum value from the experience. Treat each one like a genuine test of your abilities.

How Do I Actually Approach the Problem?

You've made it all this way, and are now ready for the interview! So you know how to prepare, but let's get into the actual problems. Check out our guide to approaching the interview problem for a great next step.

One Pager Cheat Sheet

• This tutorial provides a comprehensive guide on timing and what to focus on when preparing for a technical interview, so you can go in with confidence and avoid wasting time.
• A new bootcamp grad could need 3-6 months of prep, while a low-level Senior Systems Engineer may only need 1-2 weeks to become fully prepared for a whiteboard technical interview.
• By dedicating up to 30 minutes of trying to solve a coding problem, looking at hints, stopping when stuck and trying again, rewriting and re-solving the problem in another language, and checking your progress at regular intervals, you can effectively prepare for coding interviews.
• For a software engineering job, you must know Big O notation and key data structure and algorithm topics, such as Hashtables, Stacks/Queues, Linked Lists, Trees, Graphs; and basic math and programming language and object-oriented design and systems design knowledge.
• For those looking to prepare for coding interviews, AlgoDaily, Leetcode, HackerRank, TopCoder, GeeksForGeeks, Tushar Roy's Youtube Channel, MyCodeSchool Channel, The CS Dojo Channel and a few recommended books are key resources.
• Preparing for specialized roles through research and flash-carding can help when asking more experienced questions during an interview.
• Doing mock interviews, either with a friend or using a platform such as pramp.com, is essential for preparing for the actual interview.
• For a successful coding interview, check out the guide to approaching the interview problem.