FormulaPlatform
Your business calculations, in one governed place — not hard-coded into six systems.
Define named formulas from reusable, nestable components and variables in a browser designer. Test them live against trial values before saving. Every other system in the estate then fetches the structure and posts values to a REST endpoint to get the answer — so a rate change becomes an edit, not a release.
55REST endpoints
3Calls to integrate
2Wire formats, everywhere
0Front-end build steps
The problem
The same calculation, written four times, in four languages.
The pricing rule lives in the quoting tool. A copy lives in the billing job. A slightly older copy lives in the customer portal, and a spreadsheet on someone's desk is the one finance actually trusts. When the rate changes, four teams schedule four releases — and for a while the four systems disagree about what a customer owes.
01
Logic in four places
The same formula reimplemented per system, drifting apart from the day it is copied.
02
A release per rate change
A number the business owns can only be changed by engineers on a deployment schedule.
03
No way to test it
Whether the change is right is discovered in production, by a customer.
04
Nobody can see it
The definitive version of the rule is buried in source control, unreadable to the people who own it.
The solution
One definition. Every consumer calls it.
01
Get the formula
Fetch the full component and variable tree for a named formula.
02
Get a template
Fetch the same tree with every value blanked, ready to fill in.
03
Evaluate
Post the filled template and get back per-component results plus a total.
Capabilities
01Formula designer
- A formula is a named, numbered object with a status, held against a tenant, an organisation and an environment.
- Components render as an indented tree, each with its own expression, name and version, nesting as deeply as needed.
- Named variables per component, with a type and a value.
- Automatic variable detection: the expression is scanned as you type and every name found is offered as a one-click addition.
- An evaluation panel beside the expression, with an input per variable and an automatic mode that re-evaluates as values change.
- Per-card dirty-state marking, add or cascade-delete sub-components, and collapse or expand branches while working.
- A standalone Calculator screen: pick any formula, load its template, fill the inputs and evaluate — no integration required.
02Calculation engine
- Expressions run on a proven, purpose-built mathematical expression library, not a general-purpose scripting engine — a formula cannot become code.
- Variables are bound by name at evaluation time.
- Every component is evaluated, then summed to a formula total.
- Partial results are suppressed: if any component fails, the platform returns no total rather than a misleading number.
- Evaluation works with either a session token or a machine API key, so the same endpoint serves the interface and the integration.
03Structure & environments
- A four-level structure — tenant, organisation, application, environment — organises formulas across brands, clients and stages.
- Each environment carries its own API key, with a rotation endpoint that issues a fresh one.
- Environments flag themselves as development or production.
- Promotion copies a formula, with all its components and variables, into a target environment as the next version.
- Every record carries created and modified timestamps and the account that made the change.
04Integration & API
- 55 REST endpoints across twelve documented groups.
- Every endpoint speaks both JSON and XML — the consumer chooses, and a legacy client is a first-class citizen.
- A uniform envelope on every call: request and response identifiers, an external correlation id, the payload, and structured, field-level feedback.
- Typed request and response objects throughout — no untyped maps on the wire.
- A template call returns a blank, correctly shaped request body, so an integrator never hand-builds a payload.
- Filter-by-example and paging are built into every list endpoint.
- An interactive API console for exploring and trying every endpoint.
05Operations & administration
- A log viewer over the application and system logs, with level filtering, free-text search and a live tail of up to two thousand lines.
- Runtime log levels: raise or lower any logger without a restart or a redeploy.
- A memory console with a live heap gauge, manual and scheduled garbage collection, and a rolling history of the last fifty runs.
- A dashboard showing formula, tenant and organisation counts, and the ten most recent formulas.
- Tenant and organisation management, with create, edit and deactivate.
- Deploys as a standalone application or into an existing servlet container, on one PostgreSQL database with schema applied automatically.
- No front-end build tooling anywhere, and dependency vulnerability scanning gated at severity seven.
06Security & governance
- bcrypt password hashing, guarded against double-encoding
- Stateless signed tokens with signature and expiry validation
- Password-reset tokens scoped to that single purpose and rejected for general API access, single-use, thirty minutes
- Account-enumeration protection on password reset
- Per-environment API keys, uniquely indexed and rotatable
- Dependency vulnerability scanning in the build, gated at severity seven
- Not in this release: role-based access control, per-tenant query isolation, single sign-on, multi-factor authentication, rate limiting and encryption at rest. Formula Platform should today be deployed on a trusted internal network, behind your own access layer, and is priced accordingly. Ask us for the current roadmap before you position it into a regulated environment.
■Runtime: Java 21 on Spring Boot 4.
■Database: PostgreSQL, schema owned by versioned migrations.
■API: 55 REST endpoints across twelve groups, JSON and XML on every one.
■Front end: server-rendered, vanilla ES6, no build tooling.
■Scale: around 19,600 lines of code, 9 entities, 12 services.
Industries
Who it works for
Software vendors & ISVs
Pricing, scoring and fee logic that customers want per account moves out of the product and behind an API, so configuration stops being a source change.
Financial services
Interest, fee and charge calculations stay identical across the portal, the statement run and the back office.
Insurance
Premium and excess computation where the rating rule changes on a business cycle rather than a release cycle.
Quoting & estimating
Engineering, construction and manufacturing quotes built from dimensional formulas that every quoting channel shares.
Health & clinical scoring
Index and score calculations that must be auditable and identical wherever they are shown.
Utilities & telecoms
Tariff and consumption calculations shared by a billing engine, a self-service portal and a call-centre tool.
Logistics
Freight, surcharge and dimensional-weight rules that differ per lane and change more often than the software around them.
Payroll & benefits
Allowance, contribution and pro-rata calculations shown to an auditor as a definition rather than as source code.
Multi-brand groups
The four-level structure lets one deployment carry a different set of formulas per brand, per client and per stage.
Use cases
Example scenarios
01 · Insurance
Premium changes made by the business, not scheduled as a release
- Challenge
- The rating rule for a home insurance product is coded into both the policy system and the broker portal. Every adjustment waits for two development teams, and for a while the two channels quote different premiums.
- Approach
- The premium is modelled once as a formula, with base premium, surcharges and excess as nested components. An analyst tests changes against trial values in the evaluation panel, then promotes the formula from the development environment to production as the next version; both systems call the evaluate endpoint with their environment API key.
- Result
- A rating change becomes an edit and a promotion instead of two releases, and the policy system and the broker portal always return the same premium.
02 · Software vendors & ISVs
Per-customer fee logic moved out of the product code
- Challenge
- A software vendor sells the same platform to several clients, each with its own fee calculation. The differences live as branches in the source code, so onboarding a client with a new rule means a development ticket and a custom build.
- Approach
- Each client gets its own organisation in the tenant, organisation, application and environment structure, holding its own named fee formula. The product fetches a blank template for the client's formula, fills in the values and posts it to the evaluate endpoint, receiving per-component results and a total.
- Result
- A client with a different fee rule becomes a configuration task, and the product code stays the same for everyone.
03 · Utilities & telecoms
One tariff for the billing engine, the portal and the call centre
- Challenge
- An energy supplier calculates the same consumption tariff in an older billing engine that only speaks XML, in a customer portal and in the call-centre tool. When the three disagree, agents cannot explain the amount on the bill.
- Approach
- The tariff is defined once as a formula. The billing engine calls the API in XML while the portal and the call-centre tool use JSON on the same endpoints, and if any component fails the platform returns no total rather than a misleading figure.
- Result
- The bill, the portal and the agent's screen show the same amount, and a tariff change is made in one place.
Licence
Per deployment. Never per seat.
Licensed per installation, on your own annual turnover, ex VAT — no per-formula charge and no per-evaluation meter. Pricing is marginal, like income tax: each slice of turnover is charged at its own rate, with a €900 minimum and any yearly increase capped at 25%. Every tranche includes unlimited users, projects and organisations in one tenant, self-hosting, and support that rises with the tranche.
Annual licence by turnover, ex VAT
| Turnover | Per year |
|---|
| Up to €500k | €900 |
|---|
| €1M | €1,500 |
|---|
| €5M | €2,500 |
|---|
| €25M | €5,500 |
|---|
| €100M | €13,000 |
|---|
| €500M | €37,000 |
|---|
| €1B | €52,000 |
|---|
Illustrative: a rules service at €0.001 an evaluation bills fifty million evaluations €50,000 a year; at €5M turnover this is €2,500.
What it does
- 01One formula, defined once — every consuming system calls it instead of copying it.
- 02Test live against trial values in the browser designer before you ever save.
- 03Three REST calls, in JSON or XML, and any system is integrated.
At a glance
CategoryCalculation Platform
LicencePer deployment, unlimited users, from €900 a year
For whomSoftware vendors & ISVs · Financial services · Insurance · Quoting & pricing
Send us one formula.
The gnarliest one you have, and the systems that each hold a copy of it. We will model it and hand you the three calls that replace them.Start the conversation →