What is EvidentSource?

EvidentSource is an event sourcing database that replaces distributed systems complexity with two pure functions.

The Challenge

Building reliable, auditable applications typically requires:

• Distributed transaction coordination — Sagas, two-phase commit, or compensating transactions
• Separate audit infrastructure — Custom logging, CDC pipelines, or dedicated audit tables
• Historical query complexity — Point-in-time snapshots, temporal tables, or archive databases
• Microservice orchestration — Message brokers, retry logic, and eventual consistency handling

Each of these adds code, infrastructure, and failure modes to your system.

The Solution: Two Pure Functions

EvidentSource replaces this complexity with a simple programming model:

State Changes (decide)

Handle commands with a single pure function:

decide(command, database) → events

Validate input, check business rules against current state, and emit events. No database transactions, no distributed coordination—just return the events that should happen.

State Views (reduce)

Materialize state with a single pure function:

reduce(state, event) → state

Process events one at a time to build queryable views. No ETL pipelines, no cache invalidation—the platform handles incremental updates.

Both functions compile to WebAssembly and run inside EvidentSource, giving you portable, sandboxed business logic with no runtime dependencies.

Three Core Benefits

1. Radical Simplicity

Your code contains only business logic. The platform handles:

• Atomicity — Events commit as a unit-of-work with optimistic concurrency
• Scaling — Horizontal scaling across database partitions
• Durability — Events are immutable and replicated
• Streaming — Real-time event delivery to downstream systems

No Spring Boot, no Kafka consumers, no Redis cache—just functions.

2. Built-in Compliance

Every change is an immutable event with two time dimensions:

Dimension	Description	Use Case
Revision time	When recorded in the system	”What did we know at 3pm yesterday?”
Effective time	When it occurred in business reality	”What was the account balance on Jan 1?”

This bi-temporal model answers compliance questions like “What did we know and when?” without custom audit infrastructure.

3. Flexible Consistency (DCB)

Dynamic Consistency Boundary enables cross-entity constraints without sagas:

// Ensure customer has fewer than 5 accounts before creating a new one
constraint: max(events matching "AccountOpened" for customer) < 5

One constraint, one atomic transaction. No compensation logic, no temporary inconsistency, no distributed coordination.

How It Works

┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│   Client    │────▶│  State Change    │────▶│   Events    │
│  (command)  │     │  decide(cmd,db)  │     │  (stored)   │
└─────────────┘     └──────────────────┘     └──────┬──────┘
                                                     │
                                                     ▼
┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│   Client    │◀────│   State View     │◀────│   Events    │
│   (query)   │     │  reduce(s,e)     │     │  (stream)   │
└─────────────┘     └──────────────────┘     └─────────────┘

1. Client sends a command to a State Change
2. State Change validates the command and emits events (or rejects)
3. Events are atomically stored with bi-temporal indexes
4. State Views incrementally materialize queryable projections
5. Client queries State Views or raw events

Who Is This For?

EvidentSource is designed for:

• Application developers building line-of-business systems who want less infrastructure
• Teams with compliance requirements (finance, healthcare, government) who need audit trails
• Organizations adopting event-driven architecture who want a simpler foundation
• AI agents building or consuming event-sourced systems

Next Steps

import { LinkCard, CardGrid } from ‘@astrojs/starlight/components’;