Render your React frontend and run your backend from one server. Server-rendered React, routing, and image optimization next to schema, live queries, auth, jobs, and search. SQLite or Postgres. Deploy to your VPS or Pylon Cloud. No separate Next.js.
Most stacks are a database, an API server, a pub/sub layer, and a separate frontend framework glued together. Pylon collapses it — the handler is the transaction, the query is the subscription, and the same server renders your React pages.
Entities and indexes in TypeScript. Migrations apply on save. Generates a fully-typed client and an OpenAPI surface, in the same step.
import { e, field, policy, timestamps, softDelete, audit } from "@pylonsync/sdk"; export const Order = e.entity("Order", { customer: field.id("Customer"), total: field.int(), cents status: field.enum(["pending","paid","failed"]), createdAt: field.datetime().defaultNow(), }) .indexes(e.idx("customer", "createdAt"), e.idx("status")) .policies(policy({ allowRead: "auth.userId == data.customer || auth.hasRole('admin')", allowUpdate: "auth.hasRole('admin')", })) .behaviors([timestamps, softDelete, audit]); // → pylon codegen client · OpenAPI at /api/openapi
db.useQuery is a subscription.Pylon walks the change log on every write and pushes a diff to every client whose query depends on it. No polling. No cache invalidation. No fan-out service to operate.
25+ OAuth providers, magic-link, OIDC discovery, guest sessions, API keys. Row-level policies sit next to the data and compile into the query plan, so the rule runs on every read whether you remembered it or not.
tenant_scope — never write WHERE org_id = ? by hand again.The pieces you usually stitch together ship as one system — frontend and backend. Render the React side, or use the data side alone, then layer on realtime, workflows, search, and game-shaped primitives when the product needs them.
Streaming SSR with hydration and per-route code splitting. Pages render on the server and ship only the JS the route needs.
Client-side navigation with prefetch, and image optimization in Rust — resize, WebP, content-addressed cache. No next/image.
Tailwind compiles on save and ships with the page. No second build step, no PostCSS config to babysit.
Entities with composite indexes and relations. Migrations apply on save, generates a typed client.
db.useQuery is a WebSocket subscription. Diffs over the wire on every relevant write.
Queries, mutations, actions in TypeScript with v.* validators. Filename is the RPC name.
Access rules next to the schema. Compiled to bytecode, evaluated in the query plan.
Magic-link, 25+ OAuth providers, OIDC discovery, guest sessions, API keys. No third-party SDK.
BM25 + live facets across millions of rows. Maintained in the same transaction as your writes.
Presigned uploads to local disk or any S3-compatible bucket. R2, Backblaze, MinIO — one env var.
Multi-step flows with sleep, retries, event waits. State checkpointed on every step.
Enqueue with ctx.schedule. Cron lives in the manifest — version-controlled with code.
SQLite is the default. Set DATABASE_URL and the same schema targets Postgres.
WebSocket rooms, per-member presence, join/leave events, broadcast. No Ably, no Pusher.
Authoritative 20/30/60 tps loops in Rust. Area-of-interest, snapshot + delta replication, late-join.
Pylon server-renders your React app from the same process that runs your data — and the same backend feeds your SPA, mobile, and native clients with realtime subscriptions, optimistic mutations, and a typed client.
Server-rendered React from the same server as your data. Streaming SSR, per-route code splitting, <Link> and <Image> built in. No separate Next.js process. @pylonsync/next is there if you want it.
Subscription hooks that re-run on every relevant write. IndexedDB mirror answers reads in 0.4ms while the diff is in flight. Optimistic mutations with auto-rollback.
The same hooks API, mobile-tuned. Hermes-friendly, background-safe sockets, on-device SQLite mirror so reads survive a bad cell tower.
First-class Swift SDK with TypeScript-sync parity and a Loro CRDT bridge. Codegen turns your schema into typed entities and structured-concurrency clients.
Pick a managed backend and you inherit its boundaries — and still bolt on a separate frontend framework. Pick raw infrastructure and you rebuild everything. Pylon is one model for the frontend and the backend, across both.
| Capability | Pylon | Convex | Supabase | Firebase |
|---|---|---|---|---|
| Declarative schema | First-class | Yes | Yes | Partial |
| Live queries with diffs | First-class | Yes | Yes | Yes |
| Server-rendered frontend | Built in | — | — | — |
| TypeScript server functions | Native | Native | Edge (Deno) | Cloud Functions |
| Faceted search, no sidecar | BM25 in DB | — | pg_trgm | — |
| Tick-based authoritative loop | 20/30/60 tps | — | — | — |
| Self-host as one binary | scp-able | docker-compose | multi-service | Vendor only |
| Open source | MIT / Apache | Yes | Yes | — |
Pylon is not a hosting bet. The same frontend-and-backend app runs locally, on Pylon Cloud, on a VPS, or inside your AWS account — without rewriting handlers.
SQLite backend, hot reload, type-safe client regen on every save. Zero config while you build.
Hosted infra when you want the framework, not another ops project. Same app, same APIs.
Run the same binary on a VPS, container platform, or private network when control matters.
Move into your AWS account with Postgres, load balancing, secrets, and your VPC. Inherit none of the framework.
Frontend and backend live in minutes. Move to Pylon Cloud or your own infrastructure later — without changing a line of programming model.
One npm command. Generates a Pylon backend + Next.js frontend in a single workspace — no global binary, no Rust toolchain, no Docker.
Pulls @pylonsync/cli (platform binary) plus the SDK and React bindings. Nothing global.
Spins up the API and web together. Watches your schema, regenerates the typed client on save.
One init call, then useQuery subscribes and re-streams on every change.
Every primitive shows up in a working example, MIT-licensed in the monorepo. Fork one, change the schema, and you have a head start.
Real-time messaging with rooms, presence, and typing indicators. Loro-backed conflict-free message ordering.
Issues, projects, cycles, comments. Live cursors and optimistic mutations on every edit.
Multi-tenant B2B contacts and pipelines. Demonstrates RBAC, audit logging, and the policy compiler.
Tick-based authoritative shard with area-of-interest replication. 60 tps in Rust, Three.js client.
SwiftUI app over the native Pylon SDK. Showcases codegen, structured concurrency, and the Loro bridge.
E-commerce with faceted search, files, and a Stripe-style checkout workflow. BM25 over the catalog.
One markdown file teaches Claude Code the schema model, the policy DSL, the server-function runtime, and the React client. Drop it into ~/.claude/skills/pylon/ and Claude generates code that compiles instead of code that looks like it should.
523 lines of conventions — schema shape, policy expressions, ctx.* helpers, manifest behaviors, deploy paths. The same handbook the maintainers write to.
Save to ~/.claude/skills/pylon/SKILL.md for every project, or .claude/skills/pylon/SKILL.md committed alongside one app.
The skill lives at pylonsync.com/pylon-skill.md and ships with each Pylon release. Re-curl when a new version drops.
Full install instructions and the whole skill rendered inline at pylonsync.com/skill.
Open source, MIT/Apache. Free tier on Pylon Cloud — pay when you outgrow it, or take the binary and run it yourself.