Abstract

The enterprise data infrastructure landscape is undergoing a structural paradigm shift, moving from static, state-based persistence models toward dynamic, event-driven architectures. This transition is necessitated by the increasing demand for real-time analytics, auditability, and the contextual requirements of Artificial Intelligence (AI) systems. Within this evolving ecosystem, Kurrent.IO—formerly known as Event Store—has emerged as a foundational architect of the “Event-Native” data platform category. This report provides an exhaustive analysis of Kurrent’s strategic trajectory following its December 2024 rebranding and capital injection. It examines the company’s evolution from a niche provider of Event Sourcing databases to a comprehensive enterprise platform, analyzing its technical architecture, leadership composition, market positioning against incumbents like Apache Kafka and PostgreSQL, and its application in critical industrial use cases. The analysis suggests that Kurrent is positioning itself not merely as a database, but as the “Context Engine” for the modern enterprise, bridging the gap between operational transaction processing and the historical intelligence required by autonomous agents.

1. Introduction: The Structural Transformation of Data Persistence

To understand the strategic significance of Kurrent.IO, one must first contextualize the historical and technical trajectory of data persistence mechanisms. For decades, the relational database management system (RDBMS) has served as the bedrock of enterprise software. Predicated on the theories of E.F. Codd, the RDBMS organizes data into normalized tables, optimized for storage efficiency and transactional integrity (ACID). However, as software architectures have evolved from monolithic structures to distributed microservices, and as business requirements have shifted from simple record-keeping to predictive analytics, the limitations of the relational model have become increasingly acute.

1.1 The Limitations of State-Oriented Persistence

Traditional databases—whether relational (SQL) or document-based (NoSQL)—are fundamentally “state-oriented.” They persist the current state of an entity while discarding the history of how that state was reached. When a user updates a customer’s address or changes an order status from “Pending” to “Shipped,” the database typically overwrites the previous value. This operation is destructive by design. While effective for conserving storage in the hardware-constrained environments of the 1980s, this approach creates a “Context Gap” in modern applications.1

In a state-oriented system, answering the question “What is the current status of Order #123?” is trivial. However, answering “How long did Order #123 spend in the ‘Packaging’ stage compared to the ‘Shipping’ stage?” or “Who modified the order payload three weeks ago?” requires complex, bolt-on solutions. Developers often resort to maintaining separate audit logs or implementing Change Data Capture (CDC) pipelines, which introduce architectural fragility and data latency.2

1.2 The Object-Relational Impedance Mismatch

Furthermore, modern software engineering is dominated by Object-Oriented Programming (OOP) and Domain-Driven Design (DDD), where business logic is encapsulated in rich, hierarchical objects. Relational databases, conversely, require data to be flattened into two-dimensional tables. This discrepancy creates the “Object-Relational Impedance Mismatch,” forcing developers to build complex translation layers (Object-Relational Mappers or ORMs) that degrade performance and complicate schema evolution.1

The industry’s initial response to these limitations was the “NoSQL” revolution, which addressed the impedance mismatch by storing data as documents (JSON). However, most NoSQL stores remained state-oriented, overwriting data and failing to capture the temporal dimension of business processes. The subsequent rise of “Streaming” platforms, led by Apache Kafka, introduced the concept of the immutable log. Yet, these platforms were designed for “data in motion”—transient messaging—rather than long-term “data at rest” with granular retrieval capabilities.5

1.3 The Event-Native Paradigm

It is within this gap—between the storage capabilities of a database and the temporal fidelity of a log—that the “Event-Native” category has emerged. Kurrent.IO represents the crystallization of this category. By treating “Events” (immutable records of something that happened) as the primary unit of storage, Kurrent aims to resolve the impedance mismatch and the context gap simultaneously. In this paradigm, the database does not store the current state; it stores the sequence of events that led to the current state. The state is effectively a derivative of the history, calculable at any point in time.1 This architectural shift is not merely technical; it represents a fundamental reorientation of how enterprises value data, prioritizing the narrative of business operations over the mere snapshot of their results.

2. Corporate Genesis and Strategic Metamorphosis

Kurrent.IO’s market position today is the result of a decade-long evolution from a developer-centric tool to an enterprise-grade platform. This journey reflects the broader maturation of Event Sourcing from an academic pattern to a mainstream architectural standard.

2.1 Origins: The Greg Young Era and Event Store

The company was originally founded as Event Store in 2012 (formalized in 2019) by Greg Young, a seminal figure in the software architecture community known for formalizing the Command Query Responsibility Segregation (CQRS) pattern.1 For the first decade of its existence, the company focused intensely on the technical purity of its database, EventStoreDB. It catered to a highly sophisticated audience of backend developers and architects who subscribed to Domain-Driven Design (DDD) principles. The product was revered for its stability and adherence to functional programming concepts but remained a niche player in the broader data market.1

2.2 The 2024 Rebrand: From Storage to Current

In December 2024, the company executed a comprehensive rebranding, changing its name from Event Store to Kurrent.IO. This nomenclature shift was strategic rather than cosmetic. The name “Event Store” implied a passive repository—a warehouse where data is deposited and retrieved. “Kurrent,” conversely, evokes the dynamics of flow, energy, and immediacy. CEO Kirk Dunn articulated that the new identity represents data flowing “like electrical current through an enterprise”.7

This rebrand addresses a critical perception issue. In the modern data stack, value is increasingly associated with streaming and activation rather than storage. By positioning itself as “Kurrent,” the company signals that its platform is not just a vault for historical data but an active distribution system that “originates, aggregates, curates, and streams” data to the point of need.7

2.3 Capital Injection and Series A Extension

Coinciding with the rebrand, Kurrent announced a $12 million funding round led by Crane Venture Partners, with participation from Creandum.9 While the quantum of capital is modest compared to the massive rounds seen in the vector database or LLM spaces, its strategic allocation is notable. The funding is explicitly earmarked for scaling engineering operations and accelerating the “enterprise” go-to-market motion.10

Crane Venture Partners’ investment thesis centers on Kurrent’s ability to unlock “context-rich data events,” solving the integration challenges between state-based and event-based systems.7 This endorsement from the venture capital community validates the premise that the market is ready to move beyond the dichotomy of “Database vs. Stream” toward a unified Event-Native platform.

2.4 Leadership Transformation: The “Big Data” Alumni

A critical driver of Kurrent’s recent acceleration is the complete restructuring of its executive leadership team. The composition of the C-suite suggests a deliberate strategy to replicate the scaling successes of the “Big Data” era (Hadoop/Cloudera).

• Kirk Dunn (CEO): Appointed in October 2023, Dunn served as the COO of Cloudera from 2011 to 2015, a period that defined the early Big Data revolution. His background suggests a focus on operational rigor, enterprise sales cycles, and navigating the transition from open-source project to commercial software vendor.7
• David Wang (VP of Engineering): Another Cloudera veteran who led storage teams, Wang brings deep expertise in distributed systems and storage engineering. His role is pivotal in ensuring that KurrentDB can meet the scalability and reliability demands of Fortune 500 environments.7
• Rick Gustafson (CFO): Gustafson’s background is rooted in guiding high-growth SaaS companies through financial maturation and exit events. Having served as CFO of ServiceMax during its $1 billion acquisition by GE Digital, his presence indicates a roadmap focused on robust financial structuring, likely targeting a future IPO or strategic acquisition.13
• Patrick Ball (CRO): Patrick Ball’s appointment as Chief Revenue Officer introduces a rigorous, methodology-driven sales culture. Ball is a proponent of the “MEDDIC” sales qualification framework and has been featured on the “Hunters and Unicorns” podcast, which chronicles the playbooks of elite sales leaders. His philosophy emphasizes “winning the week” and building a “revenue machine” by recruiting top-tier talent and enforcing disciplined sales processes.15 This signals a shift away from “product-led growth” (where developers adopt the tool organically) toward “sales-led growth” targeting C-level decision-makers.
• Alexey Zimarev (Head of Product): Crucially, the company has retained deep technical DNA in Alexey Zimarev. A recognized authority on DDD and the author of “Hands-on Domain-Driven Design with.NET Core,” Zimarev bridges the gap between the new business-focused leadership and the platform’s technical user base. His continued leadership ensures that the product roadmap remains aligned with the needs of architects and developers.11

3. Theoretical Framework and Problem Space

To appreciate the architectural decisions made by Kurrent, one must deeply understand the theoretical problems it aims to solve. The platform is not merely a faster database; it is an opinionated answer to fundamental flaws in how software has traditionally modeled the world.

3.1 The Destructive Nature of CRUD

Standard applications typically use Create, Read, Update, Delete (CRUD) operations. The “Update” and “Delete” operations are inherently destructive data management practices.

• Scenario: A customer changes their shipping address.
• CRUD Approach: The database finds the row for Customer_ID: 101 and overwrites the content of the Address column. The old address is permanently lost.
• The Consequence: If a business analyst later asks, “Did the customer change their address before or after the promotional mailer was sent?”, the system cannot answer. The context is gone.

Kurrent fundamentally rejects the concepts of “Update” and “Delete.” In an Event-Native system, data is only ever Appended. A change of address is recorded as a new event (AddressChanged), appended to the customer’s stream. The current state is simply the sum of all events. This ensures Zero Data Loss and provides a perfect, immutable audit trail by default.1

3.2 Solving the Impedance Mismatch

As previously noted, the mismatch between Object-Oriented code and Relational tables is a massive source of friction. Developers spend significant time writing “glue code” to map objects to tables.

• Kurrent’s Solution: Kurrent stores events as JSON objects. These events naturally map to the domain events occurring in the software code. If the code emits an OrderPlaced event, Kurrent stores that exact JSON payload. There is no complex mapping layer, no schema migration required for the database tables, and the storage model aligns perfectly with the mental model of the developer.1

3.3 The Dual-Write Problem

In modern microservices, a service often needs to do two things when an action occurs:

1. Update its own database (Persistence).
2. Notify other services via a message broker like RabbitMQ or Kafka (Notification).

Doing these two things atomically is notoriously difficult. If the database update succeeds but the message broker is down, the system is inconsistent. This is known as the “Dual-Write Problem.”

Kurrent resolves this via the Zero-Code Outbox pattern. Because the database is a log of events, the “write” to the database and the “message” to the stream are the same thing. Other services simply subscribe to the database append log. There is no need for a separate outbox table or complex two-phase commit protocols.21

4. Product Architecture and Technical Innovation

Kurrent’s platform is anchored by KurrentDB (formerly EventStoreDB), a specialized database engine built from the ground up for Event Sourcing. Unlike databases that run on top of generic storage engines (like RocksDB or SQL), KurrentDB uses a custom log-structured storage engine optimized for sequential writes and random reads of streams.

4.1 Core Database Engine Capabilities

The architecture of KurrentDB is designed to handle the specific access patterns of event-sourced applications:

• Streams as First-Class Citizens: Data is organized into “Streams.” Each entity (e.g., Order-123) has its own stream. This allows for extremely efficient retrieval of a single entity’s history. KurrentDB supports billions of individual streams, a feat that would cripple a system like Kafka (which is designed for a small number of heavy topics).22
• Optimistic Concurrency Control: KurrentDB uses version numbers for every event in a stream. When an application attempts to append a new event, it specifies the “expected version.” If the stream has been modified by another process in the interim, the write is rejected. This provides strong consistency guarantees at the entity level, critical for financial transactions.1
• Projections Subsystem: One of Kurrent’s most distinct features is its internal Projections engine. This allows developers to write JavaScript functions that run inside the database node. These functions can monitor streams in real-time and aggregate data into new streams or state representations. This effectively brings “Stream Processing” directly to the storage layer, reducing network traffic and latency.23

4.2 KurrentDB 26: The Connectivity Release

With the release of KurrentDB 26 in late 2024/early 2025, the company shifted focus from isolation to integration. Acknowledging that it exists within a heterogeneous data landscape, Kurrent introduced features to play nicely with others:

• Native Kafka Source Connector: This allows KurrentDB to ingest data from Kafka. It enables Kurrent to act as a long-term storage and index layer for data that originates in the ephemeral world of Kafka topics. This is crucial for enterprises that have already standardized on Kafka for data transport but lack a good way to query historical data.25
• Relational Sink: This feature automatically projects data from KurrentDB into traditional SQL tables (PostgreSQL, SQL Server). This is a pragmatic concession to the reality of the enterprise: while the core application may be event-native, the Business Intelligence (BI) teams use Tableau or PowerBI, which speak SQL. This feature automates the “Read Model” generation, bridging the gap between Event Sourcing and traditional analytics.25
• Custom Indices: KurrentDB 26 introduced the ability to reorganize and index events by custom properties without changing the application code. This allows for more flexible querying patterns beyond the primary stream ID.25

4.3 Kurrent Cloud and Managed Operations

To support enterprise adoption, the company offers Kurrent Cloud, a fully managed Database-as-a-Service (DBaaS) available on AWS, Azure, and Google Cloud Platform (GCP).

• Operational Abstraction: Kurrent Cloud removes the burden of managing clusters, backups, and upgrades. It includes automated provisioning and scaling, allowing teams to focus on application logic rather than infrastructure plumbing.26
• Security: The managed service is SOC2 Type II certified and ISO 27001 compliant. It includes features like encryption at rest, role-based access control (RBAC), and private networking links, meeting the rigorous standards of Kurrent’s financial services clientele.26
• Automated Scavenge: In the Enterprise edition, the system handles “scavenging”—the process of reclaiming disk space from deleted or expired events—automatically across the cluster. This prevents the performance degradation that can occur if multiple nodes attempt to scavenge simultaneously.9

5. The AI Frontier: Contextual Intelligence and the MCP Server

Perhaps the most forward-looking aspect of Kurrent’s strategy is its aggressive pivot toward Generative AI. The leadership team has identified a critical flaw in the current AI stack: Large Language Models (LLMs) are stateless. They rely on “Context Windows” to understand the world.

5.1 The Context Gap in AI

When an AI agent interacts with a database, it typically sees a snapshot. If an AI customer service agent queries a standard database for a customer, it sees “Current Sentiment: Angry.” It does not know why. It missed the sequence of events: “Package Delayed” -> “Customer Called” -> “Call Dropped.” Without this narrative, the AI cannot empathize or problem-solve effectively.

Kurrent positions itself as the Long-Term Memory for AI. Because it stores the entire sequence of interactions, it can feed the AI the full story, not just the final chapter.28

5.2 The KurrentDB MCP Server

To operationalize this, Kurrent launched the Open Source Model Context Protocol (MCP) Server.29 This tool acts as a bridge between KurrentDB and frontier AI models like Claude, GPT-4, and Gemini.

• Natural Language Interaction: The MCP Server allows developers and AI agents to interact with the database using natural language. A user can ask, “Show me the sequence of events that led to the system outage,” and the agent can query the event log directly.30
• Agentic Workflows: The server supports “Agentic” capabilities, where the AI can autonomously create and test projections. If a developer asks the AI to “create a projection that summarizes daily sales,” the AI can generate the JavaScript code, deploy it to KurrentDB, test it against live data, observe errors, and self-correct the code without human intervention. This dramatically lowers the barrier to entry for complex event processing logic.30
• Time-Travel Debugging for AI: Because Kurrent supports “time travel” (replaying events to any point in time), AI agents can simulate different outcomes or debug complex logic by replaying historical scenarios. This capability is unique to event-native platforms.3

6. Market Positioning and Competitive Landscape

Kurrent operates in a crowded and noisy data infrastructure market. Its success depends on clearly differentiating itself from both the “Streaming” giants and the “Database” incumbents.

6.1 Kurrent vs. Apache Kafka

The most frequent confusion in the market is between Kurrent and Kafka. Both deal with “streams” of events, but their architectural goals are orthogonal.

• Apache Kafka (Data in Motion): Kafka is a distributed log designed for high-throughput message buffering and transport. It is optimized for moving data from Point A to Point B. While it has “retention” capabilities, it is not indexed for granular random access. Asking Kafka to “Give me the history of Customer #543” involves scanning partitions, which is inefficient. Kafka is the “Pipe”.6
• Kurrent (Data at Rest + Motion): Kurrent is a database. It indexes streams by ID. It is designed to be the “System of Record.” Kurrent can serve the history of Customer #543 in milliseconds. Kurrent is the “Bucket” that also allows you to watch the water flow.
• Symbiosis: Kurrent’s strategy is to coexist. KurrentDB 26’s connectors position Kurrent as the perfect complement to Kafka: Kafka handles the firehose of ingestion, and Kurrent acts as the persistent store that indexes and archives that data for granular application access.25

6.2 Kurrent vs. Relational Databases (PostgreSQL)

• PostgreSQL: The default choice for most applications. It excels at SQL queries and relationships. However, implementing Event Sourcing in Postgres requires building a custom “Event Store” table and managing the append logic manually. This is error-prone and lacks the streaming subscriptions and projection engines native to Kurrent.31
• Kurrent’s Advantage: Kurrent provides the infrastructure for Event Sourcing out of the box (concurrency control, subscriptions, projections).
• Coexistence: Through the “Relational Sink” and CQRS patterns, Kurrent recommends using itself for the “Write Side” (Command) and projecting data into PostgreSQL for the “Read Side” (Query), utilizing the best of both worlds.31

6.3 Kurrent vs. Niche Competitors (Axon Server)

• Axon Server: A strong competitor in the Java ecosystem, Axon Server is tightly coupled with the Axon Framework. It offers a seamless experience for Java developers but locks them into a specific framework and language ecosystem.32
• Kurrent: Kurrent positions itself as “Polyglot” and “Infrastructure-First.” It supports.NET, Java, Python, Go, Node.js, and Rust via gRPC. It does not dictate application framework choices, making it more adaptable to heterogeneous microservices environments.34

Table 1: Comparative Analysis of Event Data Platforms

Feature Set	KurrentDB	Apache Kafka	PostgreSQL	Axon Server
Primary Category	Event-Native Database	Streaming Platform	Relational Database	Java Event Store
Storage Model	Immutable Event Log	Distributed Commit Log	Mutable Tables	Immutable Event Log
Indexing Strategy	Fine-grained (per entity)	Coarse-grained (partitions)	B-Tree / Hash	Aggregate Identifier
Random Access	Millisecond retrieval	Inefficient (Scan required)	Extremely Fast	Fast (Java optimized)
Language Support	Polyglot (gRPC)	Polyglot	Polyglot	Java / JVM Focused
Data Retention	Permanent (Default)	Time/Size based	Current State Only	Permanent
Query Capability	Projections (JS)	KSQL / Flink	Full SQL	Java Queries
AI Integration	Native MCP Server	Via Connectors	Vector Extensions	Via Framework

7. Enterprise Case Studies: The Event-Native Advantage

The theoretical benefits of Kurrent are best understood through its deployment in high-stakes enterprise environments. The following case studies illustrate how “Event-Native” architectures solve problems that traditional databases cannot.

7.1 Holcim: Revolutionizing Global Logistics

Holcim, a global leader in sustainable building solutions, faced a critical operational bottleneck in its cement distribution network.

• The Challenge: Holcim’s legacy credit system ran on SAP, utilizing overnight batch processing. This meant that customer payments made today would not reflect in their credit balance until tomorrow. In cash-based markets like Africa, this latency caused significant friction; customers would pay a cashier but be refused entry to the cement depot because the system hadn’t updated.24
• The Architecture: Holcim utilized KurrentDB to build a “Side-Car” solution. They kept SAP as the master ledger for financial reporting but used KurrentDB to ingest real-time payment events and calculate a live “Credit Available” balance.
• The Solution: KurrentDB integrated with MuleSoft and local applications (Roots, Zonda, LeadRetail) to create a “Data Connected Backbone.” Kurrent served as the real-time source of truth, decoupled from the slow SAP batch cycles.24
• The Outcome:

• Latency Reduction: Moved from 24-hour delays to real-time credit updates.
• 24/7 Availability: The system operates independently of SAP maintenance windows, ensuring zero downtime for sales.
• Trust: In manual markets, the system eliminated the need for physical proof of payment, automating the release of goods and building trust with distributors.
• Reliability: The application ran for a full year across 11 countries with zero incidents.24

7.2 Wiser Solutions: Trust Through Traceability

Wiser Solutions (formerly utilizing technology from Vispera) provides retail pricing intelligence. They scrape millions of data points to recommend pricing strategies to retailers.

• The Challenge: Pricing recommendations are high-stakes. If Wiser recommends a price drop, the retailer loses margin. Retailers demanded to know why a specific price was recommended. In a traditional DB, the old data that triggered the algorithm might have been overwritten by newer scrapes.36
• The Solution: Wiser adopted KurrentDB to store the full history of every data point (competitor prices, stock levels) as an immutable stream.
• The Outcome: This enabled “Traceability.” Wiser could replay the exact state of the market at the moment the recommendation was made. They could prove to clients, “We recommended this price because at 10:00 AM, Competitor X dropped their price, and your rule set dictates we match them.” This transparency was critical for building client trust in the algorithm.37

7.3 Linedata: Deconstructing the Monolith

Linedata, a financial software provider, utilized Kurrent to modernize its asset management platform.

• The Challenge: Linedata needed to transition from a monolithic architecture to cloud-native microservices without losing transactional integrity.
• The Solution: By adopting Event Sourcing with Kurrent, Linedata decoupled their services. The “Write” service could process high-speed transactions, while asynchronous “Read” services could subscribe to the event stream to perform heavy analytics and reporting without slowing down the core engine.
• The Outcome: This “CQRS” approach allowed them to scale the read and write workloads independently, improving agility and enabling them to deploy new features (new projections) without bringing down the system.39

8. Open Source Strategy and Education

Kurrent maintains a delicate balance between its open-source roots and its commercial ambitions.

8.1 ESLv2 and the Single Binary

Kurrent distributes its software under the Event Store License v2 (ESLv2). This model is designed to prevent cloud hyperscalers (like AWS or Azure) from offering KurrentDB as a service without contributing back, a common defensive move in the modern open-source database market (similar to MongoDB’s SSPL).

Crucially, Kurrent utilizes a “Single Binary” distribution. The Open Source and Enterprise editions are the exact same piece of software. Enterprise features (like LDAP support, automated scavenging, and connectors) are unlocked via a license key. This simplifies the upgrade path significantly; engineering teams can build on the free version and upgrade to Enterprise in production instantly without migration or downtime.9

8.2 Kurrent Academy and Developer Enablement

Recognizing that Event Sourcing has a steep learning curve, the company has invested heavily in Kurrent Academy. This educational platform offers structured certification paths and courses.

• Curriculum: Courses range from “Kurrent Essentials” (Introduction to Event Sourcing) to advanced topics like “Securing KurrentDB” and “Working with CDC Pipelines”.42
• Target Audience: The content targets not just developers but also architects and operations teams, aiming to build a broad ecosystem of certified professionals who advocate for the platform within their organizations.42
• Strategic Intent: By offering these resources for free (or low cost), Kurrent aims to reduce the “cognitive impedance mismatch” that hinders adoption. The more developers who understand how to think in events, the larger the total addressable market for the platform becomes.21

9. Conclusion

The transformation of Event Store into Kurrent.IO represents more than a rebranding exercise; it signals the maturation of the event-native data category. For a decade, Kurrent incubated the technology of Event Sourcing within a niche community of domain-driven design experts. Now, fueled by new capital, a leadership team seasoned in the fires of the Big Data era, and a market hungry for real-time context, Kurrent is crossing the chasm into the enterprise.

The platform’s architectural innovations—specifically the unification of database and streaming semantics, the integration of stream processing (projections) into the storage layer, and the bridge to AI via the MCP Server—position it uniquely in the market. It offers a solution to the “Impedance Mismatch” that has plagued software development for thirty years and provides the “Contextual Memory” required for the next generation of AI agents.

While challenges remain—specifically the educational hurdle of teaching developers to think in events rather than tables—the successes of Holcim, Wiser, and Linedata demonstrate that the “Event-Native” model delivers tangible operational advantages in terms of speed, auditability, and resilience. As enterprises increasingly demand systems that can explain why something happened rather than just what happened, Kurrent’s immutable, time-travel-capable platform stands as a critical pillar of the modern data stack.

Citations

9 Kurrent.IO Rebrand Press Release

10 Kurrent Funding Announcement

7 HPCWire: Event Store Changes Name to Kurrent

28 Kurrent $12M Funding and Use Cases

7 Crane Venture Partners Investment Thesis

36 Wiser Solutions Case Study

42 Kurrent Academy Course Details

24 Holcim Use Case Operational Details

24 Holcim Benefits Analysis

24 Holcim Case Study Overview

11 Kurrent Leadership Team

12 Leadership Backgrounds

15 Patrick Ball Sales Methodology

16 Selling Sherpa: Hunters and Unicorns

17 Patrick Ball on MEDDIC

18 Patrick Ball Profile

39 Linedata Case Study

21 Linedata Quote

8 CEO Kirk Dunn on Rebrand

37 Vispera/Wiser Customer Quote

38 Wiser VP Engineering Quote

21 Zero-Code Outbox Feature

4 Impedance Mismatch Explanation

1 Event Sourcing Principles

42 Kurrent Academy

23 Kurrent Foundations Training

21 Kurrent Community Resources

41 ESLv2 Licensing Details

5 Kafka vs. EventStoreDB Whitepaper

29 Kirk Dunn on AI and Future

30 Kurrent MCP Server Launch

26 Kurrent Cloud Features

19 Alexey Zimarev Background

20 Alexey Zimarev Bio

13 Rick Gustafson CFO Background

14 Rick Gustafson SEC Filing

32 Axon Server Release Notes

34 GitHub Best of Django (Kurrent Mention)

6 Kurrent vs. Kafka Blog

27 Kurrent Enterprise Features

2 Benefits of Event Sourcing

26 AWS Marketplace Kurrent Listing

40 Linedata Case Study PDF

24 Holcim Logistics Use Case

3 Event Sourcing Implementation Blog

25 KurrentDB 26 Release Notes

6 KurrentDB vs. Kafka Technical Comparison

22 DB-Engines KurrentDB Profile

25 KurrentDB 26 Kafka Connector

43 Event Store vs. MongoDB Blog

33 SoftwareMill Storage Comparison

35 Kurrent Python Client

31 Kurrent vs. PostgreSQL Comparison

44 Kurrent Rebrand News

Works cited

1. What is Event Sourcing? – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/resources/eventsourcing/what-is-event-sourcing/
2. Benefits Of Event Sourcing – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/blog/benefits-of-event-sourcing/
3. EventStoreDB Implementation With Event Sourcing – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/blog/eventstoredb-implementation-with-event-sourcing
4. Streamline Distributed Application Development with Kurrent, accessed December 19, 2025, https://www.kurrent.io/use-cases/streamline-application-development-with-kurrent
5. Whitepaper: A new database technology transforming the fintech industry – Kurrent, accessed December 19, 2025, https://www.kurrent.io/whitepaper-a-new-database-technology-transforming-the-fintech-industry
6. Building a scalable and reliable event-driven architecture with KurrentDB and Kafka, accessed December 19, 2025, https://www.kurrent.io/blog/eventstoredb-kafka/
7. Event Store Changes Name to Kurrent, Raises $12M to Unify Streams and Databases – BigDATAwire – HPCwire, accessed December 19, 2025, https://www.hpcwire.com/bigdatawire/2024/12/18/event-store-changes-name-to-kurrent-raises-12m-to-unify-streams-and-databases/
8. Event Store Changes Name to Kurrent, Raises $12M to Unify Streams and Databases, accessed December 19, 2025, https://www.kurrent.io/press/event-store-changes-name-to-kurrent-raises-12m-to-unify-streams-and-databases
9. Kurrent, Previously Event Store, Garners $12M and Debuts …, accessed December 19, 2025, https://www.kurrent.io/press/kurrent-previously-event-store-garners-12m-and-debuts-enterprise-edition-of-its-event-native-platform
10. Kurrent Charges Forward with $12 Million for Event-Native Data Platform, accessed December 19, 2025, https://www.kurrent.io/press/kurrent-charges-forward-with-12-million-for-event-native-data-platform
11. About Kurrent, accessed December 19, 2025, https://www.kurrent.io/about
12. What Does Kurrent (formerly Event Store) Do? | Directory – PromptLoop, accessed December 19, 2025, https://www.promptloop.com/directory/what-does-kurrent-formerly-event-store-do
13. Chain Bridge I – SEC.gov, accessed December 19, 2025, https://www.sec.gov/Archives/edgar/data/1845149/000110465922035218/cbrgu-20211231x10k.htm
14. tm216424-5_s1a – block – 18.7813595s – SEC.gov, accessed December 19, 2025, https://www.sec.gov/Archives/edgar/data/1845149/000110465921049030/tm216424-5_s1a.htm
15. Patrick Ball – Hunters + Unicorns, accessed December 19, 2025, https://huntersandunicorns.com/patrick-ball/
16. Hunters + Unicorns 33 CxOs (podcast summary) – SellingSherpa, accessed December 19, 2025, https://sellingsherpa.com/index.php/2023/03/03/hunters-and-unicorns-podcast-summary/
17. Hunters + Unicorns: The 33 CxOs – The John McMahon Interview #003 – YouTube, accessed December 19, 2025, https://www.youtube.com/watch?v=nHUbnx3s2MM
18. Hunters + Unicorns: The 33 CxOs – Patrick Ball #004 – YouTube, accessed December 19, 2025, https://www.youtube.com/watch?v=7btmE-4m5No
19. Hands-On Domain-Driven Design with .NET Core | Programming | Paperback – Packt, accessed December 19, 2025, https://www.packtpub.com/en-us/product/hands-on-domain-driven-design-with-net-core-9781788834094?type=print
20. Event Sourcing and CQRS – Event Store Blog – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/blog/event-sourcing-and-cqrs
21. Kurrent – event-native data platform, accessed December 19, 2025, https://www.kurrent.io/
22. KurrentDB (aka EventStoreDB) System Properties – DB-Engines, accessed December 19, 2025, https://db-engines.com/en/system/KurrentDB+%28aka+EventStoreDB%29
23. Kurrent Foundations, accessed December 19, 2025, https://academy.kurrent.io/foundations-live-training
24. Holcim Developed An Innovative Credit Solution With EventStoreDB, accessed December 19, 2025, https://www.kurrent.io/case-studies/holcim
25. KurrentDB 26 Streamlines AI and Analytics Integration with Native Connectors – BigDATAwire – HPCwire, accessed December 19, 2025, https://www.hpcwire.com/bigdatawire/this-just-in/kurrentdb-26-streamlines-ai-and-analytics-integration-with-native-connectors/
26. AWS Marketplace: Kurrent Cloud, formerly Event Store Cloud – Amazon.com, accessed December 19, 2025, https://aws.amazon.com/marketplace/pp/prodview-kxo6grvoovk2y
27. Kurrent, Previously Event Store, Garners $12M and Debuts Enterprise Edition of its Event-Native Platform – Database Trends and Applications, accessed December 19, 2025, https://www.dbta.com/Editorial/News-Flashes/Kurrent-Previously-Event-Store-Garners-12M-and-Debuts-Enterprise-Edition-of-its-Event-Native-Platform-167393.aspx
28. Kurrent Raises $12M in Funding, accessed December 19, 2025, https://www.kurrent.io/press/finsmes-kurrent-raises-12m-in-funding
29. The Future Is Now: Kirk Dunn of Kurrent On How Their Technological Innovations Will Shake Up The Tech Scene | by Authority Magazine Editorial Staff – Medium, accessed December 19, 2025, https://medium.com/authority-magazine/the-future-is-now-kirk-dunn-of-kurrent-on-how-their-technological-innovations-will-shake-up-the-a70a59c5c693
30. Kurrent launches open source MCP Server – SD Times, accessed December 19, 2025, https://sdtimes.com/agentic-ai/kurrent-launches-open-source-mcp-server/
31. KurrentDB and PostgreSQL – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/blog/comparing-eventstoredb-and-postgresql/
32. Release notes — eventsourcing 9.4.6 documentation – Read the Docs, accessed December 19, 2025, https://eventsourcing.readthedocs.io/en/stable/topics/release_notes.html
33. Things I wish I knew when I started with Event Sourcing – part 3, storage – SoftwareMill, accessed December 19, 2025, https://softwaremill.com/things-i-wish-i-knew-when-i-started-with-event-sourcing-part-3-storage/
34. fkromer/best-of-django: A ranked list of awesome Django related Python packages. – GitHub, accessed December 19, 2025, https://github.com/fkromer/best-of-django
35. pyeventsourcing/kurrentdbclient: Python gRPC client for KurrentDB (was EventStoreDB), accessed December 19, 2025, https://github.com/pyeventsourcing/kurrentdbclient
36. Wiser scaled retail pricing intelligence with EventStoreDB – Kurrent, accessed December 19, 2025, https://www.kurrent.io/case-studies/wiser
37. Kurrent: Event-Native Data Platform Company Raises $12 Million – Pulse 2.0, accessed December 19, 2025, https://pulse2.com/kurrent-event-native-data-platform-company-raises-12-million/
38. Kurrent Charges Forward with $12 Million for Event-Native Data Platform – Business Wire, accessed December 19, 2025, https://www.businesswire.com/news/home/20241218867546/en/Kurrent-Charges-Forward-with-%2412-Million-for-Event-Native-Data-Platform
39. Case Studies – Event Store – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/case-studies
40. How Event Sourcing is Spurring Linedata’s Digital Transformation, accessed December 19, 2025, https://www.linedata.com/sites/default/files/2019-12/Event%20Store%20Case%20Study%20-%20Linedata.pdf
41. Introducing Event Store License v2 (ESLv2) – Kurrent.io, accessed December 19, 2025, https://www.kurrent.io/blog/introducing-event-store-license-v2-eslv2
42. Academy Home, accessed December 19, 2025, https://academy.kurrent.io/
43. How to build MongoDB Event Store – Event-Driven.io – Oskar Dudycz, accessed December 19, 2025, https://event-driven.io/en/mongodb_event_store/
44. Kurrent Charges Forward with $12M for Event-Native Data Platform – BigDATAwire – HPCwire, accessed December 19, 2025, https://www.hpcwire.com/bigdatawire/this-just-in/kurrent-charges-forward-with-12m-for-event-native-data-platform/