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 scores it 3.8/10 for agency adoption, best for Founder, Backend Engineer, and Account Executive roles handling 5+ client meetings per week.
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
Core concepts
The mental model you need to price and scope the work.
- Inference Cost Pass-Through CeilingConcept
Inference Cost Pass-Through Ceiling is the point at which an agency can no longer absorb a model provider's price or latency change inside a fixed retainer, so the cost has to move to the client or the work has to shrink. The framework asks three questions per client engagement: what share of delivery cost is metered inference, how fast can that share be re-routed to a cheaper model, and what contract language lets you reprice. Forrester's 2027 predictions flag AI growth colliding with energy and infrastructure limits, which converts compute scarcity into API price movement on agency tools. A concrete case: an agency running document analysis on a frontier API can shift bulk classification to a smaller open-weight model served through Ollama or a gateway like Helicone, keeping the frontier model only for reasoning steps. That split is the ceiling defense.
- Provider Substitution WindowConcept
Provider Substitution Window is the interval during which an agency can move a client workload from one model provider to another without rewriting prompts, evals, or integration code. The window is widest at the orchestration layer and narrowest at the fine-tuned weights layer: a gateway swap takes hours, a retrained model takes a quarter. Agencies that measure this window per client account know exactly when they hold pricing leverage and when a vendor holds it. Forrester's 2027 predictions flag compute and energy constraints pushing API pricing upward, which turns a wide substitution window into a margin defense rather than an engineering nicety. A concrete case: an agency routing Claude and GPT traffic through a gateway such as Helicone or Portkey can shift a client's summarization workload in an afternoon when one provider raises rates, while a competitor with hardcoded SDK calls absorbs the increase on a fixed retainer.
- Margin Defense StackConcept
Margin Defense Stack treats AI infrastructure as a layered cost structure rather than a single line item. The bottom layer is raw compute and API tokens, the middle layer is routing and caching, and the top layer is the client-facing retainer price. Agencies that only negotiate the top layer absorb every shock from the layers beneath. Forrester's 2027 predictions flag that AI expansion is colliding with energy and infrastructure limits, which translates into API price increases for agency tools and compresses margins on AI-inclusive retainers. A concrete defense: route repeat prompts through a gateway such as Helicone or Portkey so cached responses cut token spend before it reaches the client invoice, and keep a local fallback like Ollama for privacy-sensitive work. When a client asks why the AI retainer costs what it does, the stack shows exactly which layer each dollar covers.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- When AI Margins Depend on Third-Party Compute, Price the Dependency Before You Sign the RetainerEvaluation Rule
Map every AI dependency in the delivery stack to a named provider, a fallback route, and a pass-through cost clause before quoting fixed-fee client work.
- AI Infrastructure Rule: Route Across Providers Before You Standardize on OneEvaluation Rule
Put a routing or gateway layer between your application and every model provider before any client deliverable depends on one vendor's endpoint.
- Multi-Model Orchestration vs Single-Provider CommitmentDecision Framework
IF client work spans more than one model family, more than one pricing tier, or more than one data-residency requirement, THEN route every request through an orchestration layer so a provider price change or capability shift becomes a routing edit rather than a rebuild. IF a single provider's model is the product itself and switching cost is already sunk into fine-tunes and evals, THEN a direct integration is cheaper and simpler than adding a gateway. The frame is not which vendor wins; it is whether the agency owns the routing decision or rents it.
- The Single-Provider Lock-In Trap in AI InfrastructureFailure Pattern
- The Token Bill Creep: Why AI Infrastructure Costs Outrun Agency RetainersFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Multi-Model Routing Layer Build (10-14 days)Implementation Blueprint
A delivery pattern for agencies that stand up a provider-agnostic routing and observability layer between client applications and frontier model APIs, so pricing changes, deprecations, or safety-policy shifts at any single lab become a config edit rather than a rebuild.
- Model Routing and Failover Drill (QA)Operating Procedure
- Multi-Provider Cost and Lock-In Review (Retention)Operating Procedure
- Provider Onboarding and Credential Isolation (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.