Product
Engineering data governance that runs where your data lives.
Wormwood is a rule-governed data warehouse platform for engineering-intensive organisations. Ingest from any source. Transform using versioned, auditable rules. Run locally, on Databricks, or inside Snowflake - without writing another script.
The Problem
Your engineering data is correct. You just can't prove it.
Engineering organisations operate with data across dozens of source systems: legacy Excel workbooks built over years, Access databases carrying decades of equipment records, SQL Server CMMS instances that have outlived three IT strategies.
The data is there. The rules that govern its transformation are not. CAPEX models live in formulas buried in cells with no names and no history. Validation logic lives in the head of a senior engineer. When that engineer leaves, the logic leaves with them.
When auditors ask which version of the cost model produced the bid, the answer is: we don't know.
Wormwood answers that question. Every rule has a name, a version, a source, and an audit trail. Rules live in a database, not in a spreadsheet. Profiles are switched at runtime, not by editing code. Every transformation is traceable.
The Solution
One rule engine. Every source. Every runtime.
Wormwood consolidates the transformation logic that currently lives scattered across scripts, workbooks, and tribal knowledge into a single governed layer:
- Rules are rows in a database - named, versioned, traceable.
- Profiles are sets of rules bound to a domain - switch profiles without touching code.
- Connectors read from any source - Excel, Access, SQL Server, Oracle, APIs.
- Engine runs everywhere - local Python, Databricks, Snowflake.
Your data stays where it lives. The rules travel with it.
How It Works
Three steps. Every source. Every runtime.
Connect
Wormwood connects to your source systems - Excel workbooks, Access databases, SQL Server, Oracle, or REST APIs. The connector layer normalises any source into a typed entity record stream.
Govern
Rules in the active profile evaluate each entity. Validation rules check field completeness. Transformation rules derive new fields. Scoring rules assign quality tiers. Every execution is logged against the rule version that produced it.
Deliver
Results are written to your target: a Delta table in Databricks, a Snowflake table, a PostgreSQL database, or a JSON report. The same profile that ran locally runs identically on your cloud platform.
Capabilities
Four layers. One governed platform.
Rule Engine
Named, versioned rules executed in priority order. Rules are rows in a database table - not code, not YAML files. Every rule specifies output field, formula, rule type, technology scope, and priority.
Change a rule: one UPDATE. Revert to a previous version: one profile activation. Audit which rule produced an output: query by rule ID, version, and timestamp.
Profile System
A profile is a named, versioned set of rules bound to a domain. Activating a profile is a database state change - no deployment, no code release.
Profile switching enables A/B testing of rule sets, rollback to a previous version, and multi-client rule configurations from a single deployment.
Connector Layer
Every source connects through the same BaseConnector interface. Rules never know which connector produced their input.
Current: Excel, Microsoft Access (.accdb/.mdb), YAML/JSON
Roadmap: PostgreSQL, SQL Server, Oracle, REST API, Databricks Delta Lake, Snowflake, IBM Mainframe
Multi-Platform Execution
The profile API is runtime-agnostic. Any runtime that can make an HTTP GET request can fetch the active profile and execute rules locally.
No per-platform code variations. No environment-specific rule files. One profile, all runtimes.
Use Cases
Validated in production.
TCO Domain
Data Centre Cost Modelling
294 rules derive server counts, rack utilisation, power draw, cooling overhead, capital spend, and annual operating costs across four cooling technologies - all traceable to the Excel baseline that originally validated them.
When a parameter changes - electricity rate, location, discount rate - a single API call with overrides returns updated results across all technologies in under 100ms. No spreadsheet to update.
EDR Domain
Engineering Data Repository Validation
The Wormwood EDR domain ingests entity records from a source Access database, applies validation rules derived from real project data, and produces a quality-tiered output (A/B/C) per entity with a detailed violation report.
Entity classes: Valve, Instrument, Equipment, Pipeline, Electrical.
Platform Targets
Local today. Cloud-ready by design.
FastAPI engine + Flask admin panel. Single command start. Full rule editor, profile management, admin panel. Docker Compose bundle.
Native Databricks notebook execution. Profile fetched from API at cluster start. Rules execute as Python, parallelised via Spark's mapPartitions. Output to Delta Lake.
Snowpark Python execution inside the Snowflake boundary. Entity data stays in Snowflake. Zero data egress. Same profile, same rules.
Industries Validated
Built on real engineering data.
Oil & Gas
Instrument, valve, and equipment master data fragmented across legacy Access databases and Excel workbooks. Validated against production engineering database.
Pharmaceutical
Equipment and instrument records requiring validation for regulatory submissions. Audit trail satisfies data integrity requirements in IQ/OQ/PQ contexts.
Construction & Infrastructure
Capital project cost modelling across technology options. Engineering entity management for large infrastructure projects with multi-source data.
Financial Services
Data centre infrastructure cost governance. CAPEX/OPEX rule auditability for infrastructure investment decisions.
Technology Stack
Python-native. Cloud-portable. Zero framework lock-in.
The rule engine has no framework dependencies - pure Python 3.11. The API layer, admin panel, and connectors are layered on top. The core can run on any compute surface that supports Python.
| Rule Engine | Python 3.11 - pure OO, no framework |
| API | FastAPI + Uvicorn |
| Admin Panel | Flask + Jinja2 |
| Database (dev) | SQLite |
| Database (production) | PostgreSQL |
| Cloud - Databricks | PySpark + Databricks Runtime |
| Cloud - Snowflake | Snowflake Snowpark Python |
| Connectors | pyodbc (Access, SQL Server), openpyxl (Excel), psycopg2 (PostgreSQL) |
| Testing | pytest - 93% coverage, zero mocks |
Who It Is For
Built for people who own the data problem.
Engineering Data Managers
You manage the instrument register, the valve list, the equipment database. You know the data quality is poor. You have no governed way to prove it or fix it systematically. Wormwood gives you a rule-governed pipeline that produces a quality report and a roadmap to Tier A data.
Infrastructure Cost Engineers
You build CAPEX/OPEX models in Excel. The client wants a different discount rate or wants to see immersion cooling compared to your current design. Wormwood runs all four technologies in one API call, with full rule audit trail.
Cloud Migration Architects
Your client is moving to Databricks or Snowflake. The hard part is not the pipeline - it's the transformation logic. Wormwood defines that logic as versioned database rules before the migration starts. When the data lands in the cloud, the same rules run the same way.
Digital Transformation Leads
You are replacing legacy Access databases and Excel-based data management with modern infrastructure. You need to prove to auditors and regulators that the new system produces the same results as the old one. Wormwood's rule versioning and audit trail produce that proof.
See the Platform in Action
Project Wormwood is in active development, validated across Oil & Gas and Pharmaceutical engineering environments. Contact us to discuss your engineering data governance challenge.
Start a Conversation