Run your calculation engine in production. Not in a spreadsheet.

Codcel turns mission-critical spreadsheets — insurance pricing, actuarial models, risk calculations, quant models — into production-grade Rust, Java, or Python services your IT team owns, audits, and deploys.

Book a demoDownload free

Benchmarked on real pricing, reserving, and risk models — millions of rows, hundreds of rating factors, full audit trails.

Excel pricing model on a laptop transpiled into a generated, type-safe service with passing tests

The spreadsheet doing the calculation is also the biggest risk on your books.

  • Domain experts own the model. IT can't govern it.
  • Every rate change is a copy-paste scramble across teams.
  • A single typo ships to production. Nobody can prove it didn't.

That's not a tooling problem. It's an architecture problem. Codcel fixes it.

Your model in Excel. Your service in production. From the same file.

Your model in Excel

Your model in Excel

Generated code, in seconds

use std::error::Error;

#[derive(Debug, Clone)]
pub struct QuoteInput {
    pub driver_age: i32,
    pub postcode: String,
    pub vehicle_value: f64,
    pub no_claims_years: i32,
}

#[derive(Debug, Clone)]
pub struct QuoteOutput {
    pub annual_premium: f64,
    pub monthly_premium: f64,
    pub base_rate: f64,
    pub no_claims_discount: f64,
}

fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let input = QuoteInput {
        driver_age: 35,
        postcode: "SW1A 1AA".to_string(),
        vehicle_value: 24_500.0,
        no_claims_years: 5,
    };

    let output = codcel_quote(&input)?;

    println!("annual_premium:     {}", output.annual_premium);
    println!("monthly_premium:    {}", output.monthly_premium);
    println!("base_rate:          {}", output.base_rate);
    println!("no_claims_discount: {}", output.no_claims_discount);
    Ok(())
}

Every factor table, every lookup, every formula — translated into type-safe code your IT team reviews, tests against your current outputs, and deploys behind your existing API gateway.

For developers

Four things teams try. Codcel does something different.

Internal rewriteLow-code platformSpecialist vendorKeep ExcelCodcel
Time to production12–24 months3–6 months6–12 monthsInstantDays
Business team keeps ExcelNoNoNoYesYes
Source code you ownYesNoNoN/AYes
Runs on your infraYesSometimesNoN/AYes
Audit-ready governanceYesPartialYesNoYes
Handles 10M+ rowsDependsNoYesNoYes

Codcel is the only option where business teams keep Excel and IT gets real, owned, production code with full governance.

Built for the calculation engines that run regulated industries.

Insurance pricing & actuarial

Turn rating engines, factor tables, and reserving models into governed services.

See insurance

Banking & risk calculations

Turn capital models, stress tests, and IRB calculations into audit-ready services.

See banking

Quantitative finance

Turn trading models, pricing curves, and scenario engines into production-grade APIs.

See quant

Also used for energy trading, tax engines, healthcare actuarial, and other regulated calculation workloads.

Built to handle real production workloads.

Millions of rows

Benchmarked on real pricing, reserving, and risk datasets — not toy examples.

Hundreds of factors

Nested lookups, tiered factors, and multi-dimensional rating tables stay correct under load.

Sub-millisecond per calc

Compiled Rust services keep quote and pricing latency well below request budgets.

How Codcel fits into the stack you already have.

Domain expert in ExcelCodcel generates codeYour CI/CDYour runtimeYour API gatewayYour downstream systems

  1. Model in Excel.

    Domain experts tag inputs and outputs with small inline markers. Existing formulas untouched.

  2. Generate and review.

    Codcel emits idiomatic code your engineers review, test, and commit to Git.

  3. Deploy like any service.

    Your existing CI/CD, observability, and security posture apply. No new runtime, no new vendor.

Supported Languages & Platforms

Codcel generates real, production-ready source code across today's most widely used programming languages and ecosystems — with more coming soon.

Rust

Lib · API · WASM · Web

Java

Lib · API · Web

Kotlin

Lib · API · Web (incl. Android)

.NET (C# / VB)

Lib · API · Web

Python

Lib · Web

Go

Lib · API · Web

JavaScript

Web Clients

TypeScript

Web Clients

Swift

Lib · Apple

FFI / C

Native Bindings

AI · MCP

Agent Tools

WASM

WebAssembly Modules

We're continuously expanding Codcel's language and platform support.

What Codcel Generates

From a single Excel file, Codcel produces full systems — APIs, UIs, libraries, databases, and even MCP servers for AI agents. No templates, no frameworks, no lock-in.

Backend API Service

A fully documented REST API built from your Excel logic. Deterministic, type-safe, and ready to deploy to any cloud or on-prem environment.

Language Libraries

Generate idiomatic libraries in Rust, Python, Java, C#, Go, Swift, TypeScript and more — readable, testable, and production-ready.

SQL Schema & Data Pipelines

Turn your Excel tables into SQL schemas and high-speed and CSV import for massive datasets (including 1B+ rows).

Also generates, for developers

Fullstack Web App

A complete React-based UI with forms, validation, tables, and live calculation logic connected to your generated backend.

MCP Server for AI Agents

Expose your Excel logic as AI tools. Let ChatGPT or your internal LLM safely call calculations, run scenarios, generate reports, and quote premiums.

WASM Module

Export your Excel logic as a fast, portable WebAssembly module — perfect for embedding directly into browsers, desktop clients, or edge environments.

All generated artifacts are real, human-readable source code — fully owned by you, versioned in your repos, deployed in your architecture, and governed by your processes.

Working with teams who refuse to freeze their models in time.

We're partnering with a small number of insurers, banks, and financial institutions to turn their Excel calculation engines into governed, auditable services.

Design partners get deep engineering support, preferential pricing, and direct influence on the product roadmap.

Apply for design partnership

Two ways to start.

Talk to us about your book

Bring your hardest rating workbook.

For insurers, banks and actuarial teams turning production models into governed, auditable services. We run the demo on your file, and design partners get deep engineering support and preferential pricing.

Book a demoApply for design partnership

Try it yourself

Run Codcel on your own spreadsheet.

For developers and small teams who want to see real generated code from a real Excel file, no call required. Start on the Explore plan from €15/month, full source, all languages, cancel anytime.

Start ExploreDownload free

Stop rewriting your calculation engine. Generate it.

Book a demoDownload free

Demos take 30 minutes. Bring your hardest spreadsheet.