Chain Engine
Built for organizations that want native data integrity, automated auditability built-in compliance, and lightning-fast reads – without the cloud complexity.
This page serves as a comprehensive technical brief on our core architecture.
Introduction
Nowadays companies don't just pay for data storage. They pay a massive "Mutation Tax". Complex backup licenses. Enormous cloud clusters burned on heavy indexing. Constant resource-hungry updates to keep the state accurate. And entire armies of auditors are hired just to prove that the historical data hasn't been tampered with.
Chain Engine eliminates this complexity by embedding cryptographically secured immutability directly into the application data-layer. Providing the application with:
Event Sourcing as a Fortress:
The application state is derived from the immutable ledger and maintained in in-memory replicas. Even if an insider or hacker manages to touch the raw disk, it will be impossible to activate the unauthorized state changes, because the restart required for activation will not pass the rigorous integrity checks during the restart.
Auditability & Compliance by Design
Every event is encrypted, cryptographically sealed, and time-stamped. This results in a perfectly traceable, tamper-proof audit trail. Auditors and compliance officers gain immediate insight into what really happened, without expensive external systems or complex reconciliation processes.
Blazing Performance
Capable of pushing exceptional volumes of end-to-end task transactions per second out-of-the-box on standard, cost-effective hardware. Read requests run at pure RAM speed.
Fast Development
All business logic resides in a library outside the engine. Organizations can focus on the domain rules from day one.
Architecture
Chain Engine brings the power of an immutable ledger into everyday business applications. It features a modular architecture compiled into a single binary, driven by three core components that make Chain Engine unique. Complemented with a shared type system that ensures the application speaks the same language from start to finish.
Core Components
The Execution Engine decouples transaction processing from ledger persistence to maximize throughput. Transactions are ingested sequentially and executed concurrently via an asynchronous pipeline, keeping multiple transactions in flight simultaneously. To guarantee absolute predictability and auditability, the resulting events pass through a dedicated pending-events queue. A single leader node sequentially drains this queue, enforcing a strict, atomic writing process that commits events immutably to the append-only ledger. This architecture guarantees a single trusted writer, eliminating concurrency conflicts at the storage layer while maintaining high-performance execution.
A read-optimized, always-current RAM-based view of the application state. Rebuilt deterministically from the immutable ledger. Reads are extremely fast (< 3ms) and scale independently from writes. Easily deploy dedicated replicas to isolate heavy BI and analytics workloads from production. Supports cryptographically secured snapshots and GDPR "right to erasure".
All domain-specific rules and calculations live here – written once and reused across the system. Recommended in Rust for performance and reliability and system-wide consistency, but supports JavaScript and other languages via FFI. Keeps business logic clean, auditable, and outside the core engine for easy customization.
Auditability
Compliance by design is at the core of Chain Engine. Every event is cryptographically secured and stored in an append-only ledger, with full historical traceability.
The engine maintains a human-readable audit.log that is encrypted at rest and hash-chained. The log supports periodic rotation for easy archiving and is automatically recovered on application restart.
To make audits easy and portable, Chain Engine ships with two standalone auditor binaries that generate Merkle inclusion and integrity proofs for any event in the ledger.
Auditors can verify events independently using the generated JSON proofs, without needing access to the live system.
Performance & Scaling
Performance is highly dependent on business logic complexity. A workload involving heavy computations will exhibit different resource characteristics than lightweight state updates. While Chain Engine delivers exceptional throughput out of the box, we recommend to always benchmark under your specific transaction profiles to determine optimal scaling thresholds and monitoring baselines.
Chain Engine is designed to deliver powerful performance on standard hardware. On a typical multi-core server with sufficient RAM, the engine can effortlessly handle demanding business workloads. We conducted sustained tests with low to medium complexity (including validations, normalization, replica lookups for duplicate checks, and public key generation) on limited hardware. The engine demonstrated performance far exceeding the majority of business use cases.
Thanks to Rust’s absence of garbage collection and direct OS-thread pinning, hardware efficiency is extremely high. This provides massive computational headroom, meaning typical enterprise applications can run comfortably on a single instance – completely eliminating the overhead of traditional clustering.
When read demand spikes, e.g. thousands of simultaneous dashboards, the In-Memory Replica can be scaled horizontally using a highly optimized, low-latency replication protocol.
The leader broadcasts state updates efficiently, allowing replicas to sync peer-to-peer and automatically recover missing data segments without placing any overhead on the leader node. This ensures that massive read volume never degrades write performance, maintaining absolute data consistency across all nodes.
For enterprise use cases that exceed single-leader capacity, Chain Engine supports multi-binary deployments equipped with parallel processing and use of a mempool, geographical or functional sharding, and even no-std bare-metal Rust for ultimate optimization – all while maintaining full WORM guarantees and bulletproof compliance.
Embeddability
Chain Engine is designed to integrate smoothly into existing enterprise IT landscapes without requiring a rip-and-replace approach.
Thanks to a clean, trait-based extension architecture, the engine exposes well-defined extension points for key infrastructure concerns. Organisations can plug in their own implementations for Identity & RBAC, document storage, secrets management, logging, cryptographic providers, and more – while keeping the core engine untouched.
This makes it possible to reuse existing investments in IdP systems, observability stacks, and storage solutions. Runtime configuration further allows fine-tuning of slot timing, snapshot policies, audit log rotation, data compression, memory limits and queue management et al. – without recompiling the application.
Compliance by Design
Chain Engine is designed with data privacy principles at its core, particularly when handling personally identifiable information (PII) in enterprise applications.
It goes without saying that PII should only be stored on the ledger when operationally necessary. Multiple layers of safeguards are in place to support compliance with GDPR, CCPA and ISO 27001.
Enterprise-Grade Safeguards
The engine comes with enterprise-grade safeguards that are either built-in (out-of-the-box) or prepared via extension-points:
Access Management
Native integration with existing enterprise user systems for strict Role-Based Access Control (RBAC).
Advanced Encryption
Industry-standard authenticated encryption (AEAD) protects data at rest, paired with TLS 1.3 for transit.
Immutable Audit Trail
All actions are logged immutably with restricted access. The audit log is encrypted and protected by continuous cryptographic hashing.
Right to Erasure and Storage Limitation
The append-only nature of the ledger prevents physical deletion of historical events. This preserves auditability and data integrity. However, the architecture supports functional erasure through the following mechanisms:
Logical deletion
Expired items are automatically excluded from the active memory state and future state snapshots. This makes deleted data instantly invisible and inaccessible to all business flows, APIs, and UI views.
Automated Cold Storage
Historical data segments can be sealed almost andd moved to cold storage almost immediately after a snapshot (ledger) or the periodic audit (audit.log). This not only keeps the on-disk storage exceptionally small, but it also physically isolates expired PII data far away from active live operations.
Compliant Lifecycle Management
Once legal retention period expires, archived historical records can be securely decommissioned in accordance with the data retention policies, without compromising the integrity of active records.
Built for Agentic AI
Modern Agentic AI systems are only as good as the data they operate on. They require clean, consistent, trustworthy, and fully auditable data to make reliable decisions and take autonomous actions.
Traditional databases often fail here. Messy, mutable data leads to hallucinations, incorrect decisions, and costly mistakes. Organizations end up spending more time fixing data issues than actually leveraging AI – turning what should be a strategic advantage into an expensive disappointment.
Chain Engine fundamentally changes this paradigm. The immutable and event-driven data is clean and consistent by definition, creating an ideal foundation for agentic AI. The output of AI agents can therefore be trusted with confidence. This allows your teams to focus entirely on innovation and value creation, ensuring that your investment in agentic AI truly delivers results.
“With Chain Engine, organizations can finally move from fixing the past to building the future.”
Post-Quantum Readiness
The Chain Engine is built with future-proof cryptography in mind. It currently uses industry-standard primitives (cryptographic hashing and authenticated encryption at rest using AEAD algorithms), but all cryptographic operations are implemented through clean, configurable provider interfaces.
This abstraction layer allows organisations to seamlessly switch to post-quantum cryptographic algorithms as soon as standards mature – without code changes or architectural rework.
By preparing for post-quantum cryptography today, Chain Engine helps protect sensitive enterprise data against emerging quantum computing threats while maintaining full compatibility with current standards.
Legacy Systems vs Chain Engine
| Aspect | Traditional Approach | Chain Engine |
|---|---|---|
| Licensing | Recurring (per core / user) | One-time perpetual license |
| Infrastructure | Complex clusters & high cloud costs | Single efficient server (on-prem or dedicated) |
| Data Security & WORM | Added-on backup layers | Built-in immutable ledger |
| Audit & Compliance (NIS2 et al.) | Manual & expensive processes | Automated & cryptographically proven |
| BI & Analytics | Heavy ETL + data warehouses | Instant access via Dedicated In-Memory Replicas |
| Operational Resilience | Retrofitted | Compliant by design |
Licensing
Enterprise License
One-time perpetual license € 59.000,-
A single license grants unrestricted usage for all internal applications within your legal entity.
- Unlimited applications entity-wide
- Full source code access
- On-premise or dedicated cloud
- No recurring fees
OEM / SaaS Partner License
Contact us for custom terms
For companies who want to embed Chain Engine in their commercial SaaS or software products.
- Make your product compliant by design
- Dedicated tenant environments are feasible
- Centralized engine maintenance
- Flexible branding options