What is a feature store?

In machine learning, a feature is a variable or attribute derived from raw data that is used as an input for models to generate predictions. They represent measurable aspects of behavior, context or state within data, such as purchase frequency or geographic location.

For example, in fraud detection, models rely on curated signals rather than raw data. Features might include the number of transactions in the past week or the location of recent purchases—representations designed to capture patterns that may indicate fraudulent behavior.

Features—often referred to as ML features—are generated from multiple data sources and organized into datasets that support both data science and machine learning workflows. These features are then used to train models, evaluate metrics and deploy models into production systems.

Machine learning models operate on numerical representations of data. Each data point is expressed as a set of feature values, often in vector form, where each dimension corresponds to a specific attribute. While some structured data types are inherently numerical, like accounting information, others—such as text, images or audio—are unstructured and must be transformed into structured numerical form before they can be used by a model.

One way to transform unstructured data is through feature engineering, where raw data is converted into structured, machine-readable inputs using techniques such as aggregations, filtering and encoding. Feature engineering also includes feature extraction (where algorithms derive meaningful representations from raw data) and feature selection (which identifies the most relevant variables).

Since machine learning workflows span model training and inference, features are computed from both historical data and new data in production. Maintaining alignment requires coordination across data pipelines, feature pipelines and data engineering systems—a challenge that feature stores are designed to address.

In practice, feature stores support each stage of the machine learning lifecycle:

• Feature engineering and development: Provide a structured environment for defining new features, allowing teams to share features, reuse features and avoid duplicate implementations.

• Model training: Supply historical feature data and training data, ensuring that models are trained on reliable datasets.

• Inference and serving: Deliver feature values in real time through online feature store systems, enabling low-latency predictions.

• Monitoring and iteration: Track metrics, detect skew (or uneven distribution of data) and monitor feature quality within workflows.

The performance of machine learning models—which underpin many of today’s artificial intelligence (AI) systems—depends directly on the quality of their input variables. What goes in determines what comes out.

Feature values dictate how models interpret patterns in training data and apply those patterns to new data. This coordination improves model performance by doing two things: managing feature data at scale while also providing consistency across training and inference.

As machine learning systems scale, managing feature data becomes increasingly complex. Features are generated and circulated throughout multiple workflows, often by data engineering and ML teams working in distributed environments.

Without a centralized system, duplicate features and inconsistent feature definitions emerge. Teams may compute the same feature using slightly different logic, leading to inconsistencies within datasets and pipelines. These inconsistencies make it harder to reuse features and introduce risk into model development.

During model training, features are computed from historical data and organized into training datasets. Once deployed, those same feature definitions must be applied to new data and recomputed for inference, often in real-time or near real-time environments.

Even small differences in how features are computed can introduce inconsistencies between training and production inputs—often referred to as training-serving skew—which can lead to degraded model performance.

Feature stores address these challenges by centralizing feature definitions and standardizing feature transformations. Features are defined once, stored in a shared system and accessed through an application programming interface (API) or software development kit (SDK) interface. This coordination, often managed through a feature registry, enables teams to reuse features across multiple pipelines, models and use cases.

Feature store architecture connects data between several key stages of machine learning, including:

• Ingestion and transformation
• Storage layers
• Feature serving
• Feature registry and metadata
• Orchestration and lifecycle management

Data is collected from multiple data sources and processed through ingestion pipelines. These pipelines apply data and feature transformations to convert raw data into feature values.

Feature computation can occur in multiple ways: batch processing of previously collected data; streaming pipelines for real-time updates; and on-demand feature computation at inference time. These transformations are often implemented using Python, structured query language (SQL) or other systems within automated workflows.

Feature stores use a dual storage model consisting of an offline store and an online store. The offline store, or offline feature store, maintains historical feature data and supports model training by providing access to training data and training datasets. Typically, it’s built on top of data warehouses or data lakes.

The online store, or online feature store, maintains current feature values and supports low-latency lookup during model inference. This separation between offline and online stores enables both scalability and performance across different workloads.

Feature serving is the process of delivering feature values to machine learning models. An API or SDK layer allows applications to retrieve features between environments, ensuring that feature definitions remain aligned. It also helps minimize training-serving skew and ensures that models receive up-to-date feature values when making predictions.

A feature registry acts as the centralized system of record for feature definitions. It stores metadata, lineage and versioning information, providing visibility into how features are constructed and where they are used. This traceability makes it easier to discover reusable features, enforce governance and access control, and track dependencies within workflows.

Feature stores orchestrate pipelines and workflows across the entire feature lifecycle. Common tasks include automating feature computation, managing backfill operations for historical feature data, recomputing features when definitions change and identifying duplicate or outdated features. Orchestration, therefore, ensures that feature pipelines remain reliable and scalable throughout the data platform.

While implementations vary, most feature stores provide a consistent set of capabilities that extend beyond their core architecture, enabling scalable and reliable machine learning workflows.

Together, these capabilities define how feature data is managed in machine learning workflows. They also reflect how feature stores fit within a broader data architecture.

Traditional data systems—such as warehouses and other data stores—are designed to process and move data throughout an organization. However, this data is not inherently ready for machine learning.

Feature stores build on this foundation by organizing feature data into reusable inputs for machine learning models, standardizing how features are defined, computed and served in the development and production stages.

Feature stores provide a set of practical advantages that improve how machine learning systems are developed and maintained.

• Improved model development efficiency: Reusable feature definitions reduce the need to rebuild features for each new project, allowing teams to focus on model design rather than data preparation.

• Consistency across machine learning models: Standardized feature pipelines ensure that features are computed in the same way during training and inference, reducing the risk of training-serving skew.

• Stronger collaboration among teams: Centralized feature data allows data scientists, data engineering and ML teams to share features and work from a common system of record (SOR).

• Governance and traceability: Feature stores introduce a structured SOR for feature definitions, making it easier to understand how features are defined and used across models while enforcing consistent standards.

• Support for real-time machine learning: Feature stores enable low-latency access to feature values through online feature store systems, supporting use cases such as hyper-personalization and recommendation engines.

• Scalable and repeatable workflows: Automated feature pipelines and orchestration support machine learning operations (MLOps). This empowers organizations to scale machine learning systems between teams and use cases.

Feature stores also enable high-throughput feature serving using optimized storage layers and key-value systems like Redis, which are commonly deployed as managed, in-memory services in modern data platforms. This approach helps ensure that models retrieve up-to-date feature values efficiently.

Choosing a feature store depends on an organization’s data architecture, infrastructure and machine learning maturity. Typical considerations include:

• Integration with existing data platforms
• Open source and managed options
• Architectural requirements and workloads
• Governance and trust

Feature stores must align with existing data pipelines, data warehouses, data lakes and broader data platform systems. However, integrating feature pipelines into established workflows often requires refactoring data transformations and coordinating across teams.

As a result, organizations typically begin by evaluating how a feature store integrates with existing tools such as Snowflake, Databricks and AWS services like SageMaker Feature Store. Often, feature stores are integrated as part of broader MLOps systems that connect data engineering and model deployment.¹

Feature store implementations vary widely, with organizations continually balancing performance, scalability and operational complexity.² Open source feature store frameworks such as Feast allow companies to build and manage their own feature pipelines and infrastructure, while platforms like Tecton offer fully managed, production-ready solutions.

Some organizations, however, choose to build their own end-to-end machine learning platforms, such as Uber’s Michelangelo, that include feature store functionality as part of a broader system. Ultimately, the decision to build or adopt a feature store depends on internal expertise and long-term scalability requirements.

Architectural requirements play a central role. Some use cases require real-time or low-latency feature serving, while others depend on batch processing or on-demand feature computation. High-throughput requirements also place significant demands on infrastructure as data volumes scale.

Supporting both historical data processing and real-time inference becomes complex when maintaining consistency between offline and online feature values. Research highlights how feature store design is often driven by these workload requirements, pointing to issues like latency, scalability and point-in-time correctness.³

Governance is equally important. Feature stores operate on shared feature data, so organizations need clear visibility into how features are defined, tested and used.

As feature data is shared across teams, organizations must enforce controls to prevent data leakage and ensure that features are computed consistently. Formal governance frameworks can support consistency, lineage and compliance across feature pipelines,⁴ helping to maintain trust in machine learning systems.