Four days ago I was reading about what an API is.
By day four I had a working RAG application running locally on my machine — one that could answer questions using documents I fed it, without sending anything to an external server.
I'm still not sure how that happened. But I want to write it down before the feeling fades.
Where this fits in the journey
I'm midway through the IBM Applied AI Developer Professional Certificate. Courses 5 and 6 are where everything shifted — from understanding concepts to actually building things. Ten projects across five days.
This isn't a course review. It's an account of what building actually felt like.
Course 5 — Flask and backend development
I went in thinking the backend would be manageable.
I'd learned Node.js in my first year of college during a MERN stack module. I remembered the basics — routing, requests, how a server works. Enough to feel like I had a foundation.
What I didn't account for: after first year, I completely stopped touching backend. My focus drifted entirely to frontend. For two years I wrote UI, helped friends debug occasionally, and let everything else fade.
So when Flask came up, I didn't remember Node as much as I thought. What I remembered was the concept — how a backend is supposed to work. That was enough to adapt, even though the syntax was completely different.
What surprised me more was unit testing.
I'd seen it mentioned in coursework and always skipped past it mentally — something I filed under "I'll care about this later." During Course 5, I actually understood what it was for the first time. What it checks. Why it matters. Why writing tests isn't extra work but part of writing real software.
Here's the part I'm still thinking about.
During campus placements in my final year, a company selected me through a hackathon and called me for a final interview. They asked if I was comfortable with a testing role.
I said I didn't know much about testing and would prefer frontend, web development, or AI.
I didn't get the offer.
Sitting in a Flask unit testing module two years later, understanding what I casually dismissed in that room — that landed.
The Finance Tracker, Sentiment Analyzer, and Emotion Detector came out of Course 5. First time I connected a real frontend to a Flask backend. First time I saw how AI output fits into an application as a feature rather than the whole thing.
Course 6 — Building GenAI powered applications
This is where the ten projects came together. Image Captioner, Chatbot, Voice Assistant, Meeting Assistant, Translation Assistant, Job Application Coach — and the one I want to spend the most time on.
But let me be honest about a few things first.
The BlenderBot problem
The chatbot in the course used BlenderBot model from Meta. I want to say this clearly: in my experience, it was not BlenderBot. It was BlunderBot.
Responses were off — sometimes irrelevant, sometimes just strange. I spent time trying to figure out if I'd built it wrong before I realized the model itself was the issue. That was a useful lesson in its own way — the model matters as much as the application around it.
The translation app detour
The IBM translation API I was supposed to use wasn't accessible from my setup. So I found my own path.
I used Whisperfor speech-to-text and Piperfor text-to-speech. What I didn't know going in: Piper requires downloading an ONNXmodel file separately. The app broke. I searched, figured it out, downloaded the file.
Then Japanese voice models weren't available in my configuration. Then the audio format Piper produced wasn't compatible with the frontend.
Each of those was a small wall. I went over each one. The final app worked. It wasn't the one the course intended — but it was mine.
The LangChain version issue
This one cost me more time than anything else. The course imports used langchain.chains. In the current version of LangChain, that's moved to langchain_classic. The course materials hadn't been updated.
The application simply wouldn't run. No obvious error pointing at the real cause. I eventually found it — either downgrade the package or update every import. I updated the imports.
This is exactly the kind of thing that doesn't come up in passive learning. You only hit it when you're actually building something.
The Private RAG Application
RAG — Retrieval-Augmented Generation — is when an AI application retrieves relevant information from your own documents before generating a response. Instead of relying purely on what the model was trained on, it pulls from a source you control.
Building this one felt different from the others.
It was the first project where I could see how a real AI system is actually structured — not just a model answering questions, but a pipeline. Documents go in, get processed, get stored, get retrieved, and the model uses them to respond. Local. Private. Yours.
That architecture made something click that earlier courses had only described.
The honest part — most important paragraph in this post
Most of these were guided projects. I followed instructions. I used provided code as a starting point.
But wherever I could, I built my own version. I swapped APIs. I changed the frontend. I broke things and fixed them.
And even in the guided parts — practical implementation exposes gaps that passive learning hides. Reading about LangChain imports doesn't teach you what happens when they break. Understanding RAG conceptually doesn't show you what building the pipeline actually feels like.
You find out what you don't know only when the code doesn't run.
Day 5 is less about building fast and more about slowing down.
Today, I’m revisiting everything I’ve learned so far — reviewing my work, filling gaps, and understanding things more deeply instead of just moving on.
I’m also starting to explore what comes next: AI Agents and Practical Deep Learning.
But before jumping into another structured path, I want to build something independently first.
No tutorials. No step-by-step course.
Just a real problem, curiosity, and the tools I’ve learned so far.
What's next
Phase one is done. The foundation is there.
Phase two is building without a guide. That's where I'll find out what actually stuck. I'll write about it when I do — including the parts that don't work.
If you've built guided projects before — when did it start feeling like your own work? Was there a specific moment, or did it happen gradually?
Drop it in the comments. I'm genuinely trying to figure out where that line is. 👇