TL;DR: Worth it if you're an intermediate engineer who learns well from written material, has 6+ weeks, and wants coding patterns taught as a sequenced curriculum instead of assembled from videos and forum posts. $79 one-time for 42 patterns, 300+ problems, and solutions in 6 languages is a rounding error against the salary difference an offer represents. Not worth it if you're a true beginner (learn data structures first), a video-first learner (use NeetCode), interviewing in under 3 weeks (use a 75-problem list), or someone who won't actually finish courses (the most common failure mode, and no course fixes it).
Let's start with the awkward part: I created this course. A review of my own product deserves your skepticism, so here's the deal I'll make with you. I'll tell you exactly what you get, quote the real criticisms people make (including the ones on Reddit), name the people who should not give me $79, and point you to free alternatives where they're genuinely the better choice. If by the end this reads like a sales page, close the tab and go use NeetCode's free tier; it's excellent and I say so in detail here.
What Grokking the Coding Interview actually is
Grokking the Coding Interview: Patterns for Coding Questions is a written, interactive course built around one idea: interview problems are not thousands of unique challenges, they're a few dozen underlying patterns wearing different costumes. Instead of grinding problems and hoping the patterns emerge by osmosis, the course teaches each pattern directly, then drills it with escalating problems.
The course today, by the numbers:
- 42 coding patterns (32 common + 10 advanced) across 50 chapters and 669 lessons, from the everyday workhorses to specialty patterns most resources skip entirely
- 300+ hand-picked problems, sequenced within each pattern from "learn the template" to "stretch it"
- Solutions in 6 languages (Python, Java, C++, JavaScript, Go, C#) for every problem
- 751 in-browser playgrounds, so you run and edit code as you read, no setup
- A Test Your Knowledge track near the end: 69 graded problems split into easy (13), medium (52), and hard (4) tiers, so you find your gaps before an interviewer does
- Roughly 90 hours of total study time, with a certificate on completion
- $79 one-time, lifetime access (discounted from $197, or via the Design Gurus all-course subscription)
- Rated 4.6/5 by roughly 63,000 learners, ~188,000 enrolled
The patterns it actually covers
Since "42 patterns" is abstract, here's the concrete list, grouped the way the course builds them:
- Arrays and strings: Two Pointers, Fast & Slow Pointers, Sliding Window, Merge Intervals, Cyclic Sort, Prefix Sum, Hash Maps
- Stacks and queues: Stacks, Monotonic Stack, Monotonic Queue
- Linked lists: In-place Reversal of a Linked List
- Trees and graphs: Tree BFS, Tree DFS, Level Order Traversal, Graphs, Island (Matrix Traversal), Topological Sort, Union Find, Trie
- Search and selection: Modified Binary Search, Top 'K' Elements, K-way Merge, Two Heaps, Ordered Set, Bitwise XOR
- Recursion and DP: Subsets, Backtracking, Greedy Algorithms, 0/1 Knapsack, Fibonacci Numbers, Palindromic Subsequence
- The 10 advanced patterns that separate senior loops from junior ones: Counting, Simulation, Linear Sorting, Meet in the Middle, Serialize & Deserialize, Clone, Articulation Points & Bridges, Segment Tree, Binary Indexed Tree, MO's Algorithm, plus Multi-threaded (its own chapter, rare in interview prep)
Each chapter opens with what I call the pattern's tell: the phrasing in a problem statement that should make you suspect this pattern. If you want to sample the teaching style before paying anything, the free tier includes the introductory lessons, and our free blog deep dives on sliding window and two pointers follow the same structure the course uses.
The case for: what $79 actually buys
1. The pattern taxonomy, installed systematically. Most engineers eventually discover patterns by accident, somewhere around problem 150 of an unstructured grind. The course's entire job is to hand you at problem 1 what the grind teaches at problem 150. That compression is the product: reviewers consistently describe finally seeing why a solution works rather than memorizing that it works. It's the difference we wrote a whole post about in Learn the Patterns, Not the Problems.
2. Sequencing. The 300+ problems aren't a pile, they're a staircase. Each section reuses mental machinery from the previous one, which is why a sequenced 300+ feels lighter than a random 150. Checklists like Blind 75 don't do this, and it's the main structural difference (full comparison: Blind 75 vs NeetCode 150 vs Grokking 75).
3. Text you'll actually use twice. The week before an onsite, nobody re-watches 40 hours of video, but everybody can skim 42 written pattern summaries in an afternoon. Written material is searchable and re-readable at your own speed. This matters more than it sounds: interview prep has a review phase, and video is terrible at it.
4. Six languages. If you interview in Go or C#, most video resources thin out badly. Every problem here ships full solutions in all six.
5. The price shape. $79 once, not a subscription that punishes a slow month. Prep timelines slip; lifetime access means a slipped timeline costs nothing extra.
The case against: the real criticisms
These are the complaints that actually circulate, and my honest response to each.
"It's not free, and free resources are good now." True on both counts. NeetCode's free tier plus a disciplined study plan can absolutely get you hired. What you're paying for is curriculum design and time compression, not access to secret knowledge. If your budget is zero or you're a strong self-organizer, free is a legitimate choice, and I'd rather say that plainly than pretend otherwise.
"There's no video." Correct, it's a written course with interactive code, by design (see point 3 above). If watching someone draw the solution is how ideas click for you, this is a real limitation, not a spin-able one. Use NeetCode, or combine: several readers use this course as the curriculum and NeetCode's free videos as a second explanation when a written solution doesn't land.
"Is this the same course that was on Educative?" Same lineage, different home: the original authors (that's us) moved it to designgurus.io, where it's maintained and expanded. It's now 42 patterns (32 common + 10 advanced) and 300+ problems, roughly double the original's scope. If you did the old version years ago, the delta is substantial but you should skim the free chapter list before repurchasing anything.
"Reddit says just grind LeetCode." Reddit also produced Blind 75, so it half-agrees with me: the argument for any curated list is that random grinding is inefficient. Where I differ with "just grind" is volume-as-strategy: I've interviewed hundreds of candidates at Meta and Microsoft, and the ones who passed weren't the ones with the most problems solved, they were the ones who could map a novel problem onto a known structure calmly. That's a trainable skill, and training it deliberately is the whole course.
"Some problems feel easier than my actual FAANG loop." Fair, especially for Google. The course teaches patterns to full interview depth, but if you're targeting the hardest loops, you should add hard-variation reps in your weak patterns after finishing, plus mock interviews. No course, including mine, replaces mocks in the final two weeks.
Who should NOT buy it
- True beginners. If arrays, hash maps, and recursion are still shaky, a patterns course assumes machinery you don't have yet. Start with Grokking Data Structures or any free DSA foundation first. Buying the patterns course too early wastes it.
- Interviewing in under 3 weeks. You don't have time for 300+ problems. Do a focused 75-problem list; that's exactly why Grokking 75 exists as the compressed version.
- Video-first learners. Covered above; format fit beats content quality.
- Course collectors. If you have three unfinished prep courses, the honest diagnosis is a finishing problem, not a content problem. A fourth course won't fix it; a calendar and mock interviews might.
The math that actually decides it
Strip away everything else and the purchase decision is this: a successful interview outcome at a top company moves annual compensation by tens of thousands of dollars, and even a failed-then-passed-six-months-later cycle costs you half a year of that difference. Against those numbers, any resource that meaningfully raises your pass probability pays for itself hundreds of times over, whether it's this course, a competitor, or a stack of mock interviews. So the real question is never "is $79 a lot", it's "does pattern-first, written, sequenced prep fit how I learn." If yes, this is the strongest version of that approach I know how to build. If no, pick the format that fits and commit to it fully.
Verdict
Worth it for intermediate engineers, text-first learners, 6+ week timelines, and anyone who interviews in Go/C#/C++ or wants a curriculum rather than a checklist. Skip it for beginners, video learners, sub-3-week timelines, and serial course-starters. Rating my own course would be absurd, so I'll leave you with the two numbers that aren't mine: 4.6/5 from ~63,000 learners, and a free tier that costs you nothing to check whether the teaching style fits.
Try before deciding: the free introductory lessons of Grokking the Coding Interview let you judge the format directly. Comparing options first? Read Grokking vs NeetCode for the honest head-to-head.
FAQs
Is Grokking the Coding Interview enough to pass FAANG interviews on its own? For the coding rounds, yes for most companies, with two additions: mock interviews in your final two weeks, and extra hard-variation practice in weak patterns if you're targeting Google-tier loops. It doesn't cover system design or behavioral rounds; those are separate preparations.
How long does the course take to complete? The full curriculum is roughly 90 hours: working 1.5 to 2 hours a day, most learners finish in 8 to 12 weeks. With 6 weeks or less, do the Grokking 75 subset instead; with more time, the full course's extra variations per pattern are what transfer to harder interviews.
Is it better than LeetCode Premium? They're different tools. LeetCode Premium buys you company-tagged problems and more volume; it teaches nothing. Grokking teaches the patterns; it isn't a volume platform. Many candidates finish Grokking, then use free LeetCode (Premium rarely needed) for timed practice.
Does it include system design? No, it's focused entirely on coding patterns. Design Gurus covers that side in Grokking the System Design Interview, which is a separate course and a separate skill.
Is there a cheaper way to get the pattern-first approach? Yes, two: the free tier (introductory lessons) plus our free pattern deep dives on this blog, or Grokking 75, which applies the same philosophy to 75 problems on a 6-week plan. If those work for you and you never buy the full course, that's a fine outcome.