Patternwise: Stop Grinding. Start Learning Patterns. Your Open-Source AI Interview Coach.

Harsh Tuli — Sun, 04 Oct 2026 10:30:39 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Patternwise is a DSA and System Design practice workspace with an AI interview coach built on open-weight Gemma models. It answers one question every morning:

"Given everything I've practised so far, what should I learn, revise, or practise today?"

I built it for Nikhil, a friend from my office who recently started preparing for interviews.

When he started, he jumped between multiple websites and couldn't keep track of his progress across them. Some sites only cover DSA, others only System Design, but today's interviews expect both. And even within one site, a list of hundreds of problems tells you what you've done, not what to do next: Is sliding window still weak? Should I learn something new, or redo what I failed last week? It never tells you to stop.

So I built one place for both DSA and System Design (HLD and LLD), with an AI coach on top that looks at everything he's practised and tells him what to work on today. Now he can just open it and practise.

Patternwise does three things:

Tracks practice by pattern, not by problem. There are 27 topics, 112 patterns and 364 curated LeetCode problems, plus 77 System Design concepts, 35 HLD/LLD patterns and 34 design problems. Every attempt records the result (solved, needed hints, failed), confidence, time, and your own mistake notes.
Computes what matters today, with a deterministic recommendation engine. Each pattern gets an explainable priority built from six signals: weakness, revisions due, time since practice, interview importance, variation coverage and recent trend.
Coaches you through it with Gemma. The model explains the plan using your own data, answers "why do I keep failing this?", gives progressive hints without spoiling the solution, checks your explanations, and plays a realistic interviewer that asks follow-up questions instead of teaching.

The feature I'm proudest of: the coach knows when not to give you another problem. If you keep failing the same idea across different problems, it says so:

Don't solve another problem yet. You've struggled with Variable Window: Longest Valid on 4 different problems recently. Spend 10 minutes on the invariant, then try one guided problem.

That's the difference between a coach and a problem generator.

Demo

🔗 Live: https://patternwise.onrender.com · password: patternwise-demo

The demo account has three weeks of realistic practice history: strong hashing, a sliding-window pattern that keeps going wrong, an overdue binary search, and a System Design concept with slipping ratings. That way you can see the coach react to real signals. Try:

AI Coach → Today's Plan: the priority badge shows exactly how each score was calculated.
Ask Coach: "Why do I keep struggling with sliding window?" The answer quotes the mistake notes from the history.
Interview Mode → System Design → Design a URL Shortener: answer a few questions, then End & get feedback.

Code

452Harsh / patternwise

Pattern-first DSA preparation workspace: curated curriculum, spaced-repetition revision and progress analytics (Next.js + MongoDB)

Patternwise

A personal, pattern-first preparation workspace for DSA (data structures and algorithms) and System Design (HLD and LLD). It combines a curated curriculum with a tracker built around recognition, spaced-repetition revision, daily plans, notes, workspaces and analytics, plus an AI interview coach that runs on open-weight models and answers: "Given everything I've practised, what should I do today?"

It's built with Next.js 16, React 19 and TypeScript, styled with Tailwind CSS v4 and shadcn/ui on Base UI, and stores data in MongoDB. It's a single-user app that you sign in to with a password.

Why

Most practice tracking is a checklist of problems. Patternwise is organised around the pattern instead: how to recognise it, the core idea, a template, variations, pitfalls and where else it applies. Every solve, review and note feeds a spaced-repetition schedule, so things you're shaky on come back before you forget them. System Design gets the…

View on GitHub

How I Built It

Stack: Next.js 16 (App Router), React 19, TypeScript, Tailwind v4 and shadcn/ui; MongoDB Atlas (data plus vector search); deployed on Render.

Open-source AI:

Role	Model	Where it runs
Coaching, hints, interviewer	Gemma 4 26B-A4B	Google AI Studio (production)
Same, fully local	Gemma 4 E2B (QAT, 4.3 GB)	Ollama on my 8 GB M1, about 28 tokens/s
Retrieval embeddings	EmbeddingGemma (768-d)	Hugging Face Inference (production) or Ollama (local)

The rule that shaped everything: the engine decides, the model explains

Small open models are good at explanation and dialogue. They're bad at arithmetic over a user's history, and they'll happily invent "you've solved 12 sliding-window problems". So I split the work:

The engine (lib/coach/) is plain, pure TypeScript and fully tested:

For each pattern it computes success over the last 21 days (hints count half), failures, confidence, due reviews, staleness, per-difficulty results, and variation coverage. Every curated problem teaches one variation, so "10 solved but only 1 variation" is detectable.
From those facts it picks an action (review the concept, revise, strengthen, broaden, level up, learn) and a difficulty move (harder, easier, back to fundamentals).
For System Design it also spots concepts you studied but never applied in a design problem.
The stop rule fires on 3+ shaky attempts across 2+ problems with mostly failed recent attempts. Then it recommends one guided problem, not five more.

Gemma gets those facts as structured text, plus retrieved curriculum. It runs under strict rules: every user-specific claim must come from the supplied data, and if the data doesn't say, it says it doesn't know. The server recomputes all facts from MongoDB on every request, so the browser can't feed the model made-up stats.

RAG on MongoDB Atlas Vector Search:

Indexing: 649 curriculum documents are embedded with EmbeddingGemma (patterns with signals, templates and pitfalls; problems; HLD/LLD concepts, patterns and problems). They live in a knowledge collection with a knowledge_vector index filtered by module.
Search quality: retrieval maps unseen problems to the right pattern. "Longest substring without repeating characters" lands on Variable Window, and "sorted rotated array minimum" lands on Rotated Binary Search.
Fallbacks: if the Atlas index isn't ready it falls back to in-memory cosine, and if the embedding model is down it falls back to keyword search. The coach never just breaks.

DSA and System Design stay separate. Every coach request is scoped to one module, so a System Design answer never drags in your DSA history, and vice versa.

It closes the loop. Interview results, "explain it back" scores, and practice logged anywhere in the app feed straight back into tomorrow's plan.

Things I had to solve:

Gemma 4's inline reasoning: on Google's endpoint it always streams its reasoning as <thought>…</thought>, and switching that off isn't supported for this model. I wrote a small stream filter that drops the block, even when a tag is split across chunks, and adds token headroom so the answer isn't cut short.
Different embedding vectors: EmbeddingGemma from Ollama and from Hugging Face produce different vectors for the same text (cosine ≈ 0.71). The indexer records which embedding model built the index and flags "index needed" when the provider changes.
Testing the engine: 34 checks cover the stop rule, revision priority, difficulty moves, time budgets, and that SD data never leaks into DSA. They run in GitHub Actions CI on every push, alongside lint, type-checking, curriculum integrity checks and the production build.

Why Does Open Innovation Matter?

For an interview coach, open models aren't a philosophy point. They decide who can use it.

It runs on a laptop, for free. The exact same coach runs on Gemma 4 E2B through Ollama on an 8 GB MacBook Air, with EmbeddingGemma for search and MongoDB on localhost: no API keys, no bill. A config switch moves it over, and I checked that while it answers, the app, database and model make zero connections outside localhost (it's in the video at 2:45). Anyone who can't afford a paid prep subscription gets the same coach.
Your preparation data stays yours. Your failures, mistake notes and mock-interview debriefs are personal. With a local model they never leave your machine. Even in the hosted version, the vector store holds only curriculum content; progress and conversations are never indexed.
Swapping models is a config change, not a rewrite. All model calls go through a tiny provider interface. I developed on Gemma 4 E2B locally, deployed on Gemma 4 26B-A4B, and could point it at a GPU server running E4B or 31B by changing two environment variables. No vendor lock-in, no rewrite when pricing or terms change.
The open model made the honest design possible. Because I control the model and the prompt pipeline end to end, I could put a deterministic engine in charge and give Gemma a clear, checkable job. That's why every number on the screen has an explanation behind it.
Open models keep it free to run. Open Gemma on free tiers, MongoDB Atlas and Render keep running costs at about zero. A closed API would turn a personal study tool into a monthly bill.

What Nikhil said after trying it:

"Honestly, I really liked the concept behind [Patternwise]. Instead of just solving hundreds of random DSA questions, it focuses more on understanding the patterns. I feel that once you know the pattern, you can approach and solve a lot of different questions on your own, rather than just remembering solutions.

I also liked the way the preparation is structured with a proper timeline, so it's easier to know what to focus on and when. The System Design part is also really helpful because it covers both LLD and HLD. Overall, I think it's a much more practical way to prepare for interviews instead of just going through a huge list of problems."

That's exactly the shift I was going for: from how many problems have I solved? to which patterns do I actually understand?

My Agent Session

I built Patternwise with an AI coding agent, Claude Code, as my pair programmer. I set the direction: what Nikhil needed, the features, the design decisions, and what to cut. I also tested every step in the browser. The agent wrote and refactored most of the code with me, ran the checks, and debugged the issues we hit along the way, like Gemma 4's inline reasoning tags and the embedding mismatch between Ollama and Hugging Face.

Prize Categories

Best Use of Gemma: Gemma 4 26B-A4B powers all coaching, hints and interviews in production; Gemma 4 E2B runs the same app fully locally; EmbeddingGemma powers retrieval.
Best Use of Render: the whole app (the coach's front end and API) is deployed on Render as a Blueprint (render.yaml). The repo also includes an optional Render Blueprint that self-hosts Gemma via Ollama behind a key-checking proxy (deploy/render-ollama).
Best Use of MongoDB Atlas: Atlas is the data layer for all progress, sessions and plans, and Atlas Vector Search retrieves the curriculum for every grounded answer.
Best Use of ElevenLabs: the demo video's narration is generated with ElevenLabs (voice "Eric"), split per scene and timed to the footage.
Best Use of GitHub Copilot: GitHub Actions CI runs lint, type-checking, curriculum integrity, the 34 coach-engine checks and the production build on every push, plus a weekly job that re-verifies all 364 LeetCode links.

DEV Community: Harsh Tuli