Introduction

EvidentSource is an API platform built on bi-temporal event sourcing. Every business action is captured as an immutable event with full context — what happened, when it happened, and what the system knew at that moment. From those events, the platform materializes the queryable state views your application reads, and answers temporal questions about the past that ordinary databases can’t.

If you’re here, you’re probably building something where the record of how a decision was made matters as much as the decision itself: financial systems, regulated workflows, or software that lets AI agents take actions on your behalf.

How the pieces fit together

EvidentSource ships as three surfaces. You can enter the story from any of them.

EvidentSource Designer

A visual Event Modeling workspace. You draw your system as events, commands, and state views. The Designer generates the pure-function code (decide and evolve) that implements your model, and hands you artifacts ready to deploy to a running EvidentSource cluster.

Use it when you want to think through a system’s behavior before writing code, or you want code generated from a model that a non-engineer can read.

EvidentSource Sandbox

A free, hosted EvidentSource instance. Point any SDK (Rust, Go, TypeScript, .NET, Python) at it and start issuing commands and reading views. There’s no signup for the APIs.

The Sandbox exists to let you feel the API. Treat it as a public scratchpad: data is visible to everyone, gets purged on a schedule, and carries no availability or support guarantees. See About the Sandbox for the full notice before you put anything into it.

Use it when you want to explore the API, validate an SDK integration, or demo something to a colleague without standing up infrastructure.

EvidentSource (the platform)

The runtime itself — a single container backed by S3. Deploy it to your own AWS account via the AWS Marketplace when you’re ready to run your own workloads with real data, your own authentication, and your own durability expectations. See Operations: containers + S3.

Use it when you’ve outgrown the Sandbox and want a production EvidentSource in your VPC.

The programming model

Two pure functions. That’s it.

// State Changes — handle a command, return events
export const decide = (db, command, metadata) => {
  const state = db.viewState("some-view", { id: command.id });
  if (!state) throw StateChangeError.notFound("Not found");
  return {
    events: [{ type: "SomethingHappened", subject: command.id, data: { /* ... */ } }],
    conditions: [unchangedSince(command.id, state.revision)],
  };
};

// State Views — fold events into a queryable state
export const evolve = (stateView, events) => {
  // return the new serialized state
};

decide is called when a command arrives; it reads from state views, validates the command, and returns the events to append. evolve is called when events are appended; it folds them into the materialized views that decide and your application read.

There are no distributed transactions to reason about, no saga orchestrators to debug. You get a functional core wrapped in an imperative shell — and the shell is our problem, not yours.

Read more in State Changes & State Views.

Pick your path

If you want to…	Start here
Feel the API in five minutes	Try the Sandbox
Design a system before writing code	Design your first system
Go from whiteboard to working app	Designer → Sandbox
Understand the ideas	Concepts
Run EvidentSource yourself	Operations: containers + S3