Chronacta — a self-hosted event store

A server for systems built with Event Sourcing

Record changes as domain events and reconstruct aggregate state from their sequence. Chronacta provides event streams, optimistic concurrency, subscriptions, and projections—all in your infrastructure.

APPLICATIONPlaceOrdercommand · order-42appendCHRONACTA · EVENT STOREstream orders-42v1OrderPlacedv2ItemAddedv3PaymentAuthv4OrderShippedprojectREAD MODELorders_list · rebuildable
01

A purpose-built event store

The API is built around streams and versions, so you do not have to implement event-store operations on top of a general-purpose database.

02

Conflicting writes surface immediately

Appends carry an expected stream version. If the stream has already changed, Chronacta rejects the write so the application can handle the conflict explicitly.

03

Read models from the same history

Projections prepare data for queries. When projection logic changes, derived models can be rebuilt from the stored events.

04

Deployment under your control

Chronacta runs on infrastructure you manage. The open single-node edition covers one host; Enterprise adds high availability and broader operational tooling.

Event storage, subscriptions, and projections

Chronacta is an event-store server. Your application handles commands and enforces aggregate invariants; Chronacta stores the resulting events and makes them available to readers, projections, and subscribers.

Versioned streams

Store events in ordered streams. Use stream versions for optimistic concurrency and idempotency keys when retrying appends.

Reads and subscriptions

Read one stream or the global event log. Use durable subscriptions to retain consumer progress across restarts.

Projections and replay

Process stored events to build read models. Replay the relevant history to rebuild derived data.

Deployment and operations

Start with Chronacta on one node. Enterprise adds high availability, security integrations, and broader operational tooling.

When the event sequence is part of the model

With Event Sourcing, events are the source of truth, not an additional audit record. The application derives aggregate state from those events, while projections build read models for queries. This approach is useful when domain transitions matter to the system.

Orders and fulfillment

Model order placement, line changes, cancellations, and shipments as distinct domain events governed by aggregate invariants.

Payments and accounts

Represent financial operations explicitly and derive balances or other read models from the recorded events.

Cases and workflows

Reconstruct the transitions that led to a case's current state and apply domain rules to subsequent commands.

Multiple query models

Build lists, reports, and search indexes from the same event history without changing the aggregate's event stream.

From a command to a read model

A command handler receives a request to ship an order. It loads the order aggregate, reconstructs its state from events, and asks the aggregate to validate the operation. If the rules allow shipment, the application appends OrderShipped with the expected stream version. Chronacta records the event. A projection updates the order list, and a subscriber can notify another service.

Command
Domain decision
Domain event
Event store
Projection
A command reaches the application → the application applies domain rules and produces events → Chronacta appends them to a stream → projections build read models for queries.

Domain rules remain in the application. Chronacta provides the storage and delivery mechanisms needed to use domain events as the source of truth.

Implement one aggregate end to end

Start with a concrete domain operation and test the complete path from a command to an updated read model.

  1. 1. Define the domain model

    Identify the aggregate, its invariants, the commands it accepts, and the events that describe its state transitions.

  2. 2. Connect Chronacta

    Run the server, append events with an expected version, and reconstruct aggregate state by reading the stream.

  3. 3. Add a projection and a subscriber

    Build a read model for queries. Test consumer restarts, duplicate delivery, and rebuilding derived data.

  4. 4. Choose your deployment

    Evaluate capacity, recovery, and availability requirements. Stay on Chronacta or consider Enterprise according to those requirements.