Define business logic once.
Use everywhere.

Semantic layer and feature platform
unified as one friendly SQL dialect

Book a demo → Read the docs

Sound familiar?

These are common challenges we hear from data teams.
FeatureMesh transforms this complexity into clarity.

"We need to join 5 tables just to know if a customer is active..."

— Data Engineer

"Every team has their own version of 'monthly revenue' calculation..."

— Analytics Lead

"Our ML features are a mess of duplicated pipelines..."

— ML Engineer

Meet FeatureQL

The SQL dialect designed for business logic.
No YAML configs. No Python decorators. No scattered files.
Just consistent, declarative definitions ready for both analytics and production.

Abstracted

Feature expressions are decoupled from storage, optimization, and execution.

Atomic

Operates at the column level (that we call features) rather than at the table level.

f(x)

Functional

Pure-transformations facilitates reusability, collaboration, and testing.

Business ready

Experimentation, growth accounting, point-in-time, simulations, out of the box.

How it actually works

1. Analytics / Training

Define entities and keys

That's the foundation of semantics.

CREATE FEATURES AS
SELECT 
    customers = entity(),
    customer_id = input(bigint#customers),
    orders = entity(),
    order_id = input(bigint#orders),
;

Map features to columns

Each column in your analytics database becomes a source feature.

CREATE FEATURES IN fm.core AS
SELECT 
    customer_data := external_sql(
        `SELECT orders FROM customer_history WHERE customer_id=%customer_id`,
        AS row(orders array(row(
            order_id bigint#orders, 
            date_create timestamp, 
            price decimal(10,2)
        )))
    ),
    customer_ml_batch := external_sql(
        `SELECT churn_risk FROM customer_ml_batch WHERE customer_id=%customer_id`,
        AS row(churn_risk float)
    ),
;

Write transformations

Express your business logic as declarative feature transformations.

CREATE FEATURES IN fm.marketing AS 
SELECT
    has_recent_orders := date_diff(
        array_max(fm.core.customer_data[orders][date_create]), 
        date_ref::timestamp, 
        'day'
    ) < 30,
    churn_risk := fm.core.customer_ml_batch[churn_risk],
    lifetime_value := array_sum(fm.core.customer_data[orders][price]),
    show_promocode_offline := not has_recent_orders 
        and lifetime_value > 1000.00 
        and churn_risk > 0.8e0,
;

Compute features in batch

Apply the transformation to any set of inputs, hybrid with SQL.

/* SQL */ 
SELECT
    show_promocode_offline, 
    COUNT(1) as num_customers
FROM FEATUREQL(
    SELECT 
        customer_id := bind_sql(SELECT customer_id FROM customers), 
        show_promocode_offline
) 
GROUP BY show_promocode_offline

2. Real-time / Serving

Define online sources

Connect your databases, APIs, or services. Each becomes a source feature.

CREATE FEATURES IN fm.online AS 
SELECT
    customer_source := source_jdbc(
        'postgres://user:secure@acme.eu-west-1.rds.amazonaws.com:5432/orders', 
        array[customer_history]
    ),
    ml_endpoint := source_http(
        'https://ml.acme.com/churn-v3/predict' with (method='POST')
    ),
;

Re-use features

Apply features defined for analytics to your online sources.

CREATE FEATURES IN fm.online AS 
SELECT 
    customer_data := external_view(
        'select orders from %fm.online.customer_source[customer_history]',
        on 'SELF.customer_id = %customer_id'
        as row(orders array(row(
            order_id bigint#orders, 
            date_create timestamp, 
            price decimal(10,2)
        )))
    ),
    has_recent_orders := variant(
        fm.marketing.has_recent_orders
        replacing fm.core.customer_data with customer_data
    ),
    lifetime_value := variant(
        fm.marketing.lifetime_value
        replacing fm.core.customer_data with customer_data
    ),
    ml_data := external_http(
        from fm.online.ml_endpoint with (
            query_params=row(has_recent_orders, lifetime_value)
        ) as row(churn_risk float)
    ),
    churn_risk := ml_data[churn_risk],
;

CREATE FEATURE fm.marketing.show_promocode_online AS 
SELECT 
    variant(
        fm.marketing.show_promocode_offline
        replacing fm.core.customer_data, fm.marketing.churn_risk
        with fm.online.customer_data, fm.online.churn_risk
    )
;

Compile as prepared statement

For superfast serving

CREATE FEATURE fm.marketing.show_promocode_online_ps AS
   prepared_statement(
       fm.marketing.show_promocode_online
       using inputs customer_id
   )
;

Integrate anywhere

Evaluation of the prepared statement is just an API call away.

POST /api/evaluate
Content-Type: application/json

{
    "id": "fm.marketing.show_promocode_online_ps",
    "inputs": [
        ["5423567855"],
    ]
}

Painless adoption, zero disruption

Keep what works

Your current analytics stack works fine? Keep it running. Your existing APIs and services? They stay right where they are.
FeatureMesh works alongside your infrastructure, not against it.

Start small, scale smart

DAY

Move one piece of code from your backend to FeatureMesh. Test it. See it work.

WEEK

Data scientists are writing new features in FeatureQL instead of SQL. No migration needed.

MONTH

Gradually port existing business-rule heavy projects as needed. Your backend gets leaner and cleaner.

Risk-free evolution

No big-bang deployments. No risky migrations. Just progressive enhancement of your data capabilities. Move as fast or slow as your comfort allows.

What you'll love

Data scientists

Stop rebuilding features for each model. Access clean, validated features instantly. Focus on modeling, not data plumbing.

Engineers / Data engineers

No more scattered business logic. Clear ownership. Type-safe transformations. And way less code to maintain.

Data analysts / Business teams

Understand exactly how metrics are calculated. Experiment freely. Get the insights you need without waiting for engineering.

Your next competitive advantage

Companies won’t win by just collecting data. They’ll operationalize knowledge.
FeatureMesh transforms every business rule into reusable, composable building blocks you can deploy anywhere.

When AI becomes commodity

Models will be cheap. Your advantage will be intelligence that speaks your business language. FeatureMesh turns business logic into a shared vocabulary your AI understands instantly.

When business moves at AI speed

While others wait weeks for new rules, you’ll adapt in hours. FeatureMesh’s composable features let you build, test, and deploy strategies faster than ever.

Define business logic once.Use everywhere.