Kurrent Platform

Event-Centric Data Platform

For Event Sourcing

For Event-Driven Architecture

For Event-Driven Microservices

Replaces Change Data Capture

Zero-Code Outbox

Built-in Stream Processing

(Almost) no Impedance Mismatch

Get Started Run locally

For Event Sourcing

KurrentDB was originally built to support event sourcing. It is designed to store events in individual event streams, which can be replayed to rebuild the state of the system at any point in time. KurrentDB maintains a globally-ordered immutable log of events with an index by stream. It allows lock-free append operations and fast retrieval of events per stream or across streams.

For Event-Driven Architecture

In event-driven environments, KurrentDB serves both as the source and destination for events. It can be used to store events produced by services and to trigger actions in response to events. KurrentDB supports message distribution out of the box using connectors and persistent subscription which eliminates the need for additional infrastructure, such as message brokers.

For Event-Driven Microservices

Using events for persisting state changes allows services to be decoupled and to evolve independently. Events that are being persistent in the database, can be either directly consumed real-time by other microservices, or transformed in a stream processing pipeline to create new events or update materialized views.

Replaces Change Data Capture

KurrentDB eliminates the need for Change Data Capture (CDC) tools, which are used to capture and propagate data changes in real-time. When state changes are represented as events, subscribing to receive those events provides direct access to state changes.

Zero-Code Outbox

Many event-driven systems use the Transactional Outbox pattern to ensure that events are published in the same transaction as the state changes. KurrentDB provides a zero-code outbox, where events stored in the same database are the state changes. You won't need an outbox table or use additional libraries to manage the outbox.

Built-in Stream Processing

KurrentDB provides built-in stream processing capabilities to process events in real-time, directly in the database. You can see it as stream processing stored procedures triggered by new events. The custom projections feature allows transforming events into new events, create semantic links to original events in new streams, or updating materialized views in real-time using JavaScript code running on the server.

(Almost) no Impedance Mismatch

When working with relational databases, there's a mismatch between the way data is stored in the database and the way it's used in the application. KurrentDB offers storing state changes as events, which are simple objects that only need to be serializable to be stored and retrieved.

KurrentDB

Event-Native Database

Event-based data model reflects business processes, aligning persistence with your domain model. Gain full insight on how your data changes over time. Avoid complex ORM frameworks, outboxes and change data capture. Stream events directly from the database.

Learn the KurrentDB basics

// OrderOpened
{
  "customerId": "cu-730"
}

// ItemAdded
{
  "productId": "prod-9110",
  "count": 2,
  "price": 99.99
}

// ItemRemoved
{
  "productId": "prod-9110",
  "count": 1
}

// DiscountApplied
{
  "code": "WELCOME!",
  "amount": 10
}

// PaymentReceived
{
  "amount": 89.99,
  "fullyPaid": true
}

Docs

Reference manuals, tutorials, and code samples - all in one place to help you deploy, configure, and run KurrentDB and build applications using supported clients.

Documentation

Kurrent Academy

Level up your KurrentDB skills with free courses, covering both application development and database maintenance topics.

Start learning

Community Forum

Join other developers and Kurrent engineers on our Community Forums and Discord to get advice, learn patterns and best practices, and share your projects and experience.

Join the community

Code for everyone

Simple integration

KurrentDB client libraries are available for
Java, .NET, Go, Python, Node.js, and Rust.

  type OrderPaid = JSONEventType<
    "OrderPaid",
    { amountPaid: number; fullyPaid: boolean; }>;

const event = jsonEvent<OrderPaid>({
  id: uuid(),
  type: "OrderPaid",
  data: {
    amountPaid: 89.99,
    fullyPaid: true,
  },
});

await client.appendToStream(`Order-${orderId}`, event, {
  streamRevision: version,
}); 

  var orderCreated = new OrderPaid { AmountPaid = 89.99, FullyPaid = true };

var eventData = MessageData.From(
    "OrderPaid",
    JsonSerializer.SerializeToUtf8Bytes(orderCreated)
);

await client.AppendToStreamAsync(
    $"Order-{orderId}",
    StreamRevision.FromInt64(version),
    [eventData]
); 

  orderPaid = json.dumps(
    {"amountPaid": 89.00, "fullyPaid": True},
).encode("utf8")

event = NewEvent(
    type="OrderPaid",
    data=orderPaid,
)

commit_position = client.append_to_stream(
    stream_name=stream_name,
    current_version=version,
    events=[event],
) 

  ObjectMapper objectMapper = new ObjectMapper();

OrderPaid orderPaid = new OrderPaid(89.00, true);
EventData eventData = EventData
        .builderAsJson(
                UUID.randomUUID(),
                "OrderPaid",
                objectMapper.writeValueAsBytes()
        )
        .build();

AppendToStreamOptions options = AppendToStreamOptions.get()
        .streamRevision(version);

client.appendToStream("Order-" + orderId, options, eventData).get(); 

  data := OrderPaid{
    AmountPaid: 89.99,
    FullyPaid:  true,
}
bytes, err := json.Marshal(data)
if err != nil {
    panic(err)
}

options := kurrentdb.AppendToStreamOptions{
    StreamState: varsion,
}
result, err := db.AppendToStream(context.Background(),
    "Order-"+id, options, kurrentdb.EventData{
    ContentType: kurrentdb.ContentTypeJson,
    EventType:   "OrderPaid",
    Data:        bytes,
}) 