The Journey.

// era 01 / before the stack / roughly 2022 to 2024

Domains and Hunches

TPS Worldwide LLC was filed in Arizona in 2022, before there was a portfolio for it to hold. For a while the company was mostly a name and an idea: that if I kept putting things on the internet, eventually one of them would matter.

The early work was not engineering. It was website builders. Hostinger first, then Hostinger Horizons, their AI builder. I was not trying to win an architecture award. I was trying to see whether an idea could look like something real. A page could exist in an afternoon. A rough concept could get a homepage, a headline, a logo. That speed mattered, because it taught me the most important habit I have: do not talk about the idea, ship a version of it and look at it.

A couple of ideas from this period are still alive today. The first rough versions of what would become ClickSolveTools, a free browser tools site, and VideoGameCentral, a gaming content site, both started here, as experiments long before they were rebuilt properly. At the time they were just me poking at things to see what stuck. That is the honest description of this whole era: not a plan, just a lot of poking.

The first time I touched a real codebase was 2024, a SvelteKit app built with a collaborator. It was a year before the rest of this story really started. It did not become a business, but it was the first time I saw what was on the other side of a website builder: actual code, actual version history, actual control.

The builders had a ceiling. The moment an idea needed real data, real accounts, real payment logic, or clean ownership of its own code, the limits showed up fast. That ceiling is what pushed everything that came next.

// era 02 / the first backend / early to mid 2025

A Comment Box Becomes a Server

In April 2025 I built something small that turned out to be a turning point: a comment widget for a blog. The first version was front-end only. Comments lived in the browser's local storage and went nowhere. It was not a real system. But it worked well enough to prove a principle I still build on: a feature does not have to be perfect to be useful.

Then I made it serious. The comment system moved onto Cloudflare Workers and a D1 database, with an admin approval step so nothing went live without a check. It was not one Worker either. It ended up as a small set of them: one to write comments, one to read, one to handle likes, one for admin, one for approval.

That was the jump. Static pages and front-end tricks on one side, real application architecture on the other. Suddenly I was thinking about things a page never makes you think about: could someone spam this endpoint, what happens when the database gets hit hard, what does the free tier actually cover before it starts failing.

It was nine days of intense work and then I left it alone. But it was the first project where I stopped being someone who arranges pages and started being someone who builds backends.

// era 03 / the toolmaker / mid 2025

Learning to Build Like an Owner

Once I knew that useful software could start simple, I leaned into small tools. A brandable invoice generator with editable line items, tax math, and PDF export, then persistence, multiple currencies, auto-save. A lightweight CRM, a contact manager with tags, filters, import and export, starred contacts, follow-up reminders. A site chatbot that started as a front-end pop-up with canned answers and grew into something that could actually answer from a site's own content.

None of these were big. That was the point. Each one followed the same shape: start with a simple utility, make it usable, add persistence, add import and export, then decide later whether it deserved accounts and a backend.

What actually changed in this stretch was not my coding. It was how I thought. I stopped asking "can I build this" and started asking the questions an owner asks. Who is this for. What is the first useful thing it does. What does the homepage need to do in the first three seconds. What can stay manual for now. What can wait.

That shift, from builder to product owner, is the real skill. I do not hand-write most of the code, and I never have. What I got good at was describing exactly what a thing should do, precisely enough that an AI agent could execute it, and knowing what to cut. The tools were small. The habit was not.

// era 04 / the surge / early 2026 through spring

Directories, Search, and the Traffic Engine

The beginning of 2026 is when it stopped being occasional and became relentless. Over about thirteen weeks I pushed more than 1,600 commits across more than a dozen projects. February alone was nearly 900. Most of that stretch ran through Cursor and Windsurf, the AI coding tools I lived in before Claude Code.

The projects that defined it were directories. GlowUpFinder, a beauty services discovery platform. BuilderAI.tools, a curated directory of open-source developer tools. ClickSolveTools, a site of free browser utilities that grew past three hundred tools. ReligionCompare, a citation-backed comparison site across two dozen traditions. Furford, a pet services directory.

Building all of them back to back taught me the single most useful strategy I have. I do not enjoy the social media grind, and I am not good at pretending otherwise. So instead of chasing an audience, I build things people are already searching for: free tools, comparison pages, programmatic landing pages that answer one specific query each. Search does not sleep and it does not need me to post every day. A directory with the right pages keeps working long after I have moved on to the next project.

That is the era where the portfolio stopped being a pile of sites and started being a strategy.

// era 05 / content and games / early to mid 2026

Building Things People Come Back To

Tools solve a problem and the user leaves. That is fine, that is the job. But around the same time I was building directories, I started a separate branch of the portfolio that scratched a different itch: things people come back to for their own sake.

MiniGamePlanet, a site of free browser games that grew past a hundred of them, with a coin economy, profiles, and an admin panel behind it. VideoGameCentral, a gaming news and content site. Jagan Worldwide Games as a brand for the game side, and a game foundation of its own.

This branch also taught me how much of building is branding, and how unglamorous that part is. I spent a genuinely surprising amount of time on logos and favicons. A mark can look great at full size and look like nothing as a sixteen-pixel browser-tab icon. One commit in this era removed seven hundred and forty-eight em dashes from a single site in one pass, which tells you something about how much of this work is small, boring, and necessary.

A weak favicon makes a real project feel unfinished. A strong one makes a small project feel real. Once you are running a portfolio, the logos are not decoration. They are the trust layer, and I learned to treat them that way.

// era 06 / the ownership lesson / early 2026, roughly january to march

Whose Name Is on the Domain

Not every chapter is a build story. One of the most important ones is a business lesson.

For a stretch I was a partner in a fantasy sports venture, a fifty-fifty split with a collaborator. It produced real work: sportsbook odds tooling, NFL data pipelines, a few live sites. And then, over the first few months of 2026, it wound down. An operating agreement in January, an amendment in February that formally assigned the domains and digital assets, and a clean, documented withdrawal in early March, where I assigned my interest and stepped away.

I want to be careful here, because this is a lesson, not a grievance. The separation was handled properly, on paper, by both sides, and it preserved my unrelated projects explicitly. That clean paperwork is exactly why it was a good outcome instead of a mess.

What it taught me is simple, and I now treat it as a rule. Once real money and real partners are involved, ownership cannot float. Domains, repositories, code, brand names, APIs, deployment credentials, user data: every one of those needs a clear answer to "whose is this." Before that chapter I could build anything. After it, I knew I also had to know who owned what, and to keep new things cleanly separate from the start.

// era 07 / the first real saas / early 2026 onward

TextSpeakPro, and the Day Billing Became Real

TextSpeakPro is the project where I stopped building things that look like products and built an actual one.

It is an AI text-to-speech platform. You give it text, it gives you a voiceover you can download, and the better voices sit behind paid plans. Underneath that simple promise is the first system I built with every serious part wired up: accounts and auth, Stripe billing, usage metering, a tiered set of voices, legal and compliance pages, and a backend that abstracts the voice providers so the product never has to care which vendor is behind a given tier.

It was also where the difficulty jumped. Stripe alone was a fight: test mode versus the newer sandboxes, live and test data living in separate worlds, webhooks, checkout redirects pointed at the wrong domain by one wrong environment variable. One audit finding I still think about: character usage had to be reserved before calling the provider, not after, or someone could run up real provider costs before the app ever deducted a credit. Billing logic is not decoration. It is core infrastructure, and TextSpeakPro is where I learned that in my own hands instead of in theory.

It launched late one night in late February 2026. It found its first signups, then its first paying customers, and it has kept running as a real product since. That is what I am proud of: not a launch-day spike that faded, but a product that gets found, used, and paid for. That is a completely different thing from having an idea.

// era 08 / the system / spring 2026

One Founder, a Repeatable Machine

By spring 2026 the portfolio needed a structure, and TPS Worldwide became the umbrella it was filed to be back in 2022. Not a brand for show. A real home for the legal side, the contracts, the ownership lines, and the public face of a multi-project operation.

Underneath it, a build system had quietly emerged from doing the same things over and over. Every new project now starts the same way. Name it, choose the domain, define what the homepage promises in one line. Pick the framework by the job: content and SEO sites in Astro, apps with dashboards in SvelteKit, simple tools and games in plain HTML and JavaScript. Apply the same day-one checklist every time: canonical tags, sitemap, robots rules, security headers, structured data, the redirect from www to the bare domain. Add the legal pages. Add the SEO architecture before the content. Launch a basic but real version. Then, and only then, decide what deserves to be automated.

I also built TPS Command Center, a single Cloudflare Worker running a set of AI agents on cron schedules to handle recurring business tasks. The point of all of it is leverage. The reason one person can run this many projects is not that I work without limit. It is that almost nothing is invented from scratch anymore. The stack is familiar, the checklist is fixed, and the next project starts from a running start.

// era 09 / now / may 2026

Building for Other People

This is no longer a story about learning to code. It never really was. It is a story about learning to build internet businesses with AI as the lever, and about getting fast enough that the cost of trying collapsed.

That speed is the whole point now, because today I take the same machine and point it at other people's problems. This is the work I actually want to be doing. Helping people with product development, with websites and web services, with the unglamorous infrastructure under a real product, and with the growth that comes after launch. Not as a side effect of building my own portfolio, but as the thing itself.

Opal and Ore, an online store and brand for an independent artist, is what that looks like in practice. It is client work. I built it and I keep it running, the e-commerce, the payments, the admin, the infrastructure, while the artist runs the business on top. That is the model. Someone has an idea, or a product that needs to grow. I can name it, brand it, prototype it, deploy it, wire up payments, write the legal pages, build the SEO, and find out whether anyone cares. Fast, and solo.

This site, tommybuilt.dev, got built and deployed in a single sitting, which is either a good sign or an on-brand one.

I am not going to pretend everything worked. Most things in a portfolio this size will not. There have been broken deploys, confidently wrong AI code, Stripe screens that made no sense, migrations run against the wrong database, and more domains than any reasonable person should own. But the wins are real too, and they are still growing. I shipped a SaaS, and it has paying customers and is still running. I built directories pulling steady, growing traffic. I built brands, tools, and games, and turned a pile of random ideas into something that functions like a company.

The portfolio was always the proof. The job is helping other people build and grow theirs.