Relentlessly simple event sourcing

One specification. The whole system generated. The events are the truth.

Under every Reventless app is the same idea: describe what the business asks, decides, records and shows, once and type-safe, and let the framework generate the rest. Every change is kept as an event, so the history is never lost.

The spec is the system

Define commands, events and views in one type-safe spec. Reventless derives everything else — database schemas, GraphQL APIs, MCP servers, cloud infrastructure. Change the spec, regenerate the system.

You write the spec
// Customer.res — the spec
@@reventless.spec

@schema
type command =
  | Register({email: string, address: string})
  | UpdateEmail({email: string})
  | Deactivate

@schema
type event =
  | Registered({email: string, address: string})
  | EmailUpdated({email: string})
  | Deactivated

@schema
type state = {
  email: string,
  address: string,
  active: bool,
}
Reventless generates the rest
# Generated GraphQL API — one of four surfaces
type Mutation {
  register(email: String!, address: String!): CommandResult!
  updateEmail(id: ID!, email: String!): CommandResult!
  deactivate(id: ID!): CommandResult!
}

type Customer {
  email: String!
  address: String!
  active: Boolean!
}

type Query {
  customer(id: ID!): Customer
  customers: [Customer!]!
}
  • Event store
  • GraphQL API
  • MCP server
  • Cloud infrastructure

The specification above is the customer of the online shop, the framework’s own example, which is also the app our measured build from a written brief used.

Why teams build on Reventless

Type-safe end to end

Your event model is checked by the compiler — from command to event to view. Whole classes of bugs never reach production.

Every decision, on record

Event sourcing gives you a complete, auditable history of your business — for compliance, disputes and debugging.

Zero operations

Runs serverless by construction. No clusters, no patching, no on-call for infrastructure that isn’t yours.

AI-native via MCP

Your business processes become tools an AI can safely operate — the platform speaks the Model Context Protocol out of the box.

Slice architecture

Each feature is a vertical slice generated from the event model — small, independent, replaceable.

Infrastructure built in

Deployments are generated with the code. From event model to running cloud infrastructure without writing IaC by hand.

Go deeper

Open source

What the framework is, how the free and paid parts build on it, and why it matters.

Architecture

Event sourcing, slices, generated APIs and infrastructure, type safety, and the history since 2019.

AI

How AI is used in the tools, the guardrails that check it, and local AI on the roadmap.

Tools

The guided interview and the views that show a process before it is built.

Operations

Alarms, the console and the record of every deployment.

Documentation

Concepts, tutorials and the API reference at reventless.dev.

Find out if Reventless fits

A short conversation is enough to see whether your business process and Reventless are a match — no obligation.

Book a free 30-minute intro call Get in touch See how it works

Free 30-minute intro call — no obligation.