If you've decided to build your own internal tool, the first thing you'll bump into is a wall of unfamiliar logos. GitHub. Vercel. Supabase. It feels like you need a computer science degree just to sign up for things.
You don't. By the end of this afternoon you'll have three free accounts, they'll be connected to each other, and your AI coding agent will know how to drive them for you. Let's demystify what each one actually does first, because once the picture clicks, the setup is just clicking buttons.
The three pieces, in plain English
Think of your tool as a small business with three rooms.
GitHub is the filing cabinet with a memory. It's where your code lives. Every time something changes, GitHub keeps the old version too, so you can always see what changed and roll back if something breaks. You will rarely touch it directly — your AI agent saves work here for you. The important thing to know: it's the single source of truth for your project.
Vercel is the storefront. It takes the code from GitHub and turns it into a real website that anyone with the link can open. The magic part: every time new code lands in GitHub, Vercel automatically rebuilds and publishes the site within a minute or two. You change something, you refresh the page, it's live. No "uploading to a server" ritual.
Supabase is the back office. It's two things in one: a database (the spreadsheet-on-steroids where your tool's actual data lives — invoices, approvals, vendor records) and a login system (so the right people sign in and the wrong people stay out). When runbookify talks about governance — permissions, audit trails, approval gates — this is the room where most of that machinery sits.
How they fit together (the "three-tier" idea)
Software people call this a three-tier architecture, and it sounds grand, but it's just those three rooms in a line:
- The front (Vercel) — what people see and click.
- The logic in the middle — the rules, also running on Vercel.
- The data (Supabase) — where everything is stored.
GitHub sits underneath the whole thing as the version history. The flow is simple: your agent writes code → saves it to GitHub → Vercel publishes it → the live tool reads and writes data in Supabase. You don't have to memorize this. You just need to recognize the names when your agent mentions them.
Creating the accounts
Set aside about an hour. Have your email open in another tab.
GitHub first. Go to github.com and click Sign up. Use your work or personal email, pick a username (lowercase, no spaces — something like jordan-ops is fine), and verify your email. That's it. You now have a free filing cabinet.
Vercel next. Go to vercel.com and choose Sign up. When it offers "Continue with GitHub," click that — it links the two accounts so Vercel can see your projects automatically. Approve the permission screen GitHub shows you. Done.
Supabase last. Go to supabase.com, click Start your project, and again choose Continue with GitHub. Once you're in, click New project, give it a name like internal-tools, and let it pick a region near you. It'll ask you to set a database password — save that somewhere safe, like a password manager. The project takes a minute or two to wake up; that's normal.
You now own the whole stack. Take a screenshot of each dashboard so you remember what they look like.
How a non-coder actually uses this
Here's the part nobody tells you: you mostly won't open these dashboards day to day. You'll talk to your AI coding agent in plain English — "add a column for approval status," "only managers can delete records" — and the agent does the GitHub-and-Vercel choreography for you.
What you will do is the connective tissue the agent can't see: granting permissions when a tool asks ("Allow Vercel to access this repository?" — yes), copying a key from Supabase and pasting it where the agent tells you, and clicking the link Vercel gives you to check the live result. Think of yourself as the operations manager and the agent as a very fast junior developer who needs you to sign off on access.
What does this cost?
This is the reassuring part. For a small internal tool used by a handful of people, you can run all three on free tiers indefinitely.
- GitHub — free for private projects of this size.
- Vercel — the Hobby plan is free and covers internal tools comfortably. You'd only pay (around $20/month) if you put a high-traffic public product on it.
- Supabase — the free tier includes a real database and authentication for up to tens of thousands of users. The paid tier starts around $25/month, and you'll know when you need it because Supabase will tell you.
So a realistic monthly bill while you're learning and running your first tool: $0. You can build something genuinely useful before you ever enter a credit card.
That's the whole stack. Three accounts, one afternoon, no code. Next time you hear "push it to GitHub and Vercel will deploy," you'll know exactly which room that's happening in.