Start here

Turn one app workflow into a tested backend.

Bring an app idea, prototype, or frontend. Build one representative backend flow, inspect every resource, test the real API, and publish only what you reviewed.

Spala project overview with tables, endpoints, API URL, and publish controls
Current product view: project resources and API handoff in one overview.
Best first scopeOne auth-aware product workflow
Build surfaceHosted dashboard and AI Copilot
Need help?vitali@spala.ai
AI coding agents

Asked your agent to use Spala? Start here.

The agent installs the public MCP, asks you to sign in only when needed, then creates or reuses the project and connects its project-scoped MCP automatically.

Step 1

Install Spala MCP

npx --yes @spala-ai/mcp-install@latest init --client codex --yes --json

pnpm dlx @spala-ai/mcp-install@latest init --client <other-client> --yes --json

Use the command for the current client and follow its JSON restart or resume steps exactly.

Step 2

Let the agent continue

After restart or resume, the agent calls protected spala_start once. OAuth and any optional payment stay in the browser; terminal prompts collect missing account, company, and project details.

It creates the first organization when none exists, presents multiple choices, reuses a valid local binding or selects/creates a project, then connects, binds, and verifies its workspace-only project MCP.

Before you begin

Bring the product rules, not a database wishlist.

A useful first build starts with who can do what, which records they touch, and what must never be exposed. You can refine the schema after the contract is clear.

01

User roles

List each user type and the actions each role may perform. Include the owner or tenant boundary.

02

Core records

Name the records the workflow creates, reads, updates, or deletes and how they relate.

03

Acceptance examples

Write one valid request, one invalid request, and one action that a different user must be denied.

First project

Build, inspect, test, then publish.

This sequence keeps the AI useful without asking you to trust generated backend behavior blindly.

  1. 01
    Create or open a project.

    In agent mode, let Public MCP reuse or create the intended project. For manual evaluation, use the hosted dashboard and choose a low-risk project or staging workflow.

  2. 02
    Describe one complete workflow.

    Tell Copilot the users, records, permissions, validation, and expected result. Avoid asking for the whole application in one prompt.

  3. 03
    Inspect what was generated.

    Review PostgreSQL tables, relationships, auth rules, REST routes, workflow steps, validation, and draft state in the project graph and focused tools.

  4. 04
    Test the real route.

    Use API Playground for success, invalid data, missing auth, wrong-user access, CORS, and representative failure behavior.

  5. 05
    Publish only reviewed resources.

    Open publish review, select the intended changes, and confirm the published API behaves like the tested draft.

  6. 06
    Hand off the frontend contract.

    Use the exact API base URL, OpenAPI or SDK output, auth routes, token behavior, CORS origin, errors, and current publish state.

Coding agents

Connect MCP at the correct scope.

Public discovery and project work are different surfaces. This distinction prevents an agent from guessing a project endpoint or assuming anonymous write access.

Available

Public MCP

Install the public endpoint through @spala-ai/mcp-install for discovery, protected startup, terminal-guided organization/project selection, and authenticated project handoff.

Reuse a valid local binding or present/select/create the intended project, then call project_connect once. project_select is only a compatibility alias; do not call both.

Authorized

Project MCP

Execute only the exact workspace-local install plan returned by project_connect for inspection, changes, validation, publishing, and review.

Do not construct or guess project MCP URLs or expose the one-time bootstrap URL.

Definition of done

Your first proof should answer six questions.

If any answer is unclear, the workflow is not ready to become a production dependency.

Can the right user act?

The authenticated success path works with expected inputs and output.

Is the wrong user denied?

Ownership, role, and tenant boundaries are tested with separate accounts.

Does invalid data fail clearly?

Validation rejects bad inputs without partial or hidden side effects.

Can the frontend integrate?

The actual frontend can authenticate and call the published route using the handoff contract.

Can the owner inspect it?

Tables, routes, workflow steps, logs, and publish state are understandable in the dashboard.

Can the team recover?

Backups, rollback, support, export, and incident ownership match the cost of failure.

Start with one workflow that matters.

Build it yourself in the dashboard, or scope a managed implementation and handoff with the Spala team.