Everything your app might need. Already built.
A database, sign-in, file storage, email, scheduled jobs, AI, a headless browser, custom domains. Every project gets all of it the moment it's created. Your AI reaches for whichever pieces your app needs, and they're just there.
The usual way
- Sign up for a hosting service
- Sign up for a managed Postgres
- Sign up for an auth provider
- Sign up for a transactional email service
- Sign up for a file storage bucket
- Wire up a job queue or cron service
- Pick a vector database for search
- Glue an AI gateway in front of your providers
On Hatchable
- The AI uses what's already wired in
- Nothing to sign up for, nothing to glue
- One flat bill for all of it
Same capabilities. Different amount of plumbing.
A real database, and everything around it.
No managed-Postgres account to set up. Every project gets its own database, its own file bucket, and search that understands meaning, free, the moment it's created. Go deeper on the database, file storage, or semantic search.
A private Postgres for every project
Standard PostgreSQL with real SQL and real migrations, isolated from everyone else's. The AI writes and runs the migrations; you can query anything yourself whenever you want.
A chore tracker stores kids and chores. A client portal stores accounts and tickets.
Upload anything
Photos, PDFs, CSVs, recordings. Each project gets its own private bucket, and files come back as links you can drop straight into pages or emails.
Customers attach documents to tickets. Generated invoices get saved for download.
Find things by meaning
Built-in embeddings and vector storage, no separate vector database. Index notes, docs, or tickets and search by what they mean instead of the exact words, using the AI key you already set.
A meeting archive that finds the right past discussion even when you forget the phrasing.
Every way an app talks to humans.
Logins, invites, email. The pieces every real app eventually needs, ready before you ask. Go deeper on sign-in or email.
Accounts without passwords
Email-code login and passkeys. Sessions, sign-out, and account management included. Two lines of config and your app has user accounts.
A book club where every member has their own account.
Sending that just works
Welcome emails, notifications, weekly digests. Hatchable handles the sending, the deliverability, and the bounces. Your app just says what goes to whom.
"Email me a summary every Friday at 4pm." Done.
Bring your people in
Projects are private by default. Invite someone by email, choose whether they can use or edit, and they're in. No seat pricing.
Invite the whole family to the meal planner.
When your app needs to do AI.
Summarize, classify, draft, look at images, run multi-step work. Add your provider key once and the platform routes every call. Go deeper on AI →
One call, any provider
OpenAI, Anthropic, and Google behind a single call. Ask for a family like sonnet or gpt and the platform routes to whichever provider you've configured. Swap keys later; the app code doesn't change.
A summarizer on your OpenAI key today runs on Anthropic tomorrow, no rewrite.
Apps that can look
Send an image to a vision-capable model and it describes, classifies, extracts, or answers questions about what it sees.
A receipts tracker reads photos and pulls out the total, date, and vendor.
Beyond chat
Image generation, transcription, text to speech, batches. One escape hatch reaches any endpoint your provider offers, using the same key you already set.
A journal app illustrates entries with the same key that powers its summaries.
Multi-step work
Give the model tools like "query the database" or "send an email" and the runtime drives the loop: pick a tool, run it, feed the result back, repeat. Every step comes back in a trace you can inspect.
"Research this company and write a one-pager" runs to completion on its own.
Things that happen without a click.
Daily digests, scheduled reminders, slow jobs that shouldn't block a page load. No queue service, no cron server, no infrastructure. Go deeper on scheduled work →
Cron in one line
"Run this every Monday at 9am." "Send this at 7pm tomorrow." One line in your app, no separate service to babysit.
A weekly leaderboard email. An hourly price check. A one-time launch announcement.
Slow jobs, off the clock
Generate the PDF or crunch the batch in the background instead of making someone watch a spinner. The app answers instantly and does the heavy part on the next tick.
Uploads get processed in the background; users get an email when they're ready.
A headless browser, on tap.
Chromium built into the platform. Read pages that have no API, and turn your own pages into images and PDFs. Go deeper on the browser →
Read the web
Visit pages, extract data, fill forms. For every source that publishes a website but never shipped an API.
A dashboard checks a few public pages every morning and emails you what changed.
Pages into pixels
Screenshot any page or render it to PDF, including your own. Build the layout as plain HTML, then turn it into a share card or a printable document.
Every blog post gets an OG card. Every order gets a printable invoice.
Your app, out in the world.
A real URL from the first deploy, your own domain when you want it, and a real backend other services can talk to. Go deeper on domains and publishing →
Your name on the door
Every project starts live at its own hatchable.site URL. Point any domain you own at it whenever you're ready. HTTPS is automatic, with no per-domain charge.
maria-cooks.com instead of a subdomain, minutes after you connect it.
More than pages
Your app can serve JSON, receive and verify webhooks, and call external APIs with its stored secrets. It's a real backend, not just a site.
A Stripe webhook marks invoices paid. A public endpoint serves your data to anything.
Private until you say so
Projects start personal and login-gated, free. When something's ready for the open web, publishing is one click and your first public app is free. Builder covers everything after that, and multi-tenant apps can go a step further.
Keys handled like they matter.
AI keys, webhook URLs, API tokens. Stored encrypted, scoped to exactly who should use them, and never pasted into source code. Go deeper on secrets →
Scoped to one app
Stored encrypted, readable only by that project's code. The key never appears in the source your AI writes.
The Slack webhook in your notifier app stays in the notifier app.
Set once, use everywhere
Add a key at the account level and every project you build can use it without re-entering it.
One AI key behind your reading log, expense tracker, and weekly summary.
Everyone brings their own
In shared and multi-tenant apps, each user stores their own keys. Their usage lands on their bill, not yours.
Every teacher who copies the worksheet generator adds their own AI key.
Apps that ask
Declare what your app needs to run. The moment something reaches for a key nobody has set, the app asks for it and carries on once it's saved.
A brand monitor asks for the brand and an AI key up front.
Made to be run by your AI.
Most platforms treat the AI as a code generator and cut it off at deploy. Here the connection is the product, before and after launch. How MCP runs through it →
The chat outlives the build
The same connection that built your app keeps full access after it ships. Read logs, query data, change the schema, deploy again, all from the chat you already have open.
"Why did signups dip on Tuesday?" is a question, not a support ticket.
Apps agents can operate
Any project can expose its own tools over MCP. Your app stops being a walled UI and becomes something other agents can drive on your behalf.
A CRM your sales agent updates by itself, from whatever chat it lives in.
Agents get the manual
Every capability on this page ships with a short, canonical pattern your AI reads before building. It builds things the way that works on the first try, not the fifth.
Ask for login and the agent already knows the auth pattern.
One ask. Three parts, already wired.
Ask for any of it.
Connect the AI you already use, describe the app you want, and every piece on this page shows up already wired together.
Building on the platform? The SDK reference covers the technical surface for everything above.