Ignitio ai tutor

homepage of ignitio ai tutor for taking the meme generation request as input.

From Fear to Building: How I Built an AI Learning Platform in 15 Days, Alone, at 19

The Fear That Started Everything

I didn't build this because I was inspired.

I built this because I was scared.

When I saw how fast AI is moving — how entire job categories are being rewritten, how software engineering fundamentals are shifting underneath our feet — my first thought wasn't opportunity. It was dread. I'm a 19-year-old student in India, and I watched the gap between what's happening in the world and what's being taught in our classrooms grow wider every single semester.

In Tier 2, 3, and 4 colleges across India, students don't even know what to Google. They don't know what LangChain is, what an agent is, or what skills will make them hireable in the next 12 months. Nobody is telling them. The curriculum hasn't caught up. It might not catch up for years.

I know this because I was that student not long ago. And I still see it every day around me.

So before this hackathon, me and a few friends built a rough MVP to validate the problem. 370 waitlist signups in a single day. 84 signups on launch day — just from our own university. That number told me everything I needed to know. The problem is real. The demand is real. And nobody is solving it properly. here is the project link of basic MVP - https://ignitio.cloud/

That's when I decided to build this ai powered learning platform which is more of a agentic ai workflow. Not because I had everything figured out — but because I had enough conviction to figure it out as I went.

What I Built

LearnWithNova is a personalized AI learning platform that teaches beginners Gen AI and LangChain the way they actually need to learn it — by building something real first, then understanding how it works.

The core mechanic is what I call tinker-first, learn-second.

Most platforms dump theory on you before you've ever felt the problem. Mine flips that. Amazon Nova builds a working LangChain project tailored to the user's goal. The user clicks around it, breaks it, plays with it. Then the learning starts — tied directly to the code they just touched.

The system is powered by a three-agent LangGraph orchestration framework:

Builder Agent — Generates a working LangChain project and extracts a structured concept map of every technical idea used in the code

Teaching Agent — Reads that concept map and builds a personalized 12-week roadmap, where every single week traces back to a specific part of the user's actual project

Critic Agent — A reflection loop that reviews the roadmap's quality against the user's experience level and goals, triggering up to 2 revisions before finalizing output

All three agents share a single Pydantic state object. Every decision — routing, revision, approval — flows through conditional edges in LangGraph. Nothing is hardcoded. The system genuinely adapts.

The personalization isn't cosmetic. It's architectural. The Teaching Agent never generates generic curriculum. It always asks: where in this user's code does this concept appear, and what would make them care about understanding it?

Not someone else's project. Not a generic syllabus. Yours.

How I Built It

I had 15 days. I had no AI tech stack. And I ended up going completely solo.

My technically skilled co-founder had to drop out due to a health problem. I respect that fully — but it meant I was alone on a build I had originally planned as a team effort.

I started from zero on the AI side. My background is full-stack JavaScript — Next.js, Node, the usual. Python was foreign to me. LangChain, LangGraph, FastAPI — I'd never touched any of them.

I gave myself 10 days to learn everything and 5 days to ship.

Days 1–2 — Python fundamentals, async, Pydantic

Days 3–4 — FastAPI, endpoints, streaming, SSE

Days 5–6 — LangChain, prompt templates, output parsers, LCEL chains

Days 7–9 — LangGraph, StateGraph, conditional routing, SqliteSaver

Day 10 — AWS Bedrock + Nova integration, structured JSON outputs

My JavaScript background helped more than I expected. The concepts transferred — only the syntax changed.

The full stack I shipped:

Frontend — Next.js + Tailwind + stitch
Backend — Python FastAPI
Agents — LangGraph + LangChain

- LLM — Amazon Nova Pro (Builder + Teaching), Nova Lite (Critic)

The Challenges

I'll be honest. This build broke me in several ways.

Challenge 1 — Learning an entire AI stack in 10 days from scratch

No tutorials that matched exactly what I was building. A lot of reading source code, a lot of reading error messages, a lot of asking the right questions until something clicked. Python wasn't the hard part. LangGraph state management was. Understanding how Pydantic state flows between agents, how conditional edges actually route.

Challenge 2 — Going solo

My co-founder couldn't make it due to health reasons. I don't blame him at all — but it meant I was doing backend, frontend, prompt engineering, debugging, and deployment decisions alone, with no one to split problems with at 2am. There were days I genuinely didn't know if I'd finish.

Challenge 3 — Backlash for not showing up

I skipped university for most of this. I missed events, hangouts, things that matter to people around me. I got the comments. "Why are you wasting time on a hackathon?" I just kept building.

Challenge 4 — Frontend codebase corruption

Midway through, my entire frontend codebase corrupted. Not salvageable. I rewrote it from scratch in two days. That was a dark two days.

Challenge 5 — The hardest bug. 3 days to fix.

The most brutal technical problem was inside the agentic orchestration framework. The Builder Agent was generating duplicate concept subtasks — the same concept appearing multiple times in the concept map with slightly different phrasing, which caused the Teaching Agent to generate contradictory roadmap weeks.

I chased this for 3 days. It wasn't a LangGraph bug. It wasn't a Nova bug.

It was a Pydantic schema + system prompt interaction problem.

The schema was too permissive — it allowed the model to interpret concept_name as a free-form field, so Nova would generate semantically identical concepts with different surface strings. Combined with a system prompt that didn't explicitly constrain uniqueness, the model kept producing near-duplicate entries that passed validation.

The fix: tightened the Pydantic model with explicit field descriptions and added a constraint layer to the system prompt forcing Nova to check for conceptual uniqueness before outputting each entry. One schema change. One prompt modification. Three days to find it.

That bug taught me more about the relationship between structured outputs, prompt engineering, and LLM behavior than any tutorial could have.

What I Learned

That conviction is a better fuel than inspiration.

I didn't feel inspired when I started. I felt behind, scared, and honestly a little overwhelmed by how much I didn't know. But conviction — the belief that this problem is real, that students in my country are being left behind, that someone should build this — that carried me when motivation didn't.

Technically, I learned that the architecture is the product. A beautiful UI over a fragile agent system is just a demo. A working reflection loop with proper shared state and structured outputs is an actual product that behaves predictably. I chose to go deep on the architecture even when it cost me frontend polish, and I'd make that choice again.

I also learned that going solo forces clarity. With no one to delegate to, every architectural decision had to be fully mine. I couldn't leave any part of the system ununderstood. That pressure, as brutal as it was, made me a significantly better engineer in 15 days than I would have been otherwise.

Win or Lose, We're Building This

I want to win Best Student App. I'll be straight about that.

But this project isn't going to stop whether I do or not. The 370 waitlist didn't appear because of a hackathon. It appeared because the problem is real and students are hungry for a solution that actually works for where they are, not where Silicon Valley assumes they are.

Next year we're building the full version. Multi-language support. More learning tracks. A proper community layer. This hackathon gave me the prototype, the architecture, and the proof that it can be done.

I'm 19. I built this alone. In 15 days. In a tech stack I learned from scratch.

That's not a flex — that's just what the problem required.

And I'm just getting started.