The backend foundation for AI-built software
Get the foundation right.
Apso turns your product model into a consistent, scalable backend. You own the generated code, APIs, migrations, and infrastructure.
Add team invitations.
- Workspace-scoped data
- Member roles
- Project and task CRUD
- REST endpoints
- Team invitations
{ "entities": [ { "name": "Workspace" }, { "name": "Project", "scopeBy": "workspaceId" }, { "name": "Task" } ] }, { "name": "Invitation", "scopeBy": "workspaceId" } ] }
Start with the data model your product already needs
Each starter gives Apso a detailed schema brief for a real application pattern. Choose one, adjust the entities and relationships, then generate the backend in your preferred language.
- Multi-Tenant WorkspacesReplacesCustom Multi-tenancyTenant workspaces, scoped members, invitations, billing, keys, and limits.Save Weeks of dev time
- Customer CRMReplaces
Contacts, companies, deals, pipeline stages, activities, and follow-up tasks.Save $50-500/user
- E-Commerce StoreReplaces
Products, variants, carts, orders, payments, inventory, and promotions.Save $29-299/mo + fees
- Subscription BillingReplaces
Plans, subscriptions, invoices, payments, usage records, and coupons.Save $250-2000/mo
- Project ManagementReplaces
Projects, tasks, milestones, dependencies, sprints, boards, and time entries.Save $10-25/user
- Blog & CMSReplaces
Posts, authors, categories, media, revisions, comments, and SEO metadata.Save $5-100/mo
Use the frontend stack you know
Use Next.js Server Components and Server Actions as your BFF, or call the generated REST API from a web or mobile client. The TypeScript SDK handles queries and mutations without hiding the HTTP boundary.
// app/projects/page.tsx import { ApsoClientFactory } from '@apso/sdk'; const apso = ApsoClientFactory.getClient({ baseURL: process.env.APSO_API_URL, apiKey: process.env.APSO_API_KEY, }); export default async function Projects() { const projects = await apso.entity('Projects') .where({ status: { $eq: 'Active' } }) .orderBy({ created_at: 'DESC' }) .limit(20) .get(); return <ProjectList projects={projects} />; }
A backend foundation that keeps people and agents aligned
Backend developers get code they can review and extend. Product teams get a clear model of the system. AI agents get Apso's rules for schemas, access boundaries, extensions, and migrations, plus a repeatable process that produces the same structure across every service.
Backend developers stay in control
Inspect predictable NestJS, FastAPI, or Gin code and add product logic without losing it when the schema changes.
Product teams can define the system
Turn entities, relationships, and rules into a working API without hand-assembling every backend layer.
Lean teams can operate without a dedicated DevOps team
Run locally, deploy through Apso Cloud, or take the generated service to infrastructure your team controls.
Turn your coding agent into a backend expert with Apso
Apso gives Claude, Codex, and other coding agents repeatable backend rules, specialized workflows, and project-aware tools. You describe the outcome. The agent designs, generates, and verifies the foundation.
Give your agent backend expertise
Apso gives Claude or Codex repeatable rules for schema design, tenancy, auth, migrations, extensions, and deployment. The agent can apply the right backend pattern without waiting for you to name it.
Connect it to the real project
The Apso MCP server gives the agent access to the current schema and generation tools. It can inspect, design, validate, and build from what your project actually contains.
Ask for the product outcome
Describe the workflow in plain language. Your agent chooses the Apso process, proposes the model, generates the service, and verifies the result before you review the code.
The backend work every application needs
Apso creates the repeated service layers from one schema. The result is a coherent backend in your repository with no required Apso runtime.
- Repeatable project structure
- The schema and CLI version determine the generated entities, controllers, services, and DTOs.
- Familiar framework stacks
- Generate NestJS with TypeORM, FastAPI with SQLAlchemy, or Gin with GORM.
- PostgreSQL migrations
- Preview schema changes locally and commit language-native migration files with the service.
- Auth and tenant context
- Use Better Auth or another JWT provider and carry tenant scope through generated request handling.
- REST API and TypeScript SDK
- Connect through standard HTTP or use the SDK for fluent filters, sorting, pagination, and mutations.
- No lock-in. You own the code.
- The generated service lives in your repository. Run, test, extend, and deploy it anywhere. Apso is not required in production.
A backend repository your team can read and change
The generator writes ordinary framework code and keeps custom application logic in a separate directory. Review the files, run the tests, and use the same deployment tools you use for other services.
project-api/
.apsorcsource of truth
src/
autogen/Rewritten by Apso
Project/
Task/
extensions/Owned by your team · preserved across generation
+ your product logic
migrations/
test/
docker-compose.yml
Data layer
- ORM models
- relationships
- constraints
- migrations
API layer
- REST controllers
- validation DTOs
- filters
- OpenAPI
Application layer
- services
- auth guards
- tenant context
- extension hooks
Operations
- local database
- tests
- Docker
- deployment config
Give your product a backend that can grow with it
Start in the service builder or connect Apso to Claude or Codex. Apso teaches your agent the backend conventions, gives it the project tools, and keeps the generated service consistent as it grows.