My Story

Let me be upfront: I don't have a CS degree. I never studied programming. I didn't grow up writing code in my bedroom. I didn't take online courses, I didn't watch YouTube tutorials, I didn't do LeetCode problems. I work at INFUSE — a lead generation company — and my day job has absolutely nothing to do with software engineering. My title doesn't say 'developer' anywhere. That's the starting point. Actual, genuine zero.

The timeline is important, because I think it'll surprise you. This entire journey — from knowing literally nothing about code to running 5 production servers with 20+ projects — happened in roughly a year. Not a decade of slow learning. Not five years of night classes. About a year of building things I actually needed, almost every evening and weekend, with AI as my coding partner. I'm not saying it was easy. I'm saying it was fast compared to what people think is possible.

It all started because I had problems at work that nobody was solving. Not theoretical problems — real, annoying, daily frustrations. I was spending 30+ minutes doing manual QA on every email campaign. I was copy-pasting data between Excel files. I was checking links and DNS records by hand, one by one, like some kind of human robot. Every day I thought: there HAS to be a tool for this. And every day the answer was: there isn't one, or the ones that exist cost $500/month and don't do exactly what you need.

One day I just... tried. I opened Claude and typed something like: "I have this process at work where I check email campaigns for broken links, missing UTM parameters, and DNS issues. It takes me 30 minutes per campaign. Can you help me build something that automates this?" That was it. That was the moment everything changed. I didn't know what JavaScript was. I didn't know what a function was. I just described my problem like I was talking to a colleague.

The first thing I ever built was a simple link checker. Not a full app. Not even a web page. Just a script — a small program that I could run in my terminal that would take a list of URLs and check if they worked. Claude walked me through every step. Create a file. Put this code in it. Run it with this command. I remember staring at the terminal when it actually ran and spit out results: 'Link OK... Link OK... Link BROKEN.' I literally said out loud: 'Holy shit, this works.' It felt like magic. A few lines of text in a file, and my computer was doing something useful. That moment — I can't overstate how important it was. It rewired my brain.

That link checker was ugly. It had no error handling. It probably had bugs I never found. But it worked, and it saved me time. And more importantly, it planted a seed: if I can build this, what else can I build? That question became an obsession. Every manual task at work, every annoying process, every spreadsheet I had to update by hand — I started looking at them differently. Not as chores, but as problems I could solve.

The second project was slightly more ambitious: a script that processed Excel files with a specific column structure. Same approach — I described the columns to Claude, described what I needed to happen to the data, and Claude wrote the code. This one took a few sessions to get right because the data had edge cases I hadn't thought about. But each time something broke, I'd paste the error into Claude and say 'it crashed when processing this row, here's the error,' and we'd fix it together. This is when I learned the most important debugging skill: describe what happened vs. what you expected.

By project three or four, something shifted. I wasn't just copying and pasting Claude's code anymore. I was starting to recognize patterns. I'd see const and know it was creating a variable. I'd see if/else and understand the logic flow. I'd see .map() and know it was going through a list. I wasn't learning from textbooks — I was learning by reading code that solved MY problems. That's a completely different kind of learning, and honestly, I think it's better.

Then came the moment I realized I could build anything. It wasn't a gradual realization — it hit me all at once. I had just finished CampaignPulse, my QA automation tool. What used to take 30 minutes of manual checking now took less than 60 seconds. I showed it to my team and they were stunned. My manager asked, 'Wait, you built this? Like, from scratch?' And I thought — yeah, I did. And if I can build THIS, with a database and a web interface and automated checks and scoring... what's actually stopping me from building anything?

The chain reaction is real. Each project naturally led to the next one. CampaignPulse needed a web interface, so I learned React. The web interface needed a backend, so I learned Express. The backend needed to store data, so I learned PostgreSQL. Then Quality Monitoring needed the same stack but more complex — role-based access, scheduled jobs, automated reports. Then SMTPCloud Dashboard needed EVERYTHING — auth, billing, analytics, real-time tracking, email infrastructure. Each project pushed me slightly beyond what I knew, but never so far that I was completely lost. You don't jump from zero to 44,000 lines of code. You take 20 steps, and each step teaches you what you need for the next one.

The pivot moments matter. I went through distinct phases:

- Phase 1: Scripts for myself — Link checkers, file processors, data cleanup. Things only I used, running on my own laptop.
- Phase 2: Tools for my team — CampaignPulse, Quality Monitoring, RT Helper. Real web apps deployed on servers, used by my coworkers daily.
- Phase 3: Actual SaaS products — SMTPCloud Dashboard, LeadTool. Full platforms with user management, billing, API keys. Built for external users.
- Phase 4: Going wild — MyVaultKeep.io (a crypto trading bot on Solana), VaultKeep (a React Native mobile app). Completely different domains, just because I could.

Each phase felt like a quantum leap, but it wasn't. It was just the natural next step from where I already was.

What my coworkers said is something I think about a lot. At first, people were skeptical. 'You built this? With AI? Does it actually work?' Then they started using the tools. CampaignPulse became part of the daily QA workflow. Quality Monitoring replaced their Google Sheets. And the tone changed to: 'Can you build something that does X?' and 'Is it possible to add Y?' I went from the guy who does lead gen to the guy who apparently can build software. That identity shift was wild.

Fast forward to today. Let me give you the numbers so you understand this isn't a weekend hobby:

- 20+ projects built and shipped
- 5 production servers running on Hetzner and AWS
- 44,000+ lines of code in my biggest project (SMTPCloud Dashboard)
- Multiple production SaaS platforms used by real people daily
- A crypto trading bot connected to the Solana blockchain, handling real money
- A React Native mobile app published to app stores
- 100+ API endpoints across various projects
- 30+ database tables in my biggest schema
- Thousands of hours spent building, debugging, and deploying

Here's what I've actually built — the full list:

SMTPCloud Dashboard — a full B2B SaaS platform for email infrastructure. 44k+ lines, TypeScript, React, Next.js, PostgreSQL, the whole stack. User management, analytics dashboards, billing, API keys, campaign management, real-time tracking.

Quality Monitoring — an enterprise tool for QA processes at work. Auto-syncs with Google Sheets, AI-powered insights, automated daily reports, 111 automated tests. Used by real teams every day.

CampaignPulse — QA automation tool. Replaced 30-minute manual checks with 60-second automated scans. Checks links, DNS, UTMs, content quality.

LeadTool — Built with Python and FastAPI. Lead management with 13+ statuses, duplicate detection, bulk processing. My first Python project.

MyVaultKeep.io — A crypto trading bot with a full web dashboard. Connected to Solana blockchain, Jupiter DEX, Telegram bot for alerts, AES-256 encryption for keys.

VaultKeep — A React Native mobile app for collectors. AI item recognition using Claude Vision, barcode scanning, social features, subscription monetization.

RT Helper — Real-time automation tool powered by n8n workflows.

Nurturing Report System — CSV-to-Excel reporting platform with FastAPI backend and Next.js frontend, containerized with Docker.

AInurturingPortal, Job Hunter Bot, and a bunch of internal tools I've built along the way.

The tech stack I've picked up is honestly ridiculous for someone who can't tell you the difference between a linked list and an array:

- TypeScript & JavaScript — my main languages
- React & Next.js — for building web interfaces
- Express & Fastify — for building APIs
- PostgreSQL — for databases
- Docker & Nginx & PM2 — for deployment and infrastructure
- Python & FastAPI — for backend services
- React Native & Expo — for mobile apps
- Solana & Web3 — for blockchain/crypto
- Git, Linux, server administration — for managing everything
- Drizzle, Prisma, SQLAlchemy — for database management
- Redis, BullMQ, Celery — for background jobs
- Cloudflare, Vercel, Let's Encrypt — for DNS, hosting, SSL

I didn't learn these from a curriculum. I learned them because each project needed something new, and I figured it out with Claude's help.

The philosophy I've landed on is this: you don't need to understand every line of code. You need to understand the problem. What are you building? Who is it for? What should it do? How should it behave when things go wrong? If you can answer those questions clearly, Claude can write the code. Your job is to be the architect, the product person, the one who knows what needs to exist in the world. Claude's job is to translate that vision into working software. That division of labor is incredibly powerful.

The emotional side is real and I want to be honest about it. There were moments of pure impostor syndrome. I'd look at my running application and think: 'I don't actually know how half of this works under the hood.' I'd read about 'real developers' with CS degrees and feel like a fraud. I'd hit a bug I couldn't describe properly and spend hours frustrated. There were evenings where I'd stare at error messages and feel like giving up. But here's the thing — those feelings didn't stop me from shipping. The products work. The servers are running. The users don't care if I can explain Big O notation. They care if the tool solves their problem. And it does.

What I still don't know is a long list, and I'm okay with that. I can't write a sorting algorithm from scratch. I don't really understand how JavaScript's event loop works at a deep level. I couldn't pass a technical interview at Google. I sometimes struggle to read complex code without Claude's help explaining what it does. I don't know design patterns by name. I've never written a unit test from scratch without AI help. These gaps don't matter for what I'm doing. Maybe they will someday, and I'll learn them then — the same way I learned everything else: by needing them.

What I'd do differently if I started over: I'd set up proper project structure from day one instead of refactoring later. I'd use TypeScript from the start on every project (I started some with plain JavaScript and regretted it). I'd write tests earlier — Quality Monitoring has 111 tests now, but they came late in the process. I'd use Git more disciplined from the beginning instead of my early approach of committing everything as one giant blob. And I'd be less afraid of breaking things. The fear of breaking something slowed me down more than actual bugs ever did.

Here's what I want you to take away from this: The approach matters more than the background. I didn't learn to code and then build things. I needed to build things, and I learned what I needed along the way. The skill isn't programming — it's communicating clearly what you want to build and being relentless about shipping. If I can go from literally zero to running 5 production servers and 20+ projects — you can too. This course is me showing you exactly how I did it, step by step, with real examples from real projects. No fluff. No theory for the sake of theory. Just the stuff that actually works.

One last thing: you're going to feel like you're faking it. When you build your first app and someone asks 'did you code this?' and you say yes — it's going to feel weird. Like you cheated somehow. You didn't. The app works. The code runs. The problem is solved. That's what matters. The tools you used to get there are irrelevant. A carpenter isn't less of a carpenter because they use a nail gun instead of a hammer. You're not less of a builder because you use AI instead of writing code character by character. Welcome to the future of building software. Let's get your tools set up.