Expora IconExpora

Coding Interview PatternsThe 7 That Cover 90% of InterviewsLearn the trigger, not the solution.

90% of coding interview problems reduce to 7 structural patterns. Once you recognize which pattern applies, the algorithm follows. Expora shows each pattern executing step by step — pause at any state, run your own code, and build the trigger recognition that transfers to problems you have never seen before.

The problem with grinding LeetCode

Why pattern recognition breaks under interview pressure

Knowing the pattern name is not the same as knowing when to use it.

You recognize the pattern after reading the editorial — not before

Seeing "sliding window" in the solution title and thinking "I knew that" is not pattern recognition. The skill that matters is identifying the trigger from the problem statement alone, before you have seen the approach.

You know the pattern name but not the structural trigger

Most developers who have done LeetCode can name the patterns. Fewer can articulate the structural signal that distinguishes "use sliding window" from "use two pointers" when the input is a sorted array of integers. The trigger is the learnable part.

You solved the LeetCode version but freeze on the interview variant

Interview problems are variations with added constraints. If you memorized the solution to Minimum Window Substring, a slightly different constraint breaks the memory. If you understood the sliding window pattern, any variation is a small adjustment to a known shape.

You explain the code, not the pattern

Interviewers ask "why did you choose a queue here?" not "does your code pass?" The answer they want is the structural reason — "I need shortest path in an unweighted graph, BFS guarantees I reach each node at minimum distance first." That reasoning comes from pattern understanding, not solution memorization.

The 7 core coding interview patterns

Each pattern has a structural trigger. Learn the trigger and the algorithm follows.

01

Sliding Window

Use when: Contiguous subarray or substring with an optimization goal (max, min, exact count)

Core: Two indices (left, right) + a running state — sum, count, or frequency map

Minimum Window Substring, Longest Substring Without Repeating Characters, Max Sum Subarray of Size K

02

Two Pointers

Use when: Sorted array, find a pair or triplet, or partition elements in place

Core: Left pointer at start, right pointer at end — converge toward the middle

Two Sum II, Container With Most Water, 3Sum

03

BFS

Use when: Shortest path in an unweighted graph, or level-by-level tree traversal

Core: Queue (FIFO) + visited set — process all nodes at distance d before d+1

Binary Tree Level Order, Word Ladder, Rotting Oranges

04

DFS / Backtracking

Use when: Explore all paths, generate combinations or permutations, detect cycles

Core: Recursive call stack + visited set — undo the last choice when backtracking

Number of Islands, Combination Sum, N-Queens

05

Binary Search

Use when: Sorted input — find a target or a boundary condition in O(log n)

Core: lo/hi pointers — eliminate half the search space at each step

Search in Rotated Sorted Array, Find Minimum in Rotated Array, Koko Eating Bananas

06

Dynamic Programming

Use when: Overlapping subproblems with optimal substructure — maximize or minimize a value

Core: 1D or 2D dp array — fill cells in dependency order, reuse solved subproblems

Climbing Stairs, Longest Common Subsequence, Coin Change

07

Dijkstra

Use when: Weighted graph — minimum cost path from a source to all other nodes

Core: Min-heap (priority queue) + dist array — relax edges greedily by current best cost

Network Delay Time, Cheapest Flights Within K Stops, Path With Minimum Effort

How Expora teaches patterns, not solutions

From passive watching to active pattern recognition — with your own code.

Without Expora

  • Memorizing individual solutions that break on interview variants
  • Recognizing the pattern only after reading the editorial
  • Explaining what the code does, not why the pattern was chosen
  • Starting from zero on every problem that looks slightly different

With Expora

  • Structural trigger recognition before writing a single line
  • Visual execution of each pattern — pause, inspect, step back
  • Your own code runs through the same visual engine as the reference
  • Pattern intuition that transfers to any variation of the problem
Step 1

Pick a pattern (Sliding Window, BFS, DFS, DP, Binary Search, Two Pointers, Dijkstra) and run the reference implementation step by step — state, pointers, and data structures visible at every step.

Step 2

Study the trigger: pause at the decision points and see exactly what condition caused the window to shrink, the pointer to move, or the distance to update. Connect the structural signal to the algorithmic response.

Step 3

Switch to your own code: paste your solution and run it through the same visual engine. See where your execution diverges from the reference. The visual makes the bug immediately obvious.

Step 4

Move to the next variation. The pattern is already internalized — you adjust one structural piece instead of starting from scratch. Intuition compounds across every problem.

The difference between
solving and understanding.

LeetCode trains speed. Expora trains understanding. Our interactive visual debuggers show every step—state, pointers, and decisions—so you build intuition you can reuse across problems. Visual comprehension is 3× faster than reading static code.

From static code to
visual understanding.

Static solutions hide the “why.” Expora makes execution visible: step-by-step traces, live state, and clear transitions between steps. Learn from a reference implementation, then switch to your own code and watch the same visuals update in real time.

Learn with a
visual debugger.

Start with a guided reference run, then implement the solution yourself. Run code, step through micro-steps, and see the exact state changes that make the algorithm work—so you can adapt the pattern in real interviews.

two_sum.ts
Connected
1
2
3
4
5
6
7
8
9
10
function twoSum(nums: number[], target: number): number[] {
// Map to store difference -> index
const map = new Map();
 
for (let i = 0; i < nums.length; i++) {
const diff = target - nums[i];
if (map.has(diff)) {
return [map.get(diff), i];
}
map.set(nums[i], i);
}
}
Hash MaptwoSum
keyindex
30
O(n) TimeO(n) Space

Core capabilities for visual learning

Built for coding interview prep: understand patterns by watching real execution. Learn from reference visualizers, then run your own code and see the same visuals update step‑by‑step.

Interactive expandable mental maps

Expand concepts on demand to build intuition fast. See the core idea, invariants, time/space tradeoffs, and common interview variations—organized as a visual model you can reuse.

Visual learning roadmaps

Follow a structured path across arrays, graphs, DP, and more—with prerequisites and progression. Stop random grinding and build a complete mental model that actually transfers to new questions.

Interactive visual debuggers

Step through algorithms with breakpoints, state snapshots, and timelines. Watch pointers, queues/heaps, distances, and decisions evolve—so you understand how it works, not just what it does.

Write, run, and visualize your solution

Implement in your preferred language, run it in‑browser, and see the execution visuals update in real time. Optional: capture problems from sites like LeetCode to bring them into your learning flow.

Expora vs LeetCode vs NeetCode:
Solve vs Understand

Capability
Expora
LeetCode
NeetCode
Interactive visual debugger (step-by-step execution + state)
Partial
Reference implementation + “write your own” (same visuals)
Algorithm visualizers library (graphs, DP, DS, sorting, etc.)
Interactive mental maps (intuition, invariants, tradeoffs)
Structured learning roadmaps + prerequisites
Partial
Run code in-browser
Learning hub (references, interview tips, getting unstuck)
Partial
Partial
Capture/import problems (optional)
AI generates diagrams from code

Stop memorizing.
Start visualizing.

Don't just solve LeetCode problems blindly. Expora transforms complex algorithms into interactive mental maps and step-by-step animations, making comprehension 3× faster and intuitive.

Learn more

Trusted by engineers and educators

Expora helps people prepare for coding interviews by turning algorithms into interactive visual execution—so understanding is fast, repeatable, and easy to explain.

"The visual debugger makes graph algorithms explainable. I can see every state change and articulate the “why” behind each step—exactly what technical interviews reward."

— Maria· Backend Engineer

"We use Expora to align on shared mental models. Reference visualizers plus step-by-step execution traces reduce back-and-forth and speed up onboarding across the team."

— Alex· Engineering Lead

"State snapshots and step controls turn abstract logic into something reviewable. It’s easier to teach, easier to debug, and easier to document—without relying on long walls of text."

— Sara· Software Engineer

Built for how you learn—and how teams teach

Interview prep, onboarding, and education all share the same bottleneck: understanding execution. Expora makes it visible.

Interview candidates

  • Algorithm visualizers across core patterns
  • Reference runs + “write your own” mode
  • Interactive visual debugging (state + step controls)

Engineering teams

  • Shared mental models for complex logic
  • Faster onboarding with execution visuals
  • Clearer reviews and documentation (less back-and-forth)

Bootcamps & education

  • Teach with interactive visual execution
  • Structured roadmaps + prerequisites
  • Objective assessments using step-by-step traces

Pricing plans to help your learning grow

You have your next interview goal, we have your next plan.

Free

Start learning visually

$0

No cost. No catch.

Up to 3 visualizers

  • Binary Search, Bubble Sort & DFS
  • Step-by-step algorithm animations
  • 1 user
  • Chrome Extension problem capture
  • Basic learning roadmaps
  • 24/7 community support

Pro 6 months

Interview prep in one sprint

$99for 6 months

Billed once. No subscription.

Equivalent to $16.50/mo

Full access for 6 months

  • All algorithm visualizers
  • Interactive mental maps + visual roadmaps
  • Step-by-step animations + code runner (Judge0)
  • Chrome Extension capture
  • Unlimited visualizers
  • API Access
  • Priority access during beta

Pro 12 months

Best value for your timeline

$160for 12 months

Billed once. No subscription.

Equivalent to $13.33/mo

Full access for 12 months

  • ← Everything in Pro 6 months, plus...
  • Everything in Pro 6 months
  • New algorithms added regularly
  • Longest runway for interview prep
  • Early access to new features
  • Priority support
GDPR compliantOne-time payment (no monthly subscription)

Local-first

Your vault is yours. Optional secure sync.

Encryption in transit & at rest

TLS 1.2+ · AES-256 for synced data.

GDPR

Minimal processing and easy export.

FAQ

Coding interview patterns: common questions

What they are, how many you need, and how to recognize which one to use.

Secure authentication (Clerk) + encrypted transport
Run code online via Judge0 (sandboxed execution)
Direct product support during beta
Coding interview patterns are the 7-10 structural templates that cover the vast majority of FAANG-style problems. Instead of memorizing hundreds of individual solutions, you learn the structural trigger for each pattern — the signal in the problem that tells you which data structure and algorithm to reach for. Knowing which pattern applies is worth more than knowing 200 individual solutions.

Still unsure?

hello@expora.io

Explore more

Talk with our team

Still unsure? Reach out at hello@expora.io

Or join the waitlist and we’ll keep you updated on launch and beta access.

Ready to understand algorithms, not just solve them?

Join the whitelist and transform how you learn. Mental maps, roadmaps and animations make comprehension 3× faster.