DEV Community: Nithin Pradeep

I Built an AI System Design Coach — Clone It, Try It, Break It

Nithin Pradeep — Sun, 14 Jun 2026 10:22:52 +0000

The problem I kept running into

Every time I practiced system design, I'd hit the same wall: I'd sketch out a rough idea for "design WhatsApp" or "build a URL shortener," and then... nothing. No feedback. No indication if my choice of Kafka over RabbitMQ was justified or just cargo-culting. No one to ask "hey, what's your latency requirement?"

Real interviews have a human who prods you with the right questions. Solo practice doesn't. I built Arcwise to fix that.

What Arcwise does

Arcwise is an open-source, AI-powered system design coach. Drop in any problem, and it walks you through the full design process — just like a real interview session.

Here's the flow:

Describe ──▶ Clarify ──▶ Design ──▶ Refine ──▶ Review

Describe — Enter "Design a ride-sharing platform like Uber" or pick from built-in problems (WhatsApp, Twitter, Netflix, YouTube...)
Clarify — The AI asks 5 targeted questions: expected traffic, consistency model, latency targets, geographic scope, key constraints
Design — Based on your answers, it generates a live Mermaid architecture diagram
Refine — Chat with it: "add a caching layer", "swap to eventual consistency", "how would I handle 10M daily active users?"
Review — Get a scored breakdown across 5 dimensions (1–10 each)

Score Dimension	What it measures
`functional_coverage`	Are all core requirements addressed?
`nfr_handling`	Scale, latency, availability
`component_justification`	Are tech choices explained and appropriate?
`tradeoff_awareness`	Does the design reason about tradeoffs?
`overall`	Holistic design quality

No hand-wavy "looks good!" — actual structured feedback on what you missed.

The stack (for the curious)

I wanted this to be a real production-quality project, not a toy demo:

Layer	Tech
AI	LiteLLM — swap between Claude, GPT-4o, Gemini, Groq, or local Ollama from Settings
Backend	FastAPI · Pydantic v2 · SSE streaming · PostgreSQL (async SQLAlchemy)
Frontend	Next.js 16 App Router · React 19 · TypeScript · Zustand
Diagrams	Mermaid.js (live DSL rendering — edit the diagram directly or via chat)
Auth	JWT · bcrypt · GitHub OAuth · Google OAuth · SMTP password reset
Infra	Docker Compose · optional Redis session store

One thing I'm especially happy with: LiteLLM as the AI abstraction layer. You set your key in .env and the whole thing works — switch from Claude to GPT-4o to a local Llama3 model without touching a line of code.

Try it in 3 commands

git clone https://github.com/nithiin7/arcwise.git
cd arcwise
echo "ANTHROPIC_API_KEY=sk-ant-..." > backend/.env
docker compose up

Open http://localhost:3000. Done. No account required to start — auth is optional and off by default.

Prefer a different model? Set OPENAI_API_KEY, GEMINI_API_KEY, or GROQ_API_KEY instead (or all of them) and switch from the Settings page.

What I learned building this

Streaming UX matters more than I expected. When the diagram generates token by token and you see it appear in real time, it feels alive. Buffering the whole response and dumping it at once felt dead in comparison. SSE streaming from FastAPI to Next.js was worth the extra plumbing.

Mermaid.js is underrated. Everyone reaches for D3 or a graph library when they need diagrams. Mermaid gives you a clean DSL that an LLM can generate directly — no coordinate math, no node positioning. The diagram is just a string. That means the AI can edit it through chat without any special graph manipulation logic.

Multi-model by default was the right call. I started hardcoded to Claude, then added a ModelSelect component and LiteLLM routing. The moment local Ollama worked — fully offline, free, no API key — it changed the feel of the whole project. It's not just a Claude wrapper anymore.

What's next (and where you come in)

I have ideas, but I want to build what's actually useful:

Export to PDF / PNG — shareable artifacts for interviews
Timed interview mode — 45-minute countdown with hints disabled
Community problem library — upvote/submit design problems
Diagram diff view — show what changed between refinement rounds
Team mode — collaborate on a design in real time

If any of these resonate with you — or you have a completely different idea — open an issue or drop a comment below. I read everything.

I Built a Free, Fully Local AI Resume Builder — No Subscriptions, No Cloud, No Catch

Nithin Pradeep — Thu, 11 Jun 2026 03:39:16 +0000

If you've ever tried to use an AI resume builder, you've probably hit the same wall I did.

You sign up, poke around, find the one feature you actually need — and then boom: "Upgrade to Pro for $29/month."

It's frustrating. Resume help shouldn't be locked behind a paywall.

So I built my own.

Meet Persona

Persona is an AI-powered resume builder that you run completely on your own machine. No deployment required. No subscription. No account on some third-party service. You clone the repo, set it up, and it's yours.

It's a fork of the excellent open-source project ResumeLM, but I've added a bunch of features I couldn't find anywhere else — especially around local AI and template variety.

👉 GitHub: github.com/nithiin7/persona (Drop a ⭐ if you find it useful!)

The Big Deal: Run AI Completely Offline with Ollama

This is the feature I'm most proud of.

Most AI resume tools call out to OpenAI or Anthropic and charge you for every request. Persona supports Ollama — which means you can run the AI model locally on your own hardware, with zero API costs and zero data leaving your machine.

Here's how simple it is:

Install Ollama on your computer
Pull any model (ollama pull llama3, for example)
Open Persona's settings, point it to your local Ollama URL
Done — the AI now runs entirely on your machine

No OpenAI key. No Anthropic key. No usage limits. Your resume data never touches an external server.

If you do want to use cloud models, Persona supports those too — GPT-5, Claude Opus 4.7, Claude Sonnet 4.6, and a handful of open-source models via OpenRouter. But the Ollama path is what makes this genuinely different from everything else out there.

It's 100% Free — Everything Unlocked

The original ResumeLM had Stripe payments baked in. I ripped all of that out.

Every single feature in Persona is available to every user, always. There's no "Pro plan." There's no feature gating. You self-host it, you own it, you use all of it.

10 Resume Templates

Persona ships with ten distinct templates:

Classic — clean, ATS-safe, traditional
Modern — contemporary layout with a fresh feel
Minimal — stripped back, lots of whitespace
Professional — polished and corporate-ready
Creative — for designers and non-traditional roles
Executive — senior-level presence
Tech — built for software engineers
Academic — research, publications, academia
Bold — makes an impression
Elegant — refined and sophisticated

Each template is fully customizable — you can tweak font size, line height, margins, and spacing at a per-section level right inside the editor.

What the Editor Actually Looks Like

The editor is a three-panel layout:

Left panel — form-based editor for all your resume sections (work experience, education, skills, projects, certifications)
Center panel — live PDF preview that updates as you type
Right panel — AI chat assistant you can talk to directly

You can ask the AI to rewrite a bullet point, suggest better phrasing, tailor your experience for a specific job description, or generate an entire professional summary from scratch. It all happens inline.

There's also a resume score panel that evaluates your resume and gives you actionable feedback, and a cover letter generator baked right in.

Job Tailoring That Actually Works

One of the most useful features: paste in a job description, and Persona will tailor your resume specifically for that role. It reshuffles and rewrites your bullet points to match the language and priorities of the job posting.

ATS systems score resumes based on keyword matching, and most people don't realize their generic resume is getting filtered out before a human ever sees it. Persona helps you fix that.

Export to PDF or Word

When you're done, export your resume as a PDF or a .docx Word file. Both are properly formatted and ready to submit.

Getting Started

git clone https://github.com/nithiin7/persona
cd persona
cp .env.example .env
pnpm install
pnpm dev

Fill in .env with your API keys (or just point it at Ollama and skip the keys entirely). That's it. The app runs locally at localhost:3000.

Full setup instructions are in the README.

Why I Built This

I was job hunting. I wanted an AI tool to help me tailor my resume for each application, but I didn't want to pay $30/month for something that might get deprecated in six months, and I definitely didn't want to upload my personal details to some SaaS I'd never heard of.

So I took an open-source base, added Ollama support, expanded the templates, removed the paywall, and ended up with something I actually use.

If you're in the same boat — job searching, privacy-conscious, or just tired of subscriptions — give it a try.

The Stack (for the curious)

Next.js 15 (App Router)
React 19
TypeScript
Supabase (local auth + database)
Vercel AI SDK (model abstraction layer)
Ollama (local LLM support)
Tailwind CSS + Shadcn UI
@react-pdf/renderer (PDF generation)

If you find it useful, a ⭐ on GitHub goes a long way — it helps other people discover it when they're searching for the same thing you were.

👉 github.com/nithiin7/persona

Thanks for reading. Happy job hunting.

I Got Tired of Reading Strangers’ Codebases, So I Built an AI That Reads Them For Me

Nithin Pradeep — Mon, 08 Jun 2026 14:52:08 +0000

Every developer knows this feeling: you open a repo you've never seen before — maybe for a new job, a contribution, an audit, or just curiosity — and you're suddenly playing detective. Cmd+Shift+F for a function name. Scrolling through a 2,000-line file trying to figure out who calls what. Reading a README that was last updated two major versions ago.

It's not that the code is badly written. It's that understanding a codebase is fundamentally different from reading it. You don't need every line — you need answers to questions like:

"How does authentication actually work here?"
"Where would I add a new API route?"
"What does this PR change, and is it risky?"
"Which files would break if I touched this module?"

So I built CodeLens — a tool that lets you paste a GitHub or Bitbucket URL and just ask the codebase those questions in plain English, with streaming answers grounded in the actual source.

What it does

The flow is intentionally dead simple:

Paste a repo URL. CodeLens clones it and indexes every source file into a vector store using syntax-aware chunking (tree-sitter under the hood, so it understands the difference between a function and a comment block).
Open the chat. Ask anything — "Where are the database models defined?", "How is rate limiting implemented?", "What does the hybrid_retriever do?" — and get a streamed, source-cited answer.
Go deeper than chat. Browse symbols, search code semantically, visualize the dependency graph, or get a health summary — all without leaving the repo you just indexed.

It's basically a research assistant that has actually read the whole codebase before you ask your first question.

A quick tour of what's inside

Natural language Q&A with streaming answers — Ask anything about the codebase and watch the answer stream token-by-token, with the actual source chunks it pulled from shown alongside.

Local or cloud, your choice — Run it fully offline with Ollama (zero data leaves your machine), or switch to Claude, OpenAI, Groq, or Gemini per chat session. Helpful when you're working with a sensitive private repo and want to keep everything local.

Semantic code search — Search by intent, not keyword. "Where do we handle file uploads?" finds the right code even if the function is named process_attachment.

Symbol navigator — Every function, class, and method extracted via AST, filterable by kind, with a one-click jump straight into a chat about that symbol.

Dependency map — An interactive force-directed graph of module-level imports, so you can actually see how a codebase is wired together instead of guessing from import statements.

Repo health summary — Complexity hotspots, TODO/FIXME/HACK locations, and a rough test-coverage estimate, generated automatically from the indexed code.

PR & diff analysis — Paste a GitHub PR URL or a commit SHA and ask "what does this change?" or "what could break?" — useful for reviewing other people's PRs or getting up to speed on what just landed on main.

Cross-repo comparison — Index multiple repos and ask comparative questions in a single chat (e.g. "how does this project's auth differ from that one's?").

Private repos, securely — Pass a GitHub PAT directly in the UI; it's never persisted server-side.

How it's built (for the curious)

Under the hood it's a fairly standard but carefully tuned RAG pipeline:

FastAPI backend serving everything over REST + Server-Sent Events for token streaming
LlamaIndex orchestrates the RAG pipeline, with a tree-sitter–backed CodeSplitter for syntax-aware chunking across Python, TypeScript, JavaScript, Go, Java, and more
ChromaDB as the vector store, persisted per repo
A hybrid BM25 + vector retriever with optional cross-encoder reranking, so answers are grounded in the most relevant chunks rather than just the most semantically similar ones
SQLite via SQLModel for relational data — repos, chats, messages, extracted symbols, dependency edges
Next.js 16 + TypeScript + Tailwind + shadcn/ui on the frontend, with TanStack Query handling all server state and native EventSource for the SSE streams

Nothing exotic — just a pipeline built to actually be useful for code, where structure and relationships matter more than they do for prose.

Try it yourself

It's open source (MIT licensed) and runs with a single command via Docker:

git clone https://github.com/nithiin7/repo-chat.git
cd repo-chat
cp backend/.env.example backend/.env   # add cloud API keys if you want CLOUD mode
docker compose up --build

Open http://localhost:3000, paste in any public GitHub repo URL, and start asking questions. (First run: pull the local model once Ollama's container is up — docker exec -it <ollama-container-id> ollama pull qwen3:4b.)

If you'd rather skip Docker, the manual setup (Python 3.11+ / Node 22+) is just as quick — instructions are in the README.

What's next

I'm actively iterating on retrieval quality, adding more language support to the chunker, and refining the diff/PR analysis flow. If you try it and hit something confusing, broken, or just have an idea for what would make it more useful for your workflow — I want to hear about it.

If you find this useful

⭐ A star on github.com/nithiin7/repo-chat genuinely helps — it's the easiest way to support an open-source side project and helps other developers discover it too.

And if you give it a spin, I'd love to know: what's the first question you asked your codebase?

AI Recipe Generator: Turn Food Photos into Instant Recipes with AI 🍳✨

Nithin Pradeep — Thu, 30 Oct 2025 08:38:42 +0000

Have you ever looked at a dish and wondered, "What's in it — and how can I make it myself?" Introducing the AI Recipe Generator: a project that uses computer vision and AI to analyze any food photo and instantly generate a step-by-step personalized recipe. Upload a picture of your ingredients or a finished dish—get a complete recipe (with cooking steps) in seconds!

Why I Built This

Food recognition and AI have always fascinated me. As a developer, I noticed a gap: plenty of sites offer recipe browsing, but almost none use AI to bridge the gap between your fridge and cooking. What if we could snap a photo and get actionable, tailored recipes—making home cooking easier, smarter, and more fun?

Core Features

Image-Based Recipe Generation: Simply upload a food photo; the AI will suggest what you can cook.
Smart Ingredient Detection: The backend identifies ingredients and even guesses cooking methods.
Personalized Output: Adjust recipes based on diet, cuisine, or available ingredients.
Step-by-Step Instructions: Recipes come with cooking steps, timings, and planned nutritional details.
Recipe Collection: Save and manage your favorite recipes in-app.

Tech Stack

This project is full-stack, leveraging cutting-edge tools for both frontend and backend:

Frontend: Next.js 15 (React), TypeScript, Tailwind CSS, React Query, React Hook Form
Backend: FastAPI (Python), SQLAlchemy, Pydantic, OpenAI/Anthropic AI, Uvicorn
Utilities: Docker, pytest, Alembic (for DB migrations), Vercel & Netlify (deploy)

How It Works

Upload: User uploads a photo (ingredients or finished dish).
Vision-to-Recipe AI: FastAPI backend uses advanced image recognition to detect ingredients and dish types.
Recipe Generation: The backend crafts personalized recipes using AI language models (OpenAI/Anthropic APIs), creating ingredient lists, steps, timing, and difficulty.
Web Interface: The frontend (Next.js) displays the result, lets you customize preferences, and save your recipe library.

Implementation Walkthrough

Project Structure

/frontend: Next.js React app (UI, API clients)
/backend: FastAPI service (AI endpoints, database models)

Getting Started

Clone the repo:

git clone https://github.com/nithiin7/ai-recipe-generator
cd ai-recipe-generator

Run both servers with a single command:

./run-dev.sh

Environment Setup
API and AI keys stored in .env files for backend and frontend.
Docker build scripts for seamless deployment.
Key Endpoints

POST /api/v1/recipes/generate — generate a recipe from an uploaded image.
GET /api/v1/recipes — browse all recipes.
Auth and user-specific features planned for future versions.

Try It Yourself! 🚀

Repo: nithiin7/ai-recipe-generator
Clone, configure your API keys, and run locally or deploy to Vercel/Netlify.
Tinker with the code to add more AI models or expand cuisine coverage!

Takeaways

Building this project taught me:

How to bridge computer vision and language models in real-world web apps
The value of clean API design using FastAPI and TypeScript
The power of Docker for rapid prototyping and deployment

Would love feedback, ideas for improvement, or contributions—let’s cook up some AI magic together!

🚀 How I Built My Developer Portfolio — and What I Learned Along the Way

Nithin Pradeep — Wed, 22 Oct 2025 17:24:05 +0000

When I started building my personal portfolio, I didn’t just want a digital resume — I wanted a reflection of my thought process as a developer. Every component, layout, and animation had a reason behind it.

In this post, I’ll walk you through how I built my portfolio, the tech stack behind it, and lessons learned that can help you create one that feels professional, personal, and performance-focused.

🎯 The Goal

As a software engineer at Paytm Payments Bank, I spend a lot of time thinking about design systems, user flow, and performance. I wanted my portfolio to represent those same values:

Fast and responsive across all devices
Clean and minimal, without unnecessary clutter
Built with reusable and readable code
Easy to update and deploy

It’s live here → Portfolio Website
Codebase → Code Repo

🧱 The Tech Stack

I kept the stack modern but simple:

Next.js → Server-side rendering, static generation, and routing made easy.
TailwindCSS → For clean, responsive, and utility-first styling.
Framer Motion and GSAP → Smooth animations that enhance the user experience.
Vercel → Seamless CI/CD and global hosting with almost no config.
Contentful → For saving and fetching all the data. Dynamically updates the UI with new contents.

Each choice made development faster and more maintainable — no over-engineering, just a clear focus on what mattered.

⚙️ The Building Process

Inspiration I explored numerous websites on Awwwards to gather ideas and inspiration for my own design. I was particularly inspired by Huy Nguyen’s work, his use of color, layout, and clean animations really stood out to me. Definitely check out his websites!
Structure First, Style Later I began by mapping out the page flow — Home, About, Projects, and Contact — using simple semantic HTML and minimal CSS. Once the layout worked perfectly across viewports, I started layering in Tailwind styles.
Component Reusability Every repeating pattern became a component. For example: A generic ProjectCard to display each project dynamically. A shared Layout component for SEO and structure consistency. This kept the code DRY and made future updates painless.
Animations with Purpose Animations are subtle but intentional. For instance: Fade-ins for project cards as they enter the viewport. Smooth transitions between routes using Framer Motion. Also added Lenis Scroll for the smooth scroll effect. They’re not flashy — just enough to make navigation feel fluid.
Performance Tweaks After deployment, I focused on Lighthouse metrics. Lazy loading images, prefetching links, and compressing assets boosted performance significantly. My load time dropped by almost 40%.

🧠 Lessons Learned (That Might Help You)

Start simple. You don’t need every fancy library. Build the structure first — polish later.
Think scalability. Even for a small site, proper folder structure and reusable components matter.
Add personality. Your portfolio shouldn’t feel like a template — write in your voice, include your hobbies, and make it uniquely yours.
Performance matters. Recruiters may not say it, but they notice smooth, fast interactions.
Version control early. Track every iteration; it helps when revisiting design or debugging.

🏁 Final Thoughts

If you’re building your own portfolio:

Treat it as both a learning project and a personal brand.
Don’t overthink perfection — it’ll evolve as you do.
Add something that gives back — like a blog, guide, or open-source snippets.

Here’s mine again if you’d like to explore it:
👉 portfolio-nithin.vercel.app

I’d love to see what you’ve built too — share your portfolio links in the comments, and let’s connect!

DEV Community: Nithin Pradeep

I Built an AI System Design Coach — Clone It, Try It, Break It

The problem I kept running into

What Arcwise does

The stack (for the curious)

Try it in 3 commands

What I learned building this

What's next (and where you come in)

Links

I Built a Free, Fully Local AI Resume Builder — No Subscriptions, No Cloud, No Catch

Meet Persona

The Big Deal: Run AI Completely Offline with Ollama

It's 100% Free — Everything Unlocked

10 Resume Templates

What the Editor Actually Looks Like

Job Tailoring That Actually Works

Export to PDF or Word

Getting Started

Why I Built This

The Stack (for the curious)

I Got Tired of Reading Strangers’ Codebases, So I Built an AI That Reads Them For Me

What it does

A quick tour of what's inside

How it's built (for the curious)

Try it yourself

What's next

If you find this useful

AI Recipe Generator: Turn Food Photos into Instant Recipes with AI 🍳✨

Why I Built This

Core Features

Tech Stack

How It Works

Implementation Walkthrough

Takeaways

🚀 How I Built My Developer Portfolio — and What I Learned Along the Way

🎯 The Goal

🧱 The Tech Stack

⚙️ The Building Process