Documentation/Start Here/Ways to Build
Ways to Build
Supero gives you five ways into building an application. They all end in the same place — a multi-tenant app with access control and an admin panel, running on your database or ours. Pick the one that matches how you already work.
Pick a Path
Builders do not all think the same way. Some think in outcomes and want to describe an app and get one back. Some want command of every detail. Some model the data first and put an interface on it afterwards. Some already have the systems and just need a secured application wrapped around them. And some need the app to talk to half a dozen external services before it is useful at all.
Supero does not force one of these on you. Below are the five entry points, what each is good at, and where to go next for the step-by-step guide.
ℹ️ They are not exclusive
Most real projects mix them: generate a first cut in App Studio, refine the schema in Schema Studio, then drive the last 10% of UI polish from Claude over MCP. Nothing locks you into the path you started on.
1. App Studio — describe it, and it is built
The most direct path. Write what you want in plain language — "a multi-tenant CRM with roles, billing, and an admin panel" — and App Studio turns it into a working application. Not a mockup and not a starter template: the actual app, with the parts you would normally hand-build already in place.
Good when
- •You know the outcome you want but not the exact data model yet.
- •You want something running end-to-end before you invest in detail.
- •The app is a recognisable shape — CRM, portal, marketplace, internal tool.
Next: Build Your First App, then Anatomy of a Supero App to understand what was generated.
2. Claude + MCP — build it fully custom
When you want command of every detail, you do not settle for whatever a single prompt returns. Connect your AI editor to Supero over MCP and build exactly the application you have in mind, with full control of the UI, the features, and the flows.
It is an interactive build, not a one-shot. You direct, iterate, and refine, while Supero provides the platform underneath — the tenancy, the access control, the data layer — so your attention goes to what makes the product yours.
Good when
- •You care about the last 10% of polish as much as the first 90% of scaffolding.
- •The app is unusual enough that a one-shot description will not capture it.
- •You are already working in an AI editor and want the platform reachable from there.
Next: Connect Your AI Editor over MCP and the MCP Tools & Protocol Reference.
3. Schema Studio — for people who design the backend first
Plenty of good engineers do not start with the screens. They start with the data — the entities, the relationships, the constraints — and let everything else follow from getting that right.
Model your backend, iterate until the shape is correct, and only then hand it to App Studio or MCP to generate the frontend and integrations on top. The data model becomes the foundation rather than something the generator guesses at.
Good when
- •The data model is the hard part and the UI is comparatively obvious.
- •You have existing domain models to mirror, or compliance constraints on the schema.
- •Several applications will share one carefully designed set of object types.
Next: Schema Reference for the field and reference syntax, then Managing Data.
4. From your data to a secured application
Often the data already exists. It is sitting in APIs, in databases, in files — and what you need is not a new system but a secured application built around the systems you already have.
- 1
Create a project
A project holds your schemas, data, and tenants.
- 2
Connect your endpoints
Point a connector at a database, warehouse, file source, or HTTP API — synced or live.
- 3
Build in App Studio or over MCP
Generate the application on top of the objects the connector registered.
What comes out is an application with everything it needs around that data: access rights, user accounts, admin panels, and custom UIs — whether you are building a client-facing product or an internal tool.
Next: Connectors Overview, then Live Data, Read-Only & Security for what a connector may and may not do to the source system.
5. Connect to anything
Real applications rarely live alone. They need to talk to cloud providers, source-control hosts, an LLM, or a third-party service. Wiring those up is usually where a clean project turns into a pile of glue code.
With Supero you describe what the application should do, and the platform provides the hooks that reach the outside world. Your application gets access to external services through configured integrations rather than bespoke client code.
The Through-Line
Five different ways in, one consistent result. Whether you describe an app, drive a custom build from your editor, design a schema, wrap existing data, or wire up external services, you end up with the same thing: a multi-tenant application with access control and an admin panel, running on your own database or ours, deployable to Supero Cloud, your own AWS or GCP account, or on-premise.
ℹ️ Where the generated code lives — worth knowing before you choose
The paths differ on this point, and it is easier to pick correctly up front than to change later. Building over MCP from your own editor authors the files directly on your machine — schemas.py, config.py, ui_schemas.py, ui/app.js, run.sh — so they are in your own repository from the first minute. Building in hosted App Studio produces an application you edit through the platform, and you can still take the source out whenever you want: download it as a .tar.gz, or push it into a GitHub or Bitbucket repository you own. The difference is where you edit day to day, not whether you can have the code. Note that no path offers a two-way sync — the source leaves, it does not flow back. Continuity & Exit covers this in full.
See the architectures
Ten reference solutions, each with a diagram and a build path. Solutions Overview
Start from zero
Domain, project, schema, and first CRUD call in a few minutes. Quick Start
Understand the model
Domain, project, tenant, object type — and how they nest. Core Concepts
Choose where it runs
Supero Cloud, your own cloud, or on-premise. Deployment
On this page