Open-source feature platform
Define features once.
Compute them consistently in batch, training, and online.
ClearFeature is a transparent, lightweight, self-hosted, code-first feature platform. Define versioned feature logic in Python and dependencies as a DAG, then use the same tested code for historical batch computation, point-in-time-correct training datasets, and request-time online computation.
Raw source data
Source reports
transactional, behavioral, market, operational
One Feature Project
Versioned Python feature DAG
UDFs · registry · dependencies · tests
Same logic, every path
Historical materialization
Point-in-time training datasets
Live request-time computation
Production ML still implements the same feature more than once.
A feature is born in a notebook. It is rewritten in SQL or Spark for historical pipelines. It is rewritten again in a backend service for production. Three implementations of one idea — owned by three teams, drifting independently.
notebook.py
Where the feature is designed. Fast to change, never deployed, quietly becomes the informal spec.
pipeline.sql
The historical re-implementation for training data. Different nulls, different rounding, different edge cases.
service code
The production re-implementation. Maintained by a different team, released on a different schedule.
The result is training-serving skew, duplicated engineering, slow model releases, and historical feature values no one can precisely reconstruct. More on the skew problem →
Three implementations become one.
Before — one feature, three implementations
Notebook Python
research and model development
Historical SQL / Spark
backfills and training pipelines
Online service code
re-implemented for production latency
Three codebases drift apart — silently.
With ClearFeature — one implementation
One Feature Project
Python UDFs · declarative DAG · versions · tests
Historical materialization & PIT training data
Live request-time computation
The same tested logic executes on both paths.
What that changes for the business
Ship models with fewer infrastructure handoffs
A data scientist’s tested feature code is the artifact that runs in production — not a specification someone else re-implements.
Reduce duplicated feature engineering
One definition, one dependency graph, one set of tests — instead of parallel notebook, batch, and online codebases.
Reduce training/serving divergence
When training and production execute the same code, an entire class of silent model degradation disappears at the source.
Reproduce historical feature computation
Versioned features plus availability-aware history make it possible to reconstruct what a model actually knew. How reproducibility works →
How ClearFeature works
A Feature Project moves through one workflow — from definition to live computation — without changing implementation along the way.
01
Define
02
Test
03
Ingest
04
Materialize
05
Build training data
06
Compute live
The full workflow, with real commands and code, is on the platform page.
The question is not when an event happened.
It is when that information became available to the system. A source report can describe Monday and arrive on Wednesday — a Tuesday prediction must not see it. ClearFeature builds training datasets that respect availability, so historical rows contain only what the system could actually know.
Fits the stack you already run
ClearFeature sits between your source data and your models, using infrastructure components your team already operates.
Your sources
Structured source reports
transactional, behavioral, market, operational
ClearFeature (self-hosted)
Feature Runtime
Core + your Feature Project
PostgreSQL · Valkey · S3-compatible storage · Kafka-compatible broker
history, latest values, raw reports, events
Your models
Training pipelines
Live inference services
Where teams apply it
Credit Risk
Fraud Detection
Real-Time Scoring
Energy & Trading
Proven end to end — honestly labeled
The architecture has been exercised through a reproducible engineering demo on synthetic credit-decision data. It verifies the execution model, not scale.
Reproducible engineering demo · synthetic data · not a benchmark
Four independent report sources
tax, credit bureau, telco, and socio-demographic reports
Tens of thousands of synthetic application snapshots
ingested as canonical raw-report payloads
Dependent feature DAG
source features → affordability layer → score-as-feature, resolved by the platform
Materialization runs twice
the second pass verifies idempotent, deterministic behavior
Deterministic online serving
request-time values test-asserted against the same DAG
Per-value lineage
every served feature value traceable to its inputs
Open source, down to the execution engine
ClearFeature is Apache-2.0. Inspect the architecture, run it yourself, and keep your Feature Project as your own code — the engine has no claim on it.
More on the open-source model on the Open Source page.
Use ClearFeature yourself — or bring us into the deployment
Every production ML stack is different. If you are planning a self-hosted deployment, migrating from internal feature pipelines, or standing up a first Feature Project, we can work on it with your team — architecture, deployment, migration, and pilot scope are discussed individually.
How commercial adoption works is on the Enterprise page.
Why ClearFeature
Feature stores often start from retrieving feature values. ClearFeature is centered on executing versioned feature logic — the same dependency graph, over historical and live data. If your problem is that feature computation exists in several places, the execution model is the thing to fix.
Building production ML feature infrastructure?
Tell us how your training and production feature pipelines work today. We will tell you honestly whether ClearFeature fits.