For developers

Postgres, auth and storage in a single binary.

Wire-compatible with @supabase/supabase-js. Ships as one Go binary you can run anywhere, or drive entirely from your editor over MCP.

Set it up

Start from your editor, an idea, or Supabase.

One command wires your agent to the backend over MCP. Or describe an app, or bring a Supabase project across.

Claude Code

claude mcp add instancez --transport http https://my.instancez.ai/mcp

Other MCP clients

{ "mcpServers": { "instancez": { "type": "http", "url": "https://my.instancez.ai/mcp" } } }

One command, nothing to install. Your agent then builds and deploys your backend from inside the editor you’re already in, Postgres, row-level security, auth and storage, without leaving the session.

You’ll be asked to sign in the first time. Your frontend stays wherever you like.

What you’re actually getting

The hard part isn’t building an app. It’s everything behind it.

Every app has an engine room behind it, where your users’ accounts, data and files live, and who’s allowed to see what. AI can write a good-looking app in an afternoon; that engine room is what decides whether it survives real customers, so it’s the part we build.

01

You shouldn't need to hire an infrastructure team

Most tools leave you to run everything behind the app yourself, normally a hire, or three, the moment cost or a security review forces the issue.

How we solve it

instancez is one program, the same thing runs whether we host it for you or you run it yourself, in one command, not a new hire.

A single Go binary, docker run it, drop it on Lambda, or run it on bare metal.

02

“You can leave anytime” only counts once somebody has

Every tool promises you're not locked in. That promise is only worth something once a real company has actually left and stayed open for business.

How we solve it

Your app talks to us the same way it talked to Supabase, so moving over means changing an address, and moving away later is just as cheap.

We're wire-compatible with @supabase/supabase-js: tables, relationships, RLS policies, auth users and storage objects transfer, and existing client calls work against a new URL and key.

Outcome

A local clinic's 8 GB Supabase instance was live again in under an hour, with zero changes to their application code.

03

You should be able to see what the AI built

When AI builds your app by clicking around a control panel, nobody, not you, not a developer you hire later, can check its work.

How we solve it

Everything the AI builds is written down in plain, readable form, and every change goes to a private preview first, so nothing reaches your users until you've tried it yourself.

The whole backend is one declarative file, every table, relationship, and the exact access policy on each operation, tracked in git and reviewable in a pull request.

This is what “written down in readable form” looks like. One short file describes a table of posts and says that anyone can read them but only the author can change theirs. You never have to write this, but it’s there, and anyone you hire can read it.

instancez.yaml 
tables:
  posts:
    fields:
      - name: id
        type: bigserial
        primary_key: true
      - name: user_id
        type: uuid
        foreign_key:
          references: auth.users.id
    rls:
      - operations: [select]
        using: "true"
      - operations: [insert]
        with_check: "auth.uid() = user_id"
      - operations: [update, delete]
        using: "auth.uid() = user_id"

What you get

  • A real database Postgres with schemas, foreign keys and indexes
  • Rules about who can see what, enforced on every request Row-level security, applied in the database itself
  • Sign-in that already works Password, magic link, OTP, Google and GitHub, anonymous, TOTP MFA
  • Somewhere to put files Local disk or S3, under the same access rules
  • Custom logic when you need it JavaScript functions at /functions/v1/<name>
  • Runs anywhere you want it Docker, AWS Lambda, or bare metal
Read the source

It’s open source, which means if we ever disappeared you could keep running all of this yourself.

Why the AI gets it right

We built this to be the thing AI is already best at writing.

AI models learn from the code that already exists in the world. We deliberately built instancez to work the same way as the most widely used tool of its kind, so the AI is writing something it has seen millions of times rather than guessing at something new.

That’s the difference between an app that works on the first try and one that looks finished but quietly breaks. It also gets better on its own, as models read more of that code, they get better at ours, without us changing anything.

Concretely: we’re wire-compatible with @supabase/supabase-js, one of the most heavily represented client libraries in training data. A backend with a novel SDK fights the model’s priors on every call and pays for it in retries and hallucinated methods.

Install the CLI

This installs inz, the CLI you use to run and manage the backend on your own infrastructure, same binary that powers the hosted product, not a stripped-down edition. docker run it, drop it on Lambda, or run it on bare metal.

curl -fsSL https://get.instancez.ai | sh

On Windows, grab it from the GitHub repo directly.

Read the source

Want us to host the app too?

Already had an app built somewhere else? Send us the code and we’ll run it for you. You get a private link to try it first, and you publish when it looks right.

And when it needs somewhere to keep accounts, data or files, that’s already here.

Nothing goes live until you say so

However you start, you get a private version to click around and test first. It goes live for real customers when you say it’s ready, not when the AI decides it’s finished.

Simple, transparent pricing

Start free and scale as you grow. No hidden fees.

Monthly Yearly 2 months free

Free

For side projects that stay up.

$0 /month
  • 1 appone project, deployed and hosted for you
  • 2 GB of data2 GB database
  • 10 GB of filesimages, uploads, attachments
  • 5 GB of traffic a monthegress
  • 50,000 total userstotal registered users
  • Your app never gets switched offstays live even when idle
Get Started
Popular

Pro

For a real product with real customers.

$20 /month
  • 1 project included, with 10 GB of data10 GB database, dedicated compute
  • 100 GB of files, shared across every projectimages, uploads, attachments
  • 250 GB of traffic a month, shared across every projectegress
  • 100,000 total users, shared across every projecttotal registered users
  • Custom domains includedbring your own domain, no per-domain fee
  • Daily backups
  • Extra projects $8/mo each ($80/yr)1 GB of their own data, drawing from the traffic and files above
  • Spending cap on by defaultno surprise bills
Get Started

Enterprise

For teams with compliance and scale needs.

Custom
  • Deploy in your own cloudyour infrastructure, your perimeter
  • SSO integrationSAML / OIDC for your whole team
  • Integrate with your existing systemsconnect the tools you already run
  • Your LLM provider of choicebring your own model and keys
Cofounder Talk to Cofounder

Questions developers ask

The mechanics, compatibility, hosting, and what you actually own.

What exactly does self-hosting give me?

The full backend: a single binary running Postgres-backed APIs, auth, storage, and functions on your own infrastructure, Docker, AWS Lambda, or bare metal. It is the same software that powers the hosted product, not a stripped-down community edition.

Install the inz CLI with curl -fsSL https://get.instancez.ai | sh on macOS or Linux, then use it to run the backend. On Windows, grab it from the GitHub repo directly.

I already use Supabase. Can I bring my code and my data?

Both, and two teams have already done it. instancez is wire-compatible with @supabase/supabase-js, so existing client calls, filters, embedded queries, aggregates, and RPCs work against a new URL and key, no application changes.

Data comes across with your schema, RLS policies, auth users, and storage objects intact. One of our two migrations so far was a local clinic’s 8 GB Supabase instance, live again in under an hour, with zero changes to their application code.

Do I own what gets built?

Yes. If you cancel, you walk away with a working app and everything needed to keep running it, not a read-only copy or an export you can’t do anything with.

Nothing about your app is locked in a format only we can open. It’s all ordinary files you can hand to any developer.

Specifically: your schema, security policies and functions are plain YAML and JavaScript you can commit to your own repository, and the runtime they execute on is open source.

What happens if you raise your prices?

You can leave and take it with you. The software that runs your app is open source under Apache-2.0, with nothing held back for paying customers, so if our pricing ever stops making sense, running it yourself is a real option rather than a threat you can’t carry out. What you pay us for is not having to.

Can I see changes before my customers do?

Always. Every change goes to a private version first, a real, working copy of your app that only you can reach. You click around, check it behaves, and publish when you’re happy. Nothing goes live because the AI decided it was finished.

And because the whole configuration is a file under version control, the previous working state is always something you can read, diff and re-apply.

Where does my data live, and do you train on it?

We never train on your data or your prompts. Hosted projects run on dedicated Postgres instances with encryption in transit and at rest. On Enterprise you can deploy into your own cloud account and bring your own LLM provider, so nothing leaves your perimeter.

Still deciding? Talk to a cofounder, you will get an actual engineer, not a sales rep.