Technical interview coaching, with a real plan

Grinding problems alone teaches you some answers. It doesn't teach you to recognize a pattern you've never seen, or explain your thinking while someone watches. That's what we practice.

Book a free intro callSee the ten areas
Portrait of Judson Dunne

I've been through this process myself.

I worked through these same patterns while preparing for interviews, and I secured a job as an Agent Solutions Engineer at Bland.ai, starting in June 2027.

I also build this material into real products. I grew Locava to more than 10,000 users and wrote shortest-path algorithms from scratch for Pathfinder 3D, so when we talk about graphs or heaps, I can show you where they matter.

To be clear: every company runs interviews differently, and no one can guarantee an offer. I also haven't worked as a big tech interviewer. What I offer is structure, repetition and specific feedback.

How we adapt it

First

A diagnostic problem, and what you know about your target process.

Then

A roadmap for your timeline. With two weeks, we focus on your weakest patterns instead of covering all ten.

Throughout

Problems between sessions, reviewed together, and adjustments as your weak spots change.

Ten areas, in an order that builds.

Each one uses the ones before it, which is why heaps come after trees and dynamic programming comes last. Read the full study roadmap.

01Arrays & StringsIndexing, in-place updates, string building and simple scans.
What you'll learn
How to read a problem's constraints and write a clean first pass before reaching for anything clever.
Common patterns
Single scans, prefix sums, in-place swaps.
Sample problems
Reverse a string. Maximum subarray. Merge sorted arrays.
Why it matters
Almost every interview starts here, and small indexing mistakes are what cost people time.
02Hash Maps & SetsFrequency counting, seen-before checks and constant-time lookup.
What you'll learn
When trading a little memory for constant-time lookups turns a slow solution into a fast one.
Common patterns
Frequency maps, seen-before sets, grouping by key.
Sample problems
Find a pair that sums to a target. Group anagrams. Find duplicates.
Why it matters
It's often the first optimization to look for, and interviewers expect you to reach for it.
03Two Pointers & Sliding WindowPointer movement, substrings, subarrays and window optimization.
What you'll learn
How to avoid re-checking work by moving through the input deliberately.
Common patterns
Opposite-end pointers, fast and slow, expanding and shrinking windows.
Sample problems
Longest substring without repeats. Container with most water.
Why it matters
These can turn an obvious O(n²) answer into O(n), and that's a jump worth being able to explain.
04Stacks & QueuesLIFO and FIFO, monotonic stacks and common applications.
What you'll learn
How to recognize when a problem depends on the most recent or oldest item.
Common patterns
Matching pairs, monotonic stacks, queue-based processing.
Sample problems
Valid parentheses. Next greater element. Daily temperatures.
Why it matters
Picking the right structure is often the whole insight, and it's easy to miss under pressure.
05Binary SearchSorted search spaces, boundaries and binary search on answers.
What you'll learn
How to write it without off-by-one bugs, and where it applies beyond sorted arrays.
Common patterns
Lower and upper bounds, rotated arrays, searching the answer space.
Sample problems
Search a rotated array. Minimum speed to finish on time.
Why it matters
It's simple to describe and easy to get wrong, so it shows how carefully you handle boundaries.
06Linked ListsTraversal, pointer updates, reversing lists and cycle detection.
What you'll learn
How to update references carefully without losing part of the list.
Common patterns
Dummy heads, in-place reversal, fast and slow pointers.
Sample problems
Reverse a list. Detect a cycle. Merge two sorted lists.
Why it matters
They test whether you can reason about state one step at a time and handle edge cases.
07Trees & Binary Search TreesBinary trees, traversal orders, recursion and BST properties.
What you'll learn
How to trust recursion, and how to decide what each call should return.
Common patterns
Pre, in and post-order traversal, level order, BST invariants.
Sample problems
Maximum depth. Validate a BST. Lowest common ancestor.
Why it matters
Trees are where many people find out whether recursion has really clicked.
08Heaps & Priority QueuesTop-K problems, scheduling and priority-based selection.
What you'll learn
When you need the current best item, not a fully sorted list.
Common patterns
Top-K, merging sorted inputs, two heaps.
Sample problems
K most frequent elements. Merge K sorted lists. Task scheduling.
Why it matters
Knowing when a heap fits shows that you understand the tradeoffs.
09Graphs & TraversalRepresentations, BFS, DFS, grids, connectivity and ordering.
What you'll learn
How to spot a graph in a problem that doesn't mention one.
Common patterns
Adjacency lists, visited sets, grid traversal, topological ordering.
Sample problems
Number of islands. Course schedule. Shortest path in a grid.
Why it matters
Many problems get simpler once you model them correctly. I wrote shortest-path algorithms from scratch for Pathfinder 3D.
10Recursion, Backtracking & Dynamic ProgrammingSearch trees, choose-and-undo, memoization and state design.
What you'll learn
How to define the state first, so the solution follows from it.
Common patterns
Choose, explore, un-choose. Memoized recursion. Tabulation.
Sample problems
Generate subsets. Word search. Coin change. Longest common subsequence.
Why it matters
These feel hardest and reward a clean mental model more than any other topic.

Across all ten

  • Big-O and complexity analysis
  • Sorting
  • Greedy algorithms
  • Functional programming concepts
  • JavaScript fundamentals
  • Practical debugging
  • Explaining out loud
  • Testing edge cases

We spend the most time on the areas that matter most for you and the roles you're targeting.

The part that problem lists skip.

Clear verbal problem solving

Restating the problem, naming your approach and talking while you code, without losing your thread.

Mock interviews

A timed round run like the real thing, followed by specific feedback on what to change.

Behavioral storytelling

Turning your projects into short stories about a decision you made and what happened.

Practical debugging

Finding a bug in unfamiliar code methodically, out loud, under time pressure.

API and app-building exercises

For roles that ask you to build something instead of solving a puzzle: routes, data and tests.

Your practice roadmap

A plan for your timeline and your target roles, which we adjust as your weak spots change.

What a mock interview looks like.

Here's a typical coding round. If your process is different, like a take-home review or an app-building exercise, we'll practice that instead.

  1. 0:00

    The prompt

    I give you a problem you haven't seen, and you ask clarifying questions as you would with an interviewer.

  2. 0:05

    Your approach

    You describe a first solution and its complexity. If you skip this and start typing, that goes in the feedback.

  3. 0:10

    You code

    You keep talking while you write. I may interrupt, because real interviewers do.

  4. 0:30

    You test it

    You pick the edge cases and trace them yourself before I say anything.

  5. 0:35

    A follow-up

    A changed constraint, like input that doesn't fit in memory, to see how you adapt.

  6. 0:45

    Feedback

    We replay the moments that mattered and write down the one or two things to drill next.

Five sessions, or ten.

DSA Interview Accelerator

Focused practice on the patterns you need most. Candidates who need targeted help.

$375

/ five 60-minute sessions

Initial skill assessment

Personalized prep plan

Guided DSA practice

Curated problems between sessions

Practice explaining your solutions

Final mock interview

Feedback on what to improve

We find your weakest areas and practice the ones that matter most.

Start with the Accelerator

Complete Technical Interview Prep

A structured path through the foundations of technical interviews. Candidates who want to prepare across the major patterns.

$700

/ ten 60-minute sessions

Initial diagnostic

Personalized study roadmap

Ten live sessions

Coverage across the major DSA patterns

Curated practice problems

Between-session exercises

Complexity analysis

Interview communication practice

Two mock interviews within the ten sessions

Final strengths and weaknesses assessment

An independent practice plan

Guided practice and feedback across all the core interview topics.

Start Complete Prep

All prices are for live online sessions. I send payment details after your intro call. Session policies.

Don't need a package? Ask about a single mock interview or targeted coaching on a free intro call.

Frequently asked
questions

Which package should I choose?

If you know which areas you need to work on, start with the Accelerator. If you want to cover all the major patterns, choose Complete Prep. We can talk it through on the intro call.

Are mock interviews included?

Yes. The Accelerator includes one and Complete Prep includes two.

How much time do we spend on each topic?

It depends on you. We spend more time on the areas where you need the most practice.

Which language should I use?

Whichever one you're most comfortable with. Most people use Python, Java or JavaScript, and I'm happy to work on JavaScript specifics.

Will this get me a job?

Nobody can promise that, and you should be careful of anyone who does. Interview processes also differ by company and role, so we'll prepare for the one you're actually facing.

Have you been an interviewer at a big tech company?

No. I recently went through interview preparation myself and secured an engineering role at Bland.ai. If you want a senior interviewer from a specific company, you may also want a mock with one of them.

How does payment work?

I send payment details after your intro call. Single sessions are paid before the session, and packages are paid before the first session.

Got an interview coming up?
Let's make a plan.

Book a Free Intro Call

Free. 15 minutes.