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

(Almost) no Impedance Mismatch

Ensure your application logic aligns natively with stored data. KurrentDB persists state changes as simple, serializable event objects, which eliminates the need for object-relational mapping.

For Event Sourcing

KurrentDB was purpose-built for event sourcing. Store events in individually indexed streams and replay them to reconstruct system state at any moment. Enjoy a globally ordered, immutable event log with lock-free appends and lightning-fast event retrieval per stream or across your entire system.

For Event-Driven Architecture

Seamlessly store, distribute, and react to events with no external message brokers required. With built-in connectors and persistent subscriptions, KurrentDB powers real-time event flows and automates message delivery out of the box.

For Event-Driven Microservices

Decouple, scale, and evolve your microservices. Persist state changes as events, enabling independent service evolution. Events can be consumed in real time or transformed via stream processing pipelines to generate new events or update materialized views.

Replaces Change Data Capture

No more CDC tools or complex infrastructure required. With KurrentDB, state changes are events. Subscribe to the event stream for direct, real-time access to all changes.

Zero-Code Outbox

Outbox pattern with zero code. KurrentDB natively ensures events and state changes are stored atomically and requires no separate outbox tables or extra libraries. Publish events reliably, with zero operational overhead.

Built-in Stream Processing

Process, transform, and semantically link events in real-time directly in your database. Think of it as stored procedures for event streams: triggered by new data, executed in-database, and optimized for millisecond-level latency.

KurrentDB

Event-Native Database

Model your business processes, not just the state of your business. KurrentDB's event-native data model directly reflects your domain model. Skip the complexity of ORMs, outboxes, and CDC. Gain complete visibility into how your data evolves, and stream events in real time—straight from the source.

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,
}) 