Feast: The Open-Source Feature Store for Real-Time ML
Feast solves training-serving skew and enables feature reuse across models - define features once and serve them consistently from both batch and real-time data sources.
Mahmudul Haque Qudrati
CEO & ML Engineer
May 5, 2026
7 min read
One AI engineering post, weekly
LLM benchmarks, prompt techniques, and token-cost breakdowns — not another AI news roundup.
Three problems plague ML feature pipelines without a feature store:
Training-serving skew. Features are computed differently at training time (batch job) and serving time (real-time API). The model was never trained on what it sees in production.
Duplicate feature computation. Ten models compute the same "user purchase count last 7 days" in ten different pipelines.
Point-in-time correctness. When generating training data, you need the feature values as they were at prediction time - not today's values retroactively applied to historical labels.
Feast solves all three.
Core Concepts
Feature View: defines a set of features from a data source.
Offline Store: historical feature data for training (Parquet files, BigQuery, Snowflake, Redshift).
Online Store: low-latency feature data for serving (Redis, DynamoDB, SQLite for dev).
Feature Service: a named set of features consumed by a model.
Team workspace
Ship faster with chat, meetings, and projects in one place — Zlyqor.
Defining Feature Views
from datetime import timedelta
from feast import Entity, FeatureView, Field, FileSource
from feast.types import Float64, Int64, String
# Define the entity (what your features describe)
user = Entity(name="user", join_keys=["user_id"])
# Define a data source
user_stats_source = FileSource(
path="data/user_stats.parquet",
timestamp_field="event_timestamp",
)
# Define the feature view
user_stats_fv = FeatureView(
name="user_stats",
entities=[user],
ttl=timedelta(days=7),
schema=[
Field(name="purchase_count_7d", dtype=Int64),
Field(name="avg_order_value_30d", dtype=Float64),
Field(name="days_since_last_login", dtype=Int64),
Field(name="country", dtype=String),
],
online=True,
source=user_stats_source,
)
Getting Historical Features for Training
from feast import FeatureStore
import pandas as pd
store = FeatureStore(repo_path=".")
# Entity DataFrame: who you want features for and at what time
entity_df = pd.DataFrame({
"user_id": [1001, 1002, 1003],
"event_timestamp": pd.to_datetime(["2025-03-01", "2025-03-15", "2025-04-01"]),
"label": [1, 0, 1], # the target variable
})
# Point-in-time correct feature retrieval
training_df = store.get_historical_features(
entity_df=entity_df,
features=[
"user_stats:purchase_count_7d",
"user_stats:avg_order_value_30d",
"user_stats:country",
],
).to_df()
print(training_df.head())
get_historical_features() returns the feature values as they were at each event_timestamp - eliminating data leakage.
Materializing to Online Store and Serving
# Push features to online store (Redis/DynamoDB)
feast materialize-incremental $(date +%Y-%m-%dT%H:%M:%S)
# In your serving API
from feast import FeatureStore
store = FeatureStore(repo_path=".")
def predict(user_id: int) -> float:
features = store.get_online_features(
features=["user_stats:purchase_count_7d", "user_stats:avg_order_value_30d"],
entity_rows=[{"user_id": user_id}],
).to_dict()
X = [[features["purchase_count_7d"][0], features["avg_order_value_30d"][0]]]
return model.predict_proba(X)[0][1]
Latency for online retrieval from Redis: typically 1-5ms.
Feast vs Tecton
Feast is fully open source, self-managed, and free. Tecton is a managed feature platform with a SaaS model, better UI, and enterprise support. For teams starting out, Feast covers all the fundamentals. For organizations with 50+ ML engineers and SLA requirements, Tecton's managed infrastructure is worth evaluating.
Resources: Feast GitHub, docs.
#feast#feature-store#mlops#real-time#feature-engineering
Mahmudul Haque Qudrati
CEO & ML Engineer
Visionary leader with extensive experience in machine learning and software development. Drives strategic innovation and business growth.
More from Mahmudul
GPT-6 Astra AGI: How to Actually Use It and Get Its Best Performance
8 min read
DeepSeek vs MiniMax vs Kimi in Coding Benchmarks: Real Scores, Real Prices, Real Tradeoffs
8 min read
GPT-6 Astra Benchmarks, Pricing, and Safety: What Developers Need to Know
5 min read
Claude Fable 5.1: Same Price, 75% Cheaper Cache, and Real Tradeoffs
4 min read
Related Articles
7 min readONNX: Export Any ML Model and Run It Anywhere
ONNX (Open Neural Network Exchange) is the universal model format - export from PyTorch, scikit-learn, or HuggingFace and run 3x faster inference with ONNX Runtime on CPU or GPU.
9 min readRedis Guide for Developers: Not Just a Cache
Redis is an in-memory data structure store used for caching, sessions, rate limiting, queues, pub/sub, and distributed locks. Here is how to use it well.
9 min readGradient Descent Explained: How Machine Learning Models Actually Learn
Gradient descent is the engine behind every modern ML model. Here is how it works, why learning rate matters, and when to use Adam over SGD.
// discussion
Comments