What is Kizaki?

Kizaki is an application platform. You declare your data model, auth, authorization, billing, and file storage in one schema file written in Inspire. You write server workflows in TypeScript. The compiler generates the runtime, typed client packages, and deploy artifact from that single source.

Auth checks, access policies, migration diffs, and client types stay in sync because they all derive from the same schema. You spend your time on product logic, not backend plumbing.

The Problem Kizaki Solves

App development breaks in two predictable ways:

• You spend weeks composing services, SDKs, and configuration instead of building features.
• Auth checks, data access rules, and migration scripts live in different systems and drift apart.

Kizaki moves those concerns into the platform. Your application keeps full expressivity. The repetitive system wiring that makes stacks fragile goes away.

The Kizaki Model

Kizaki has three layers:

• Inspire declares the data model, auth, policies, routes, and platform features.
• Server code implements your business logic in TypeScript with /** @expose */ functions.
• Frontend code calls generated APIs and renders the product.

The compiler keeps these layers aligned. It reads your schema, validates your exposed functions, generates TypeScript packages, and gives the runtime the information it needs to enforce the model you declared.

A typical workflow:

1. Create a new app with kizaki init
2. Run it locally with kizaki dev
3. Add server functions with /** @expose */
4. Call the generated @kizaki/client from your app
5. Evolve your schema with committed migrations
6. Deploy with kizaki deploy

What You Build With

Inspire is where you make platform decisions. Server code is where you write workflows. The generated client is what your browser code calls. The browser query stack keeps UI state live.

The Core Workflow

auth {
  providers: [email],
  sessionDuration: 30d,

  principal {
    displayName: string @from(Profile.displayName),
  }
}

entity Todo {
  title: string @minLength(1) @maxLength(255),
  completed: boolean = false,
  ownerId: __User.id,

  @grant read, write, delete where resource.ownerId == principal.id
}

That schema becomes:

• a real database with validated columns and constraints
• a built-in auth model exposed through /__auth/*
• a policy-enforced runtime contract
• generated TypeScript entities and client functions
• the source of truth for future migrations and deploys

For the full auth surface, see Inspire Auth and Authentication.

Why The Schema Matters

Changing the schema updates every generated surface: types, client functions, migration plans, and runtime policies. Auth and authorization stay next to the data they protect. Migrations come from source-of-truth diffs, not hand-written SQL. The runtime enforces access consistently across reads, routes, and live queries.

One file is the single point of change. Everything downstream follows.

When To Use Kizaki

Kizaki fits when you want:

• auth and authorization built in from day one
• a typed backend without hand-writing CRUD layers
• one workflow for browser apps, APIs, and background jobs
• schema changes that stay reviewable and safe
• deploys that follow the same model as local development

You move quickly without building platform infrastructure yourself.

Continue with the Quickstart to build and run your first app.