Hekla
Hekla is an event-sourcing runtime that eliminates boilerplate and entire classes of bugs by enforcing determinism and side-effect restrictions at compile time rather than runtime. Backend teams declare events, commands, projectors, and effects in heklang; the runtime generates OpenAPI routes, read models, admin consoles, and encryption logic from those declarations. Commands cannot reach the network, projectors cannot decrypt, and folds cannot read clocks because the language forbids it, not because something checks at runtime. Hekla rebuilds read models from position zero without downtime, journals durable effects so replays never double-execute, and provides subject-scoped encryption and crypto-shredding erasure natively. Best suited for agencies building auditable backends or systems that must pass SOC 2, GDPR, or HIPAA audits.
Hekla is an event-sourcing runtime. InnovaAI rates it 3.8 of 10 for agency adoption, best for Founder, Backend Engineer and Account Executive roles.
Agency Audit
Hekla is an event-sourcing runtime that lets backend teams declare auditable systems in a single declarative language (heklang) rather than writing distributed logic across multiple services. Compile-time guarantees eliminate entire classes of bugs: commands cannot reach the network, projectors cannot decrypt, and folds cannot read clocks. Agencies building compliance-heavy or audit-critical backends for clients benefit most, as Hekla generates OpenAPI docs and admin consoles from declarations, reduces deployment risk via hekla plan diffs, and handles subject-scoped encryption and crypto-shredding erasure natively. Best suited for technical founders and backend engineers who spend significant time debugging race conditions, data-consistency bugs, or privacy-compliance edge cases.
3recommended
72/mo
No paid plan published
High
Illustrative scenario. Not a guarantee. Net capacity needs a verified paid base plan, and none is published for this service, so it is not modeled. Hours saved come from the service estimate; implementation, taxes, and unprovided usage charges are excluded.
- Founder handling backend system design and implementation
- Backend Engineer handling race-condition and state-consistency debugging
- Account Executive handling compliance audit and data-erasure coordination
- Your team is building greenfield systems but has no one with event-sourcing experience and cannot dedicate 2-3 weeks to learning heklang and the event-sourced mental model. The language is not intuitive for teams trained only in imperative or ORM-based backends.
- Your backend is already in production and uses imperative patterns (REST controllers, ORMs, direct database writes). Hekla is not designed for incremental adoption; you would need to rewrite the entire backend to benefit.
- Your team's primary pain is API response latency or database query performance. Hekla optimizes for correctness, auditability, and determinism, not throughput. If your bottleneck is read-model query speed, Hekla does not solve that.
Internal Adoption Path
No paid plan published
72 hr/mo
3 seats × 24 hr each
$5,400/mo
modeled at $75/hr labor rate
No paid plan published
Illustrative scenario. Not a guarantee. No verified paid base plan is published for this service, so subscription cost and net capacity are not modeled. Implementation, taxes, and unprovided usage charges are excluded.
Platform Features
Core capabilities of Hekla
Declarative event-sourced backend in one language
Backend engineers define events, commands, projectors, and effects in heklang; the runtime generates OpenAPI routes, read models, and admin consoles from declarations. Eliminates the need to hand-write REST controllers, database schemas, or serialization logic, saving backend teams 8-12 hours per sprint on boilerplate.
Compile-time determinism and side-effect restrictions
Commands cannot reach the network, projectors cannot decrypt, and folds cannot read clocks. These restrictions are enforced at compile time, not runtime checks, so entire categories of race conditions and state-consistency bugs are impossible. Backend engineers skip hours of debugging concurrent-write conflicts.
Subject-scoped encryption and crypto-shredding
Fields tagged with @subject(id) are encrypted under keys scoped to that subject; erasure of one subject does not touch fields scoped to another. Compliance teams and Account Executives no longer need to coordinate manual data-deletion workflows or audit encryption coverage.
Durable effect execution with idempotent journaling
Effects (side effects like sending emails or calling external APIs) are journaled and executed durably; replaying an effect never re-sends it. Backend engineers eliminate duplicate-email bugs and failed-payment-retry logic without writing custom idempotency layers.
Read-model rebuild without downtime
Projectors rebuild read models from position zero in the background while the running system continues serving queries. Operations teams and Project Managers skip coordination of maintenance windows and avoid customer-facing downtime during schema changes or bug fixes.
Deploy-time safety verification with hekla plan
hekla plan compares a candidate deploy against the running system and surfaces whether new code would still produce the same read models and effects. Founders and CTOs catch logic changes that would break consistency before they ship, reducing post-deploy incident response.
What Makes Hekla Different
Unique advantages vs similar tools in this niche
Compile-time enforcement of side-effect restrictions
vs Runtime checks and conventions in traditional event-sourcing frameworksCommands cannot call network because invoke does not parse in one, and projectors cannot decrypt because reveal does not parse in one.
Dynamic Consistency Boundary derived from folds
vs Manual configuration of optimistic concurrency in other systemsThe slices a command folded are the condition its append is checked against, eliminating drift between declared and actual reads.
Subject-scoped encryption with crypto-shredding
vs Traditional encryption at rest requiring rewrites for erasureOne key delete makes every value scoped to that subject unmatchable and unreadable across the log and read models without rewrite or compaction.
Deploy verification via replay of recorded invocations
vs Manual testing and staging environmentshekla plan replays recorded invocations against candidate code to detect behavioral divergence before deploy.
Value Equation
Outcome-likelihood-time-effort assessment for Hekla
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. Hekla has no published pricing, so we hold this section until real numbers are available.
Contact HeklaPricing
Pricing data not yet available for Hekla.
Reality Check
Hekla requires the team to learn heklang and adopt event-sourcing patterns; there is no gradual migration path from imperative backends. Pre-1.0 status means the language and runtime are still evolving. Payoff is highest for teams building new backends or those already committed to event sourcing; retrofitting existing systems is not the intended use case.
High effort: requires technical configuration and team training
How This Accelerates White-Label Services
Who It's For
- ✓agencies-building-auditable-backend-systems
- ✓teams-requiring-strict-data-privacy-compliance
- ✓developers-needing-deterministic-event-sourced-architectures
Acceleration Steps
- 1Schedule onboarding with the vendor
- 2Configure declare event-sourced backend systems using the heklang language
- 3Launch your first client project
Academy for Hekla
Work through it in order: the course for this service first, then the modules behind it.
Course for this service
Hekla Agency Implementation, Auditable Backend Delivery
Learn to architect and deliver event-sourced backends using Hekla's declarative language, eliminating boilerplate and compliance risk for clients. This course teaches agencies how to scope projects around heklang declarations, automate read model generation, and position deterministic backends as a premium service for regulated industries.
Open the courseNo Academy modules are published for this service yet. Browse the full Academy
Why this category matters
The commercial case before the tooling.
Core concepts
The mental model you need to price and scope the work.
- Provider Concentration ExposureConcept
Provider Concentration Exposure measures how much of an agency's client delivery depends on one model vendor's pricing, uptime, and roadmap. The framework scores each AI-backed workflow on three axes: share of requests routed to a single provider, cost sensitivity if that provider reprices, and recovery time if the API degrades or a model is retired. High exposure is not a technical problem, it is a retainer problem: a client deliverable that stalls because one endpoint changed terms is a margin and trust event. The concentration risk is structural, not hypothetical. OpenAI closed roughly $11 billion against a $30 billion target in its latest round, which constrains roadmap and pricing flexibility for every agency building on its API. Mitigation is cheap relative to the downside: route through a gateway layer such as Portkey or OpenRouter, keep a second provider warm, and document a fallback for each critical workflow before the client asks for one.
- Orchestration Layer PremiumConcept
Orchestration Layer Premium is the margin an agency keeps by routing every model call through an abstraction layer instead of hard-coding a single provider's SDK into client delivery. The layer (a gateway, router, or proxy) lets you swap Anthropic, OpenAI, Google Vertex AI, or AWS Bedrock behind one interface, so a price change or capability shift becomes a config edit rather than a rebuild. It matters because provider economics move fast: OpenAI closed an $11B round against a $30B target, which constrains the pricing flexibility agencies plan around. The premium shows up twice, first as avoided rework hours when a model is deprecated, second as negotiating room when you can quote two vendors on the same workload. Helicone and TrueFoundry both sell this layer directly, and Portkey-style routing does the same job at smaller scale. Agencies running retainer-based AI features should treat the gateway as billable infrastructure, not overhead.
- Token Cost AttributionConcept
Token Cost Attribution is the practice of metering model spend at the workflow level, not the account level, so every AI-backed deliverable carries its own cost line before it reaches a client retainer. The category description frames AI Infrastructure around cost, latency, and reliability, and cost is the variable agencies control least once a build ships. Forrester's Tokenomics analysis warns that agentic workflows billed by token consumption can erode margin when nobody audits them at design stage, and prompt-level trimming has been shown to cut per-task costs by 50 percent or more. A concrete case: an agency running document-summarization agents for three retainer clients discovers that one client's full-document attachments account for most of the monthly model bill, because no per-workflow meter existed. Gateways such as Helicone and Portkey log spend per request, which turns that discovery into a routing decision rather than a quarterly surprise.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Infrastructure Rule: Price the Exit Before You Price the ModelEvaluation Rule
Before signing a client retainer on any model provider, prove the workload runs on a second provider within one working day, and write that portability test into the delivery scope.
- AI Infrastructure Rule: Route Through a Gateway Before You Sign a Second Model ContractEvaluation Rule
Stand up a multi-model routing layer (an AI gateway or orchestration proxy) before adding a second direct provider integration, so provider swaps are a config change rather than a rebuild.
- Multi-Model Orchestration vs Single-Provider CommitmentDecision Framework
IF an agency runs AI features across more than two client retainers, THEN route every model call through an orchestration or gateway layer so a pricing change or capability shift at one provider never halts delivery. IF a single client engagement, a fixed budget, and one model family cover the whole scope, THEN commit directly to that provider and skip the abstraction tax.
- Why AI Infrastructure Budgets Collapse After the First Client PilotFailure Pattern
- The Single-Provider Anchor Trap: Why AI Infrastructure Stalls When One Model Becomes the DefaultFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Multi-Model Orchestration Layer Build (10-18 days)Implementation Blueprint
A delivery pattern for agencies that put a routing and failover layer between client applications and frontier model providers, so pricing changes, deprecations, or capability shifts at any single vendor do not stall a retainer. The build produces a working gateway, a cost and latency baseline, and a documented fallback path per model call.
- Model Provider Failover Drill (QA)Operating Procedure
- Token Cost Margin Audit (Delivery)Operating Procedure
- Provider Concentration Risk Review (Onboarding)Operating Procedure
13 modules selected for Hekla
Frequently Asked Questions
Answers about pricing, setup, implementation
Hekla is an event-sourcing runtime that lets backend teams declare auditable, deterministic systems in heklang instead of writing distributed logic across multiple services. It generates OpenAPI routes, read models, and admin consoles from declarations; enforces side-effect restrictions at compile time so race conditions and state-consistency bugs are impossible; and provides subject-scoped encryption, durable effect execution, and downtime-free read-model rebuilds. Best for agencies building compliance-heavy backends or systems that must pass SOC 2, GDPR, or HIPAA audits.
Hekla pricing is not publicly listed. Contact the Hekla team directly for per-seat or per-deployment pricing and to discuss licensing for internal agency adoption.
Backend engineers and technical founders benefit most: engineers eliminate race-condition debugging and hand-rolled encryption logic; founders reduce post-deploy incident response by catching logic changes before they ship. Account Executives and Project Managers benefit secondarily by gaining queryable audit trails (answering 'what happened to this customer' in seconds) and eliminating manual data-deletion coordination. Operations teams skip maintenance-window coordination because read models rebuild without downtime.
Conservative estimate: 6-10 hours per backend engineer per week, anchored to race-condition debugging, boilerplate elimination, and encryption-logic hand-rolling. For a team of 2-3 backend engineers, that compounds to 12-30 hours per week across the team. Payoff is highest for teams already building event-sourced systems or those with strict compliance requirements; teams retrofitting imperative backends see minimal savings in the first 4-6 weeks.
Hekla is pre-1.0 and actively evolving. The language and runtime are stable enough for new greenfield backends, but teams should expect occasional breaking changes and should not adopt it for systems already in production unless they have the capacity to track upstream changes.
Learning heklang and adopting event-sourcing patterns typically takes 2-3 weeks for a team of experienced backend engineers. Greenfield projects can start using Hekla immediately; retrofitting existing imperative backends is not recommended and would require a full rewrite.