Introduction

Machine Learning models rarely consume raw operational data directly. Raw records are transformed into measurable inputs such as account age, average order value, number of recent transactions, days since the last activity, rolling consumption, or recent error count. These model inputs are called features.

When teams calculate features independently in notebooks, batch jobs, APIs, and production services, the same feature may acquire multiple definitions. Training may calculate a thirty-day total one way while production serving calculates it differently. This can create duplicated work, inconsistent values, hidden data leakage, and training-serving skew.

A feature store provides an organized system for defining, managing, discovering, retrieving, and serving Machine Learning features. It connects feature definitions with data sources, entities, timestamps, transformation logic, metadata, ownership, historical values, and online serving.

Learning Objectives

Prerequisites

python -m pip install feast pandas pyarrow scikit-learn

What Is a Feature?

A feature is an individual measurable input used by a Machine Learning model to calculate a prediction.

What Is a Feature Store?

A feature store is a managed data and metadata layer that makes approved Machine Learning features available for model development and production inference.

Why Use a Feature Store?

Feature Store vs Ordinary Database

Feature Store Architecture

Offline Store

The offline store provides historical feature values for training, validation, testing, backtesting, and batch scoring.

Online Store

The online store provides feature values for latency-sensitive inference. It commonly stores the latest materialized values needed by real-time prediction services.

Offline Store vs Online Store

Entities and Entity Keys

An entity represents a real-world object about which features are calculated. An entity key identifies a specific instance of that entity.

Event Time and Creation Time

Point-in-Time Correctness

Point-in-time correctness ensures that a training row receives only feature values available at or before that row's event timestamp.

Future-Information Leakage

Feature View

A feature view describes a logical collection of related features, the entities associated with them, the data source, timestamp semantics, schema, and applicable freshness behavior.

Feature Service

A feature service groups the features required by a particular model or model version. It provides one logical reference for historical and online retrieval.

Create a Feast Feature Repository

feast init customer_churn_features
cd customer_churn_features

customer_churn_features/
├── feature_store.yaml
├── data/
└── feature_repo/
    ├── __init__.py
    └── customer_features.py

Configure a Local Feast Store

project: customer_churn
registry: data/registry.db
provider: local

online_store:
  type: sqlite
  path: data/online_store.db

entity_key_serialization_version: 3

Prepare Historical Feature Data

from pathlib import Path

import numpy as np
import pandas as pd


output_path = Path(
    "data/customer_features.parquet"
)


feature_data = pd.DataFrame(
    {
        "customer_id": [
            1001,
            1002,
            1003,
            1004
        ],
        "event_timestamp": pd.to_datetime(
            [
                "2026-01-01T10:00:00Z",
                "2026-01-01T10:05:00Z",
                "2026-01-01T10:10:00Z",
                "2026-01-01T10:15:00Z"
            ],
            utc=True
        ),
        "created_timestamp": pd.to_datetime(
            [
                "2026-01-01T10:01:00Z",
                "2026-01-01T10:06:00Z",
                "2026-01-01T10:11:00Z",
                "2026-01-01T10:16:00Z"
            ],
            utc=True
        ),
        "transactions_30d": [
            4,
            8,
            2,
            12
        ],
        "average_order_value_90d": [
            42.5,
            61.0,
            28.0,
            75.5
        ],
        "support_cases_30d": [
            1,
            0,
            3,
            1
        ]
    }
)


if feature_data[
    "customer_id"
].duplicated().any():

    raise ValueError(
        "Duplicate customer identifiers "
        "were found in the example snapshot."
    )


if not np.isfinite(
    feature_data[
        [
            "transactions_30d",
            "average_order_value_90d",
            "support_cases_30d"
        ]
    ]
).all().all():

    raise ValueError(
        "Feature values must be finite."
    )


output_path.parent.mkdir(
    parents=True,
    exist_ok=True
)


feature_data.to_parquet(
    output_path,
    index=False
)

Define a Feast Entity

from feast import Entity
from feast import ValueType


customer = Entity(
    name="customer",
    join_keys=[
        "customer_id"
    ],
    value_type=ValueType.INT64,
    description=(
        "A customer represented by "
        "an internal numerical identifier"
    )
)

Define a Feast Data Source

from feast import FileSource


customer_feature_source = FileSource(
    path=(
        "data/customer_features.parquet"
    ),
    timestamp_field=(
        "event_timestamp"
    ),
    created_timestamp_column=(
        "created_timestamp"
    )
)

Define a Feast Feature View

from datetime import timedelta

from feast import FeatureView
from feast import Field
from feast.types import Float64
from feast.types import Int64


customer_activity_features = (
    FeatureView(
        name="customer_activity_features",
        entities=[
            customer
        ],
        ttl=timedelta(
            days=30
        ),
        schema=[
            Field(
                name="transactions_30d",
                dtype=Int64
            ),
            Field(
                name="average_order_value_90d",
                dtype=Float64
            ),
            Field(
                name="support_cases_30d",
                dtype=Int64
            )
        ],
        source=customer_feature_source,
        online=True,
        tags={
            "domain": "customer",
            "owner": "ml-platform",
            "feature_version": "1.0.0"
        }
    )
)

Define a Feature Service

from feast import FeatureService


customer_churn_feature_service = (
    FeatureService(
        name="customer_churn_features_v1",
        features=[
            customer_activity_features
        ],
        tags={
            "model_name": (
                "customer-churn-classifier"
            ),
            "model_feature_contract": (
                "1.0.0"
            )
        }
    )
)

Apply Feature Definitions

feast apply

Retrieve Historical Features

import pandas as pd
from feast import FeatureStore


store = FeatureStore(
    repo_path="feature_repo"
)


training_entities = pd.DataFrame(
    {
        "customer_id": [
            1001,
            1002,
            1003
        ],
        "event_timestamp": pd.to_datetime(
            [
                "2026-01-01T10:02:00Z",
                "2026-01-01T10:07:00Z",
                "2026-01-01T10:12:00Z"
            ],
            utc=True
        ),
        "churn": [
            0,
            1,
            0
        ]
    }
)


historical_job = (
    store.get_historical_features(
        entity_df=training_entities,
        features=(
            customer_churn_feature_service
        )
    )
)


training_dataset = (
    historical_job.to_df()
)


print(
    training_dataset
)

Save a Reproducible Training Dataset

from pathlib import Path


training_output = Path(
    "training-data/customer_churn_v1.parquet"
)


training_output.parent.mkdir(
    parents=True,
    exist_ok=True
)


training_dataset.to_parquet(
    training_output,
    index=False
)

Materialize Features

Materialization copies or synchronizes feature values from an offline source into the configured online store for inference.

feast materialize-incremental \
  2026-01-02T00:00:00

Retrieve Online Features

online_response = (
    store.get_online_features(
        features=(
            customer_churn_feature_service
        ),
        entity_rows=[
            {
                "customer_id": 1001
            }
        ]
    )
)


online_features = (
    online_response.to_dict()
)


print(
    online_features
)

Use Online Features for Prediction

import pandas as pd


feature_frame = pd.DataFrame(
    {
        "transactions_30d": (
            online_features[
                "transactions_30d"
            ]
        ),
        "average_order_value_90d": (
            online_features[
                "average_order_value_90d"
            ]
        ),
        "support_cases_30d": (
            online_features[
                "support_cases_30d"
            ]
        )
    }
)


probability = float(
    model_pipeline.predict_proba(
        feature_frame
    )[0, 1]
)


print(
    {
        "positive_class_probability": (
            probability
        ),
        "model_version": "1.0.0",
        "feature_service": (
            "customer_churn_features_v1"
        )
    }
)

Training-Serving Consistency

Test Offline and Online Consistency

import numpy as np


def verify_feature_consistency(
    offline_values,
    online_values,
    feature_names
):
    mismatches = []

    for feature_name in feature_names:

        offline_value = offline_values[
            feature_name
        ]

        online_value = online_values[
            feature_name
        ]

        if not np.isclose(
            float(
                offline_value
            ),
            float(
                online_value
            ),
            rtol=1e-10,
            atol=1e-12
        ):
            mismatches.append(
                {
                    "feature": feature_name,
                    "offline": float(
                        offline_value
                    ),
                    "online": float(
                        online_value
                    )
                }
            )

    return {
        "consistent": (
            len(
                mismatches
            )
            ==
            0
        ),
        "mismatches": mismatches
    }

Feature Freshness

Feature freshness measures how old a feature value is when it is retrieved or used.

import pandas as pd


def calculate_feature_age_seconds(
    retrieval_time,
    feature_event_time
):
    retrieval_time = pd.Timestamp(
        retrieval_time
    )

    feature_event_time = pd.Timestamp(
        feature_event_time
    )

    if retrieval_time.tzinfo is None:
        retrieval_time = retrieval_time.tz_localize(
            "UTC"
        )

    if feature_event_time.tzinfo is None:
        feature_event_time = (
            feature_event_time.tz_localize(
                "UTC"
            )
        )

    feature_age = (
        retrieval_time
        -
        feature_event_time
    )

    return float(
        feature_age.total_seconds()
    )

Feature Quality Monitoring

def calculate_feature_quality(
    feature_series
):
    total_count = len(
        feature_series
    )

    if total_count == 0:

        raise ValueError(
            "Feature observations are required."
        )

    return {
        "sample_count": int(
            total_count
        ),
        "missing_rate": float(
            feature_series.isna().mean()
        ),
        "distinct_count": int(
            feature_series.nunique(
                dropna=True
            )
        )
    }

Batch, Streaming, and On-Demand Features

On-Demand Transformation

from feast import Field
from feast import RequestSource
from feast.on_demand_feature_view import on_demand_feature_view
from feast.types import Float64


transaction_request = RequestSource(
    name="transaction_request",
    schema=[
        Field(
            name="current_transaction_amount",
            dtype=Float64
        )
    ]
)


@on_demand_feature_view(
    sources=[
        customer_activity_features,
        transaction_request
    ],
    schema=[
        Field(
            name="amount_to_average_ratio",
            dtype=Float64
        )
    ]
)
def transaction_ratio(
    inputs
):
    output = pd.DataFrame()

    denominator = (
        inputs[
            "average_order_value_90d"
        ]
        .replace(
            0,
            np.nan
        )
    )

    output[
        "amount_to_average_ratio"
    ] = (
        inputs[
            "current_transaction_amount"
        ]
        /
        denominator
    )

    return output

Version Feature Definitions

Feature Lineage

Feature Metadata

{
    "feature_name": "transactions_30d",
    "feature_version": "1.0.0",
    "entity": "customer",
    "join_key": "customer_id",
    "data_type": "integer",
    "description": "Completed customer transactions during the prior 30 days",
    "event_time_field": "event_timestamp",
    "source_version": "replace-with-source-version",
    "transformation_version": "replace-with-code-version",
    "freshness_requirement": "replace-with-approved-requirement",
    "owner": "replace-with-feature-owner",
    "status": "approved",
    "intended_use": "Customer behavior modelling"
}

Security and Access Control

Responsible Feature Management

Online Retrieval Failure Handling

Feature Store Monitoring

Feature Deprecation

Cost Considerations

Common Feature Store Mistakes

Recommended Feature Store Workflow

Hands-On Practice

Knowledge Check

Feature Store Readiness Checklist

Lesson Summary