Your prototype needs two things: a backend that remembers stuff, and a home on the internet. You can set up both today.
You have something that works. A site, an app, a tool -- something you vibe-coded and it came together faster than you expected. But right now it's a movie set. Gorgeous from the front, nothing behind it. The form doesn't save anything. Nobody can visit the URL. It lives on your laptop and nowhere else.
Today we close that gap. Supabase gives your app a backend -- a database where data actually lives, so your app can remember things. Netlify puts it on the internet with a real URL anyone can visit. Both are free to start, and Claude does the heavy lifting for both.
Supabase is the backend. It gives your app a database, an API, user authentication, and file storage -- all through a web dashboard. You don't set up servers. You don't maintain infrastructure. You create an account, grab your keys, and tell Claude to connect everything.
Go to supabase.com and sign up. Click "New Project," give it a name, pick a region close to you, and set a database password.
Once the project spins up (about a minute), go to Settings > API. You need two things: your Project URL (looks like https://xyzabc.supabase.co) and your anon public key (a long string of characters).
Create a text file on your computer -- something like my-project-keys.txt -- and paste in your Project URL, anon key, and today's date. You'll need these keys every time you start a new session with Claude, and some keys expire or rotate over time. Having them in one place saves you from hunting through dashboards later.
You'll see an anon key and a service role key in your settings. The anon key is the one you'll use -- it's safe to share with Claude and put in your app code. The service role key is the master key that bypasses all security. Don't use that one unless Claude specifically asks for it, and never put it in code that goes on the internet.
Netlify puts your site on the internet. You get a free URL, automatic HTTPS, and a deploy process that takes about 10 seconds once it's set up. Your prototype goes from "works on my laptop" to "anyone can visit this link."
Go to netlify.com and sign up with your email. That's it -- you don't need a GitHub account or anything else.
This is what lets Claude talk directly to Netlify from your terminal. Think of it as giving Claude the keys to the building -- without this, Claude can write your code but can't actually put it on the internet for you. Tell Claude:
I need to install the Netlify CLI so you can deploy my site. Can you walk me through it?
Add your Netlify site name and any tokens to that same my-project-keys.txt file. One file, all your keys, dated so you know when you saved them.
Just like Netlify, Supabase has command-line tools that let Claude manage your database directly from the terminal -- creating tables, updating your schema, all of it. Without this, Claude can write code that talks to Supabase, but it can't set things up for you. With it, you just describe what you want and Claude handles the rest.
I need to install the Supabase CLI so you can manage my database directly. Can you walk me through it and link it to my project?
SQL is how databases store and retrieve data -- Claude writes it for you. You'll never need to learn the syntax. If Claude ever shows you SQL and you're curious what it does, just ask it to explain in plain English.
This is the whole playbook. Copy these into Claude, fill in the brackets, and let it work.
Connect my app to Supabase. Here are my API keys:
Project URL: [paste your project URL]
Anon Key: [paste your anon key]
Set up the connection so my app can read and write data.
The starting prompt. Claude figures out your tech stack and wires up the connection.
Create a table to store [describe what you need -- user profiles, form submissions, blog posts, whatever]. Set it up so my app can save and retrieve this data.
Describe the data in your own words. "A table for contacts with name, email, and notes" is perfect.
I need user authentication in my app. Set up Supabase auth with email/password login so users can create accounts and see their own data.
When your app needs logins. One prompt, and Claude sets up the whole auth flow.
Deploy my site to Netlify so it's live on the internet. Walk me through anything I need to confirm.
The deploy prompt. Claude runs the deploy command and gives you the live URL.
I made some changes to my app. Deploy the updated version to Netlify.
After the first deploy, updating is this simple. Change, deploy, done.
Look at what just happened. You set up a real database that saves real data. You deployed a real website that anyone can visit with a real URL. Your prototype isn't a prototype anymore -- it's a product. Not a finished one, not a polished one, but a real one that remembers things and lives on the internet.
Most people never cross this gap. They build something beautiful that lives on their laptop and never goes further. You just put yours on the internet with a backend that works. Everything from here is iteration.
If something isn't clicking or you hit a wall getting set up, reach out. I do personalized activation sessions where we go from prototype to live product together -- and expansion sessions for people who are already building and want to go further.