# How I Built a Self-Learning YouTube AI on AWS Aurora (And Barely Survived the Weekend)

> Source: <https://dev.to/neo_gamers_d7450d6e9b8785/how-i-built-a-self-learning-youtube-ai-on-aws-aurora-and-barely-survived-the-weekend-1gen>
> Published: 2026-06-28 11:03:07+00:00

Eight months ago, I couldn't write a single line of code. I was just a guy in Tunisia trying to figure out how to make things work on the web, tinkering with old Volkswagen engines—specifically trying to wrap my head around the suspension geometry of a Golf MK3 and the quirky reliability of Passat B6 diesels—and dreaming of building real software.

Fast forward to today, and I just shipped a self-learning vector database application on AWS for a massive international hackathon.

It feels like an absolute fever dream, but it's real. Here is the story of how **Virantics** came to be, the suspense of building it under severe time pressure, and why I decided to take on the "H0: Hack the Zero Stack" challenge.

If you've ever tried to run a YouTube channel—especially the automated or faceless kind—you know the pain. The algorithm is brutal. You spend hours strategizing, editing, and designing, only to realize that by the time you spot a video trend, the window of opportunity has already closed.

The usual AI tools out there just guess. They wrap a basic prompt around a language model and spit out generic, hallucinated ideas. I absolutely hate generic software. When I build my own micro-utilities, like the custom tools I host on Elevato, I build them to solve actual, specific problems. No fluff.

When I saw the announcement for the H0 hackathon, I knew I had to jump in. The premise was daunting but exactly what I was looking for: *"Front-end in minutes. Back-end designed for scale"*. The rules required us to build a full-stack app that could realistically go to production, deploying the frontend on Vercel or v0, and strictly using designated AWS Databases.

I didn't want to build just another stateless wrapper for this event. I wanted a machine that gets smarter the more people use it.

The concept: a suite of YouTube growth tools that self-learns using real-world performance data. I designed a three-layer memory system. The brain of the operation would be **AWS Aurora Serverless PostgreSQL**, utilizing the `pgvector`

extension.

Instead of hallucinating trends, the database stores the top 30% of real YouTube winners as vector embeddings. Every single time a user runs a query, the system accumulates more evidence.

For the stack, I went with:

Building this felt a lot like diagnosing a mysterious rattle in a Golf MK6. You fix one thing, tighten a bolt, and suddenly another part starts shaking.

I started off strong using Vercel's v0 to scaffold the Next.js UI. Having an AI generate the React and Tailwind boilerplate felt like having a superpower. I had the skeleton of the Virantics dashboard up in no time, matching the dark, sleek aesthetic I envisioned.

But then came the backend integration. Setting up AWS OIDC Federation with Vercel IAM roles is a brilliant way to handle security without hardcoding long-lived secrets, but getting the permissions perfectly aligned took some serious, head-scratching debugging.

The real boss fight, however, was architecting the `pgvector`

implementation on Aurora. I had to ensure that when the Idea Brainstormer feature fired up, it wasn't just doing a basic keyword search. It needed to execute an actual semantic similarity search against proven winning patterns in specific niches.

There was a tense moment late Saturday night. The Tunisian summer heat was creeping in, the coffee was running dangerously low, and staring at my Kilo IDE screen, I realized the API route for the **Title Engine** kept timing out. This engine is supposed to produce title variations tagged with psychological triggers (like Curiosity or FOMO) and account for recency decay. But it was just spinning into the void.

After digging through the logs, I realized my database query was scanning sequentially instead of using the index I thought I had built. Fixing that was the software equivalent of finally getting a rusted control arm bolt loose. I restructured the query, rebuilt the index, and held my breath.

I hit the endpoint again.

Everything just clicked. The latency dropped from a terrifying 30 seconds to absolute milliseconds. The data flowed perfectly into the UI.

With the database humming, I wired up the remaining features:

To make sure the project was actually discoverable and had a solid SEO foundation—something I learned the hard way when migrating my other projects to Next.js—I polished the metadata and routing structure.

Submitting the demo video was the final hurdle before collapsing. Going from absolute zero coding knowledge to configuring serverless vector databases on AWS in less than a year is a journey I wouldn't trade for anything. It is exhausting, it is messy, but seeing a complex, multi-layered system work flawlessly is the greatest feeling in the world.

If you are a developer on the fence about jumping into a hackathon, just do it. You will learn more in a weekend of sheer panic and problem-solving than you will in three months of passive tutorials.

Check out the live app, throw some channels at it, and let me know what you think!
