This isn't a tutorial. It's just an outline of how a handful of small web tools — a couple of portfolio calculators, an activity generator, and a typing speed test with a live public leaderboard — went from nothing to live on the internet in a very short space of time, almost entirely through conversation.
The VPS
Everything here runs on a VPS — a virtual private server. It's a slice of a much bigger machine sitting in a data center somewhere, set up so it behaves like your own independent computer: your own operating system, your own storage, a public IP address, and full control over it, without the cost or hassle of an entire physical server. Mine is hosted on Oracle Cloud, on their free tier — a genuinely lightweight box, a couple of CPU cores and under a gigabyte of memory, running Ubuntu. It costs nothing, and it's been more than enough to run nginx, a small backend, and four little front-end projects at once.
The Workflow
The interesting part isn't really the VPS, it's how I've actually been building on it. I don't write code locally and deploy it somewhere else — I SSH straight into the box from my computer and run Claude directly on the server. That means every conversation happens on the live machine: editing nginx config, restarting services, installing packages, reading logs, all in real time, with nothing to push or deploy afterwards. I describe what I want in plain English, and we go back and forth until it's actually working, on the real server, not a staging copy of it.
What We Built
Over a few sessions this turned into: a couple of live portfolio calculators, an activity generator for when you're bored or stuck for date-night ideas, and a MonkeyType-style typing speed test with a public leaderboard people can compete on. Most of it took a single conversation to go from an idea to something live and working — backend included, styling included, wired into the site's nginx config and all.
Working Together
What's stood out most is how much of this has actually been a back-and-forth, not a one-way list of instructions. Setting up HTTPS is a good example. Getting a real certificate from Let's Encrypt kept silently failing, and it took some real digging to work out why. It turned out Oracle Cloud has its own separate network-level firewall sitting in front of the VPS — completely outside anything reachable over SSH. Claude could open every port on the machine itself and it still wouldn't have mattered, because the block was happening a layer further out, in the Oracle console. Claude proved it with a packet capture showing the validation traffic never even reached the network card, then asked me to flip the one setting it genuinely couldn't reach itself. Ten seconds in a browser tab on my end, and the renewal started working. Small thing, but it's a decent snapshot of the shape of this whole project: Claude driving almost everything from the terminal, and me stepping in for the handful of things that live outside it.
The Challenges
It hasn't been entirely smooth. HTTPS took a couple of rounds to actually get right before it stuck, and the box itself is genuinely tiny — under a gigabyte of memory — so at one point we had to add swap space just to stop things getting shaky under load. Nothing that was a huge blocker, but a good reminder that "a website" is never just the code — DNS, certificates, firewalls, and a memory budget all sit underneath it, and sooner or later you run into every one of them.
The Division of Labor
In the end this has really been a two-person effort, just an unusual one. I've been the project director — deciding what to build, what it should look like, what mattered and what didn't, and handling the handful of things that only I could reach, like the Oracle console. Claude has done pretty much all of the actual development — writing the code, wiring up the backend, debugging the certificate mess, keeping the server itself running. Neither half works without the other, and that combination is basically the whole reason this got built as fast as it did.