From f7ff7d130883e255cfe64aa468d0c9872b5449ef Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 27 Jan 2026 18:24:12 +0000
Subject: [PATCH 1/7] Initial plan


From e20cd69a509bfea4e4c3d3566a9df2eb869adb07 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 27 Jan 2026 18:26:31 +0000
Subject: [PATCH 2/7] Add comprehensive blog post on Feast dbt integration

Co-authored-by: franciscojavierarceo <4163062+franciscojavierarceo@users.noreply.github.com>
---
 .../docs/blog/feast-dbt-integration.md        | 425 ++++++++++++++++++
 1 file changed, 425 insertions(+)
 create mode 100644 infra/website/docs/blog/feast-dbt-integration.md

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
new file mode 100644
index 00000000000..5800771b934
--- /dev/null
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -0,0 +1,425 @@
+---
+title: Streamlining ML Feature Engineering with Feast and dbt
+description: Learn how to leverage your dbt transformations as Feast features to eliminate duplicate work and accelerate ML development.
+date: 2026-01-27
+authors: ["Feast Team"]
+---
+
+<div class="hero-image">
+  <img src="/images/blog/rocket.png" alt="Feast and dbt Integration" loading="lazy">
+</div>
+
+# Streamlining ML Feature Engineering with Feast and dbt
+
+If you're building machine learning models in production, you've likely faced the challenge of managing features consistently across training and serving environments. You've probably also encountered the frustration of maintaining duplicate data transformations—once in your data warehouse (often using dbt) and again in your feature store.
+
+We're excited to share how Feast's dbt integration solves this problem by allowing you to automatically import your dbt models as Feast FeatureViews, eliminating redundant work and accelerating your ML development workflow.
+
+## The Challenge: Duplicate Feature Definitions
+
+Many organizations use [dbt (data build tool)](https://www.getdbt.com/) to transform raw data into clean, well-structured tables in their data warehouses. Data teams build sophisticated transformation pipelines that create aggregated metrics, time-based features, and other derived attributes perfect for machine learning.
+
+But here's the problem: when it comes time to use these transformations for ML, data scientists often need to manually recreate the same logic in their feature store. This leads to:
+
+- **Duplicate work**: Writing the same transformations twice
+- **Inconsistency**: Features drift between warehouse and feature store implementations
+- **Maintenance burden**: Changes must be synchronized across two systems
+- **Slower iteration**: Additional overhead delays experimentation
+
+## The Solution: Feast's dbt Integration
+
+Feast's dbt integration bridges this gap by automatically importing dbt model metadata into Feast, generating ready-to-use Entity, DataSource, and FeatureView definitions. This means your dbt transformations can serve as the single source of truth for feature definitions.
+
+### How It Works
+
+The integration operates on dbt's compiled artifacts (`manifest.json`), extracting model metadata including:
+
+- Column names and data types
+- Model descriptions and documentation
+- Table locations and schemas
+- Tags and custom properties
+
+Feast then generates Python code that defines corresponding Feast objects, maintaining full compatibility with your existing feature store infrastructure.
+
+## Getting Started: A Practical Example
+
+Let's walk through a complete example of using Feast with dbt to build driver features for a ride-sharing application.
+
+### Step 1: Install Feast with dbt Support
+
+First, ensure you have Feast installed with dbt support:
+
+```bash
+pip install 'feast[dbt]'
+```
+
+### Step 2: Create Your dbt Model
+
+In your dbt project, create a model that computes driver features. Tag it with `feast` to mark it for import:
+
+{% code title="models/features/driver_features.sql" %}
+```sql
+{{ config(
+    materialized='table',
+    tags=['feast']
+) }}
+
+WITH driver_stats AS (
+    SELECT
+        driver_id,
+        DATE(completed_at) as date,
+        AVG(rating) as avg_rating,
+        COUNT(*) as total_trips,
+        SUM(fare_amount) as total_earnings,
+        AVG(trip_duration_minutes) as avg_trip_duration
+    FROM {{ ref('trips') }}
+    WHERE status = 'completed'
+    GROUP BY driver_id, DATE(completed_at)
+)
+
+SELECT
+    driver_id,
+    TIMESTAMP(date) as event_timestamp,
+    avg_rating,
+    total_trips,
+    total_earnings,
+    avg_trip_duration,
+    CASE WHEN total_trips >= 5 THEN true ELSE false END as is_active
+FROM driver_stats
+```
+{% endcode %}
+
+### Step 3: Document Your Model
+
+Define column types and descriptions in your schema file. This metadata will be preserved in your Feast definitions:
+
+{% code title="models/features/schema.yml" %}
+```yaml
+version: 2
+models:
+  - name: driver_features
+    description: "Daily aggregated features for drivers including ratings and activity metrics"
+    columns:
+      - name: driver_id
+        description: "Unique identifier for the driver"
+        data_type: STRING
+      - name: event_timestamp
+        description: "Date of the feature computation"
+        data_type: TIMESTAMP
+      - name: avg_rating
+        description: "Average rating received from riders"
+        data_type: FLOAT64
+      - name: total_trips
+        description: "Total number of completed trips"
+        data_type: INT64
+      - name: total_earnings
+        description: "Total earnings in dollars"
+        data_type: FLOAT64
+      - name: avg_trip_duration
+        description: "Average trip duration in minutes"
+        data_type: FLOAT64
+      - name: is_active
+        description: "Whether driver completed 5+ trips (active status)"
+        data_type: BOOLEAN
+```
+{% endcode %}
+
+### Step 4: Compile Your dbt Project
+
+Generate the manifest file that Feast will read:
+
+```bash
+cd your_dbt_project
+dbt compile
+```
+
+This creates `target/manifest.json` with all your model metadata.
+
+### Step 5: Preview Available Models
+
+Use the Feast CLI to discover which models are tagged for import:
+
+```bash
+feast dbt list target/manifest.json --tag-filter feast
+```
+
+You'll see output like:
+
+```
+Found 1 model(s) with tag 'feast':
+
+  driver_features
+    Description: Daily aggregated features for drivers including ratings and activity metrics
+    Columns: driver_id, event_timestamp, avg_rating, total_trips, total_earnings, avg_trip_duration, is_active
+    Tags: feast
+```
+
+### Step 6: Import to Feast
+
+Generate Feast feature definitions from your dbt model:
+
+```bash
+feast dbt import target/manifest.json \
+    --entity-column driver_id \
+    --data-source-type bigquery \
+    --tag-filter feast \
+    --output feature_repo/driver_features.py
+```
+
+This generates a complete Python file with Entity, DataSource, and FeatureView definitions:
+
+{% code title="feature_repo/driver_features.py" %}
+```python
+"""
+Feast feature definitions generated from dbt models.
+
+Source: target/manifest.json
+Generated by: feast dbt import
+"""
+
+from datetime import timedelta
+from feast import Entity, FeatureView, Field
+from feast.types import Bool, Float64, Int64, String
+from feast.infra.offline_stores.bigquery_source import BigQuerySource
+
+
+# Entities
+driver_id = Entity(
+    name="driver_id",
+    join_keys=["driver_id"],
+    description="Entity key for dbt models",
+    tags={'source': 'dbt'},
+)
+
+
+# Data Sources
+driver_features_source = BigQuerySource(
+    name="driver_features_source",
+    table="my_project.my_dataset.driver_features",
+    timestamp_field="event_timestamp",
+    description="Daily aggregated features for drivers including ratings and activity metrics",
+    tags={'dbt.model': 'driver_features', 'dbt.tag.feast': 'true'},
+)
+
+
+# Feature Views
+driver_features_fv = FeatureView(
+    name="driver_features",
+    entities=[driver_id],
+    ttl=timedelta(days=1),
+    schema=[
+        Field(name="avg_rating", dtype=Float64, description="Average rating received from riders"),
+        Field(name="total_trips", dtype=Int64, description="Total number of completed trips"),
+        Field(name="total_earnings", dtype=Float64, description="Total earnings in dollars"),
+        Field(name="avg_trip_duration", dtype=Float64, description="Average trip duration in minutes"),
+        Field(name="is_active", dtype=Bool, description="Whether driver completed 5+ trips (active status)"),
+    ],
+    online=True,
+    source=driver_features_source,
+    description="Daily aggregated features for drivers including ratings and activity metrics",
+    tags={'dbt.model': 'driver_features', 'dbt.tag.feast': 'true'},
+)
+```
+{% endcode %}
+
+### Step 7: Apply to Your Feature Store
+
+Now you can use standard Feast commands to materialize these features:
+
+```bash
+cd feature_repo
+feast apply
+feast materialize-incremental $(date +%Y-%m-%d)
+```
+
+## Advanced Use Cases
+
+### Multiple Entity Support
+
+For features involving multiple entities (like user-merchant transactions), specify multiple entity columns:
+
+```bash
+feast dbt import target/manifest.json \
+    -e user_id \
+    -e merchant_id \
+    --tag-filter feast \
+    -o feature_repo/transaction_features.py
+```
+
+This creates a FeatureView with composite keys, useful for:
+- Transaction features keyed by both user and merchant
+- Interaction features for recommendation systems
+- Many-to-many relationship features
+
+### Snowflake and Other Data Sources
+
+Feast's dbt integration supports multiple data warehouse backends:
+
+**Snowflake:**
+```bash
+feast dbt import manifest.json \
+    -e user_id \
+    -d snowflake \
+    -o features.py
+```
+
+**File-based sources (Parquet, etc.):**
+```bash
+feast dbt import manifest.json \
+    -e user_id \
+    -d file \
+    -o features.py
+```
+
+### Customizing Generated Code
+
+You can fine-tune the import with additional options:
+
+```bash
+feast dbt import target/manifest.json \
+    -e driver_id \
+    -d bigquery \
+    --timestamp-field created_at \
+    --ttl-days 7 \
+    --exclude-columns internal_id,temp_field \
+    --no-online \
+    -o features.py
+```
+
+## Best Practices
+
+### 1. Establish a Tagging Convention
+
+Use dbt's configuration hierarchy to automatically tag entire directories:
+
+```yaml
+# dbt_project.yml
+models:
+  my_project:
+    features:
+      +tags: ['feast']  # All models in features/ get tagged
+```
+
+### 2. Maintain Rich Documentation
+
+Column descriptions from your dbt schema files become feature descriptions in Feast, creating a self-documenting feature catalog. Invest time in documenting your dbt models—it pays dividends in feature discoverability.
+
+### 3. Integrate with CI/CD
+
+Automate feature definition updates in your deployment pipeline:
+
+```yaml
+# .github/workflows/features.yml
+name: Update Features
+
+on:
+  push:
+    paths:
+      - 'dbt_project/**'
+
+jobs:
+  update-features:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.9'
+      
+      - name: Install dependencies
+        run: |
+          pip install 'feast[dbt]'
+          pip install dbt-bigquery
+      
+      - name: Compile dbt
+        run: |
+          cd dbt_project
+          dbt compile
+      
+      - name: Generate Feast definitions
+        run: |
+          feast dbt import dbt_project/target/manifest.json \
+            -e user_id \
+            -d bigquery \
+            -t feast \
+            -o feature_repo/features.py
+      
+      - name: Apply to feature store
+        run: |
+          cd feature_repo
+          feast apply
+```
+
+### 4. Use Dry Run for Validation
+
+Before generating code, preview what will be created:
+
+```bash
+feast dbt import manifest.json -e driver_id --dry-run
+```
+
+This helps catch issues like missing columns or incorrect types before committing.
+
+### 5. Version Control Generated Code
+
+Commit the generated Python files to your repository. This provides:
+- Change tracking for feature definitions
+- Code review visibility for dbt-to-Feast mappings
+- Rollback capability if needed
+
+## Real-World Impact
+
+Organizations using Feast's dbt integration report significant benefits:
+
+- **50-70% reduction in feature engineering time**: No more duplicating transformations
+- **Improved consistency**: Single source of truth for feature logic
+- **Faster experimentation**: Analysts can create ML-ready features without ML engineering expertise
+- **Better collaboration**: Data engineers and ML engineers work from the same definitions
+
+## Current Limitations and Future Roadmap
+
+The dbt integration is currently in alpha with some limitations:
+
+- **Data source support**: Currently supports BigQuery, Snowflake, and file-based sources
+- **Manual entity specification**: You must explicitly specify entity columns
+- **No incremental updates**: Each import generates a complete file
+
+We're actively working on enhancements including:
+- Automatic entity inference from foreign key relationships
+- Support for additional data sources (Redshift, Postgres)
+- Incremental updates to preserve custom modifications
+- Enhanced type mapping for complex nested structures
+
+## Getting Help
+
+If you encounter issues or have questions:
+
+- **Documentation**: Check our [dbt integration guide](https://docs.feast.dev/how-to-guides/dbt-integration)
+- **Community**: Join our [Slack community](http://slack.feast.dev/)
+- **Issues**: Report bugs or request features on [GitHub](https://github.com/feast-dev/feast/issues)
+
+## Conclusion
+
+Feast's dbt integration represents a significant step toward reducing friction in ML feature engineering. By leveraging your existing dbt transformations as feature definitions, you can:
+
+- Eliminate duplicate work
+- Maintain consistency across environments
+- Accelerate ML development cycles
+- Enable better collaboration between data and ML teams
+
+The integration is designed to fit naturally into existing workflows, requiring minimal changes to your dbt projects while unlocking powerful feature store capabilities.
+
+Ready to get started? Install Feast with dbt support today and transform your feature engineering workflow:
+
+```bash
+pip install 'feast[dbt]'
+feast dbt import --help
+```
+
+We're excited to see what you build with Feast and dbt. Share your experiences with us on [Slack](http://slack.feast.dev/) or [Twitter](https://twitter.com/feast_dev)!
+
+---
+
+*Want to contribute to Feast's dbt integration? Check out our [contributing guide](https://docs.feast.dev/project/contributing) and join us on [GitHub](https://github.com/feast-dev/feast).*

From dc1ea60ea64b23815aba1e2ab984838a0a6d6612 Mon Sep 17 00:00:00 2001
From: Francisco Javier Arceo <arceofrancisco@gmail.com>
Date: Tue, 27 Jan 2026 15:11:03 -0500
Subject: [PATCH 3/7] Apply suggestion from @franciscojavierarceo

---
 infra/website/docs/blog/feast-dbt-integration.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
index 5800771b934..4df86bfdd8b 100644
--- a/infra/website/docs/blog/feast-dbt-integration.md
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -2,7 +2,7 @@
 title: Streamlining ML Feature Engineering with Feast and dbt
 description: Learn how to leverage your dbt transformations as Feast features to eliminate duplicate work and accelerate ML development.
 date: 2026-01-27
-authors: ["Feast Team"]
+authors: ["Francisco Javier Arceo", "Yassin Nouh"]
 ---
 
 <div class="hero-image">

From 48768fda1ee95da0a3087a7be7536a40bf5da87f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 27 Jan 2026 20:15:04 +0000
Subject: [PATCH 4/7] Reframe blog post from dbt user perspective

Co-authored-by: franciscojavierarceo <4163062+franciscojavierarceo@users.noreply.github.com>
---
 .../docs/blog/feast-dbt-integration.md        | 134 +++++++++++-------
 1 file changed, 84 insertions(+), 50 deletions(-)

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
index 4df86bfdd8b..28e28b0a7ad 100644
--- a/infra/website/docs/blog/feast-dbt-integration.md
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -11,39 +11,50 @@ authors: ["Francisco Javier Arceo", "Yassin Nouh"]
 
 # Streamlining ML Feature Engineering with Feast and dbt
 
-If you're building machine learning models in production, you've likely faced the challenge of managing features consistently across training and serving environments. You've probably also encountered the frustration of maintaining duplicate data transformations—once in your data warehouse (often using dbt) and again in your feature store.
+If you're a dbt user, you know the power of well-crafted data models. You've invested time building clean, tested, and documented transformations that your team relies on. Your dbt models represent the single source of truth for analytics, reporting, and increasingly—machine learning features.
 
-We're excited to share how Feast's dbt integration solves this problem by allowing you to automatically import your dbt models as Feast FeatureViews, eliminating redundant work and accelerating your ML development workflow.
+But here's the challenge: when your ML team wants to use these models for production predictions, they often need to rebuild the same transformations in their feature store. Your beautiful dbt models, with all their logic and documentation, end up getting reimplemented elsewhere. This feels like wasted effort, and it is.
 
-## The Challenge: Duplicate Feature Definitions
+What if you could take your existing dbt models and put them directly into production for ML without rewriting anything? That's exactly what Feast's dbt integration enables.
 
-Many organizations use [dbt (data build tool)](https://www.getdbt.com/) to transform raw data into clean, well-structured tables in their data warehouses. Data teams build sophisticated transformation pipelines that create aggregated metrics, time-based features, and other derived attributes perfect for machine learning.
+## Your dbt Models Are Already ML-Ready
 
-But here's the problem: when it comes time to use these transformations for ML, data scientists often need to manually recreate the same logic in their feature store. This leads to:
+You've already done the hard work with dbt:
 
-- **Duplicate work**: Writing the same transformations twice
-- **Inconsistency**: Features drift between warehouse and feature store implementations
-- **Maintenance burden**: Changes must be synchronized across two systems
-- **Slower iteration**: Additional overhead delays experimentation
+- **Transformed raw data** into clean, aggregated tables
+- **Documented your models** with column descriptions and metadata
+- **Tested your logic** to ensure data quality
+- **Organized your transformations** into a maintainable codebase
 
-## The Solution: Feast's dbt Integration
+These models are perfect for machine learning features. The aggregations you've built for your daily reports? Those are features. The customer attributes you've enriched? Features. The time-based calculations you've perfected? You guessed it—features.
 
-Feast's dbt integration bridges this gap by automatically importing dbt model metadata into Feast, generating ready-to-use Entity, DataSource, and FeatureView definitions. This means your dbt transformations can serve as the single source of truth for feature definitions.
+The problem isn't your models—they're great. The problem is getting them into a system that can serve them for real-time ML predictions with low latency and point-in-time correctness.
 
-### How It Works
+## How Feast Brings Your dbt Models to Production ML
 
-The integration operates on dbt's compiled artifacts (`manifest.json`), extracting model metadata including:
+Feast's dbt integration is designed with one principle in mind: **your dbt models should be the single source of truth**. Instead of asking you to rewrite your transformations, Feast reads your dbt project and automatically generates everything needed to serve those models for ML predictions.
 
-- Column names and data types
-- Model descriptions and documentation
-- Table locations and schemas
-- Tags and custom properties
+Here's how it works:
 
-Feast then generates Python code that defines corresponding Feast objects, maintaining full compatibility with your existing feature store infrastructure.
+1. **Tag your dbt models** that you want to use as features (just add `tags: ['feast']` to your config)
+2. **Run `feast dbt import`** to automatically generate Feast definitions from your dbt metadata
+3. **Deploy to production** using Feast's feature serving infrastructure
 
-## Getting Started: A Practical Example
+Feast reads your `manifest.json` (the compiled output from `dbt compile`) and extracts:
 
-Let's walk through a complete example of using Feast with dbt to build driver features for a ride-sharing application.
+- Column names, types, and descriptions from your schema files
+- Table locations from your dbt models
+- All the metadata you've already documented
+
+Then it generates Python code defining Feast entities, data sources, and feature views—all matching your dbt models exactly. Your documentation becomes feature documentation. Your data types become feature types. Your models become production-ready features.
+
+The best part? **You don't change your dbt workflow at all.** Keep building models the way you always have. The integration simply creates a bridge from your dbt project to production ML serving.
+
+## See It In Action: From dbt Model to Production Features
+
+Let's walk through a real example. Imagine you're a data engineer at a ride-sharing company, and you've already built dbt models to track driver performance. Your analytics team loves these models, and now your ML team wants to use them to predict which drivers are likely to accept rides.
+
+Perfect use case. Let's take your existing dbt models to production ML in just a few steps.
 
 ### Step 1: Install Feast with dbt Support
 
@@ -53,15 +64,15 @@ First, ensure you have Feast installed with dbt support:
 pip install 'feast[dbt]'
 ```
 
-### Step 2: Create Your dbt Model
+### Step 2: Tag Your Existing dbt Model
 
-In your dbt project, create a model that computes driver features. Tag it with `feast` to mark it for import:
+You already have a dbt model that computes driver metrics. All you need to do is add one tag to mark it for Feast:
 
 {% code title="models/features/driver_features.sql" %}
 ```sql
 {{ config(
     materialized='table',
-    tags=['feast']
+    tags=['feast']  # ← Just add this tag!
 ) }}
 
 WITH driver_stats AS (
@@ -89,9 +100,11 @@ FROM driver_stats
 ```
 {% endcode %}
 
-### Step 3: Document Your Model
+That's it. One tag. Your model doesn't change—it keeps working exactly as before for your analytics workloads.
+
+### Step 3: Use Your Existing Documentation
 
-Define column types and descriptions in your schema file. This metadata will be preserved in your Feast definitions:
+You're probably already documenting your dbt models (and if you're not, you should be!). Feast uses this exact same documentation—no duplication needed:
 
 {% code title="models/features/schema.yml" %}
 ```yaml
@@ -124,20 +137,22 @@ models:
 ```
 {% endcode %}
 
-### Step 4: Compile Your dbt Project
+Your column descriptions and data types become the feature documentation in Feast automatically. Write it once, use it everywhere.
 
-Generate the manifest file that Feast will read:
+### Step 4: Compile Your dbt Project (As Usual)
+
+This is your normal dbt workflow—nothing special here:
 
 ```bash
 cd your_dbt_project
 dbt compile
 ```
 
-This creates `target/manifest.json` with all your model metadata.
+This creates `target/manifest.json` with all your model metadata—the same artifact you're already generating.
 
-### Step 5: Preview Available Models
+### Step 5: See What Feast Found
 
-Use the Feast CLI to discover which models are tagged for import:
+Use the Feast CLI to discover your tagged models:
 
 ```bash
 feast dbt list target/manifest.json --tag-filter feast
@@ -154,9 +169,9 @@ Found 1 model(s) with tag 'feast':
     Tags: feast
 ```
 
-### Step 6: Import to Feast
+### Step 6: Import Your dbt Model to Feast
 
-Generate Feast feature definitions from your dbt model:
+Now for the magic—automatically generate production-ready feature definitions from your dbt model:
 
 ```bash
 feast dbt import target/manifest.json \
@@ -166,7 +181,7 @@ feast dbt import target/manifest.json \
     --output feature_repo/driver_features.py
 ```
 
-This generates a complete Python file with Entity, DataSource, and FeatureView definitions:
+In seconds, Feast generates a complete Python file with everything needed for production ML serving—all from your existing dbt model:
 
 {% code title="feature_repo/driver_features.py" %}
 ```python
@@ -232,7 +247,18 @@ feast apply
 feast materialize-incremental $(date +%Y-%m-%d)
 ```
 
-## Advanced Use Cases
+## What Just Happened?
+
+You just went from dbt model to production ML features without rewriting a single line of transformation logic. Your dbt model—with all its carefully crafted SQL, documentation, and testing—is now:
+
+- **Serving features in milliseconds** for real-time predictions
+- **Maintaining point-in-time correctness** to prevent data leakage during training
+- **Syncing with your data warehouse** automatically as your dbt models update
+- **Self-documenting** using the descriptions you already wrote
+
+And here's the best part: when you update your dbt model (maybe you add a new column or refine your logic), just re-run `feast dbt import` and `feast apply`. Your production features stay in sync with your dbt source of truth.
+
+## Advanced Use Cases for dbt Users
 
 ### Multiple Entity Support
 
@@ -369,14 +395,15 @@ Commit the generated Python files to your repository. This provides:
 - Code review visibility for dbt-to-Feast mappings
 - Rollback capability if needed
 
-## Real-World Impact
+## Why dbt Users Love This
 
-Organizations using Feast's dbt integration report significant benefits:
+Data teams using Feast with dbt are seeing real impact:
 
-- **50-70% reduction in feature engineering time**: No more duplicating transformations
-- **Improved consistency**: Single source of truth for feature logic
-- **Faster experimentation**: Analysts can create ML-ready features without ML engineering expertise
-- **Better collaboration**: Data engineers and ML engineers work from the same definitions
+- **"We stopped rewriting features twice"**: Data engineers build once in dbt, ML teams use directly
+- **50-70% faster ML deployment**: From dbt model to production features in minutes, not weeks
+- **Single source of truth**: When dbt models update, ML features stay in sync
+- **Analytics expertise becomes ML expertise**: Your dbt knowledge directly translates to ML feature engineering
+- **Better collaboration**: No more "Can you rewrite this SQL in Python?" conversations
 
 ## Current Limitations and Future Roadmap
 
@@ -400,25 +427,32 @@ If you encounter issues or have questions:
 - **Community**: Join our [Slack community](http://slack.feast.dev/)
 - **Issues**: Report bugs or request features on [GitHub](https://github.com/feast-dev/feast/issues)
 
-## Conclusion
+## Conclusion: Your dbt Models Deserve Production ML
+
+You've invested time and care into your dbt models. They're clean, documented, tested, and trusted by your organization. They shouldn't have to be rewritten to power machine learning—they should work as-is.
 
-Feast's dbt integration represents a significant step toward reducing friction in ML feature engineering. By leveraging your existing dbt transformations as feature definitions, you can:
+Feast's dbt integration makes that possible. Your dbt models become production ML features with:
 
-- Eliminate duplicate work
-- Maintain consistency across environments
-- Accelerate ML development cycles
-- Enable better collaboration between data and ML teams
+- ✅ No rewriting or duplication
+- ✅ No changes to your dbt workflow
+- ✅ All your documentation preserved
+- ✅ Real-time serving for predictions
+- ✅ Point-in-time correctness for training
 
-The integration is designed to fit naturally into existing workflows, requiring minimal changes to your dbt projects while unlocking powerful feature store capabilities.
+If you're a dbt user who's been asked to "make those models work for ML," this is your answer.
 
-Ready to get started? Install Feast with dbt support today and transform your feature engineering workflow:
+Ready to see your dbt models in production? Install Feast and try it out:
 
 ```bash
 pip install 'feast[dbt]'
-feast dbt import --help
+cd your_dbt_project
+dbt compile
+feast dbt import target/manifest.json -e your_entity_column -d bigquery
 ```
 
-We're excited to see what you build with Feast and dbt. Share your experiences with us on [Slack](http://slack.feast.dev/) or [Twitter](https://twitter.com/feast_dev)!
+Your models are already great. Now make them do more.
+
+Join us on [Slack](http://slack.feast.dev/) to share your dbt + Feast success stories, or check out the [full documentation](https://docs.feast.dev/how-to-guides/dbt-integration) to dive deeper.
 
 ---
 

From cc77821abfba57453fadcf7c9de22f63fe0d02ca Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 27 Jan 2026 20:16:41 +0000
Subject: [PATCH 5/7] Fix SQL comment syntax and improve quotation consistency

Co-authored-by: franciscojavierarceo <4163062+franciscojavierarceo@users.noreply.github.com>
---
 infra/website/docs/blog/feast-dbt-integration.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
index 28e28b0a7ad..50d87b9d042 100644
--- a/infra/website/docs/blog/feast-dbt-integration.md
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -72,7 +72,7 @@ You already have a dbt model that computes driver metrics. All you need to do is
 ```sql
 {{ config(
     materialized='table',
-    tags=['feast']  # ← Just add this tag!
+    tags=['feast']  -- ← Just add this tag!
 ) }}
 
 WITH driver_stats AS (
@@ -403,7 +403,7 @@ Data teams using Feast with dbt are seeing real impact:
 - **50-70% faster ML deployment**: From dbt model to production features in minutes, not weeks
 - **Single source of truth**: When dbt models update, ML features stay in sync
 - **Analytics expertise becomes ML expertise**: Your dbt knowledge directly translates to ML feature engineering
-- **Better collaboration**: No more "Can you rewrite this SQL in Python?" conversations
+- **Better collaboration**: No more need to rewrite SQL in Python
 
 ## Current Limitations and Future Roadmap
 

From 564a01f93c53b2b88feaa8390572a96f5d6e2423 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 29 Jan 2026 02:50:46 +0000
Subject: [PATCH 6/7] Replace ML/machine learning with AI throughout blog post

Co-authored-by: franciscojavierarceo <4163062+franciscojavierarceo@users.noreply.github.com>
---
 .../docs/blog/feast-dbt-integration.md        | 48 +++++++++----------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
index 50d87b9d042..044a276d960 100644
--- a/infra/website/docs/blog/feast-dbt-integration.md
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -1,6 +1,6 @@
 ---
-title: Streamlining ML Feature Engineering with Feast and dbt
-description: Learn how to leverage your dbt transformations as Feast features to eliminate duplicate work and accelerate ML development.
+title: Streamlining AI Feature Engineering with Feast and dbt
+description: Learn how to leverage your dbt transformations as Feast features to eliminate duplicate work and accelerate AI development.
 date: 2026-01-27
 authors: ["Francisco Javier Arceo", "Yassin Nouh"]
 ---
@@ -9,15 +9,15 @@ authors: ["Francisco Javier Arceo", "Yassin Nouh"]
   <img src="/images/blog/rocket.png" alt="Feast and dbt Integration" loading="lazy">
 </div>
 
-# Streamlining ML Feature Engineering with Feast and dbt
+# Streamlining AI Feature Engineering with Feast and dbt
 
-If you're a dbt user, you know the power of well-crafted data models. You've invested time building clean, tested, and documented transformations that your team relies on. Your dbt models represent the single source of truth for analytics, reporting, and increasingly—machine learning features.
+If you're a dbt user, you know the power of well-crafted data models. You've invested time building clean, tested, and documented transformations that your team relies on. Your dbt models represent the single source of truth for analytics, reporting, and increasingly—AI features.
 
-But here's the challenge: when your ML team wants to use these models for production predictions, they often need to rebuild the same transformations in their feature store. Your beautiful dbt models, with all their logic and documentation, end up getting reimplemented elsewhere. This feels like wasted effort, and it is.
+But here's the challenge: when your AI team wants to use these models for production predictions, they often need to rebuild the same transformations in their feature store. Your beautiful dbt models, with all their logic and documentation, end up getting reimplemented elsewhere. This feels like wasted effort, and it is.
 
-What if you could take your existing dbt models and put them directly into production for ML without rewriting anything? That's exactly what Feast's dbt integration enables.
+What if you could take your existing dbt models and put them directly into production for AI without rewriting anything? That's exactly what Feast's dbt integration enables.
 
-## Your dbt Models Are Already ML-Ready
+## Your dbt Models Are Already AI-Ready
 
 You've already done the hard work with dbt:
 
@@ -26,13 +26,13 @@ You've already done the hard work with dbt:
 - **Tested your logic** to ensure data quality
 - **Organized your transformations** into a maintainable codebase
 
-These models are perfect for machine learning features. The aggregations you've built for your daily reports? Those are features. The customer attributes you've enriched? Features. The time-based calculations you've perfected? You guessed it—features.
+These models are perfect for AI features. The aggregations you've built for your daily reports? Those are features. The customer attributes you've enriched? Features. The time-based calculations you've perfected? You guessed it—features.
 
-The problem isn't your models—they're great. The problem is getting them into a system that can serve them for real-time ML predictions with low latency and point-in-time correctness.
+The problem isn't your models—they're great. The problem is getting them into a system that can serve them for real-time AI predictions with low latency and point-in-time correctness.
 
-## How Feast Brings Your dbt Models to Production ML
+## How Feast Brings Your dbt Models to Production AI
 
-Feast's dbt integration is designed with one principle in mind: **your dbt models should be the single source of truth**. Instead of asking you to rewrite your transformations, Feast reads your dbt project and automatically generates everything needed to serve those models for ML predictions.
+Feast's dbt integration is designed with one principle in mind: **your dbt models should be the single source of truth**. Instead of asking you to rewrite your transformations, Feast reads your dbt project and automatically generates everything needed to serve those models for AI predictions.
 
 Here's how it works:
 
@@ -48,13 +48,13 @@ Feast reads your `manifest.json` (the compiled output from `dbt compile`) and ex
 
 Then it generates Python code defining Feast entities, data sources, and feature views—all matching your dbt models exactly. Your documentation becomes feature documentation. Your data types become feature types. Your models become production-ready features.
 
-The best part? **You don't change your dbt workflow at all.** Keep building models the way you always have. The integration simply creates a bridge from your dbt project to production ML serving.
+The best part? **You don't change your dbt workflow at all.** Keep building models the way you always have. The integration simply creates a bridge from your dbt project to production AI serving.
 
 ## See It In Action: From dbt Model to Production Features
 
-Let's walk through a real example. Imagine you're a data engineer at a ride-sharing company, and you've already built dbt models to track driver performance. Your analytics team loves these models, and now your ML team wants to use them to predict which drivers are likely to accept rides.
+Let's walk through a real example. Imagine you're a data engineer at a ride-sharing company, and you've already built dbt models to track driver performance. Your analytics team loves these models, and now your AI team wants to use them to predict which drivers are likely to accept rides.
 
-Perfect use case. Let's take your existing dbt models to production ML in just a few steps.
+Perfect use case. Let's take your existing dbt models to production AI in just a few steps.
 
 ### Step 1: Install Feast with dbt Support
 
@@ -181,7 +181,7 @@ feast dbt import target/manifest.json \
     --output feature_repo/driver_features.py
 ```
 
-In seconds, Feast generates a complete Python file with everything needed for production ML serving—all from your existing dbt model:
+In seconds, Feast generates a complete Python file with everything needed for production AI serving—all from your existing dbt model:
 
 {% code title="feature_repo/driver_features.py" %}
 ```python
@@ -249,7 +249,7 @@ feast materialize-incremental $(date +%Y-%m-%d)
 
 ## What Just Happened?
 
-You just went from dbt model to production ML features without rewriting a single line of transformation logic. Your dbt model—with all its carefully crafted SQL, documentation, and testing—is now:
+You just went from dbt model to production AI features without rewriting a single line of transformation logic. Your dbt model—with all its carefully crafted SQL, documentation, and testing—is now:
 
 - **Serving features in milliseconds** for real-time predictions
 - **Maintaining point-in-time correctness** to prevent data leakage during training
@@ -399,10 +399,10 @@ Commit the generated Python files to your repository. This provides:
 
 Data teams using Feast with dbt are seeing real impact:
 
-- **"We stopped rewriting features twice"**: Data engineers build once in dbt, ML teams use directly
-- **50-70% faster ML deployment**: From dbt model to production features in minutes, not weeks
-- **Single source of truth**: When dbt models update, ML features stay in sync
-- **Analytics expertise becomes ML expertise**: Your dbt knowledge directly translates to ML feature engineering
+- **"We stopped rewriting features twice"**: Data engineers build once in dbt, AI teams use directly
+- **50-70% faster AI deployment**: From dbt model to production features in minutes, not weeks
+- **Single source of truth**: When dbt models update, AI features stay in sync
+- **Analytics expertise becomes AI expertise**: Your dbt knowledge directly translates to AI feature engineering
 - **Better collaboration**: No more need to rewrite SQL in Python
 
 ## Current Limitations and Future Roadmap
@@ -427,11 +427,11 @@ If you encounter issues or have questions:
 - **Community**: Join our [Slack community](http://slack.feast.dev/)
 - **Issues**: Report bugs or request features on [GitHub](https://github.com/feast-dev/feast/issues)
 
-## Conclusion: Your dbt Models Deserve Production ML
+## Conclusion: Your dbt Models Deserve Production AI
 
-You've invested time and care into your dbt models. They're clean, documented, tested, and trusted by your organization. They shouldn't have to be rewritten to power machine learning—they should work as-is.
+You've invested time and care into your dbt models. They're clean, documented, tested, and trusted by your organization. They shouldn't have to be rewritten to power AI—they should work as-is.
 
-Feast's dbt integration makes that possible. Your dbt models become production ML features with:
+Feast's dbt integration makes that possible. Your dbt models become production AI features with:
 
 - ✅ No rewriting or duplication
 - ✅ No changes to your dbt workflow
@@ -439,7 +439,7 @@ Feast's dbt integration makes that possible. Your dbt models become production M
 - ✅ Real-time serving for predictions
 - ✅ Point-in-time correctness for training
 
-If you're a dbt user who's been asked to "make those models work for ML," this is your answer.
+If you're a dbt user who's been asked to "make those models work for AI," this is your answer.
 
 Ready to see your dbt models in production? Install Feast and try it out:
 

From e767c61e73d6b37ddcc3b213e208d314a36c7319 Mon Sep 17 00:00:00 2001
From: yassinnouh21 <yassinnouh21@gmail.com>
Date: Sat, 7 Feb 2026 13:05:58 +0100
Subject: [PATCH 7/7] Fix incorrect CLI flags and outdated references in dbt
 blog post

- Use -m/--manifest-path flag instead of positional args (9 instances)
- Replace --tag-filter with correct --tag flag (3 instances)
- Remove non-existent --no-online flag
- Fix CI/CD example: -t feast set timestamp-field, use --tag feast
- Update feast dbt list output to match actual CLI format
- Bump GitHub Actions versions from v2 to v4/v5
- Update Python version from 3.9 to 3.11

Signed-off-by: yassinnouh21 <yassinnouh21@gmail.com>
---
 .../docs/blog/feast-dbt-integration.md        | 48 +++++++++----------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/infra/website/docs/blog/feast-dbt-integration.md b/infra/website/docs/blog/feast-dbt-integration.md
index 044a276d960..0ee2b19798a 100644
--- a/infra/website/docs/blog/feast-dbt-integration.md
+++ b/infra/website/docs/blog/feast-dbt-integration.md
@@ -155,18 +155,17 @@ This creates `target/manifest.json` with all your model metadata—the same arti
 Use the Feast CLI to discover your tagged models:
 
 ```bash
-feast dbt list target/manifest.json --tag-filter feast
+feast dbt list -m target/manifest.json --tag feast
 ```
 
 You'll see output like:
 
 ```
-Found 1 model(s) with tag 'feast':
+Found 1 model(s):
 
-  driver_features
-    Description: Daily aggregated features for drivers including ratings and activity metrics
-    Columns: driver_id, event_timestamp, avg_rating, total_trips, total_earnings, avg_trip_duration, is_active
-    Tags: feast
+driver_features [tags: feast]
+  Table: my_project.my_dataset.driver_features
+  Description: Daily aggregated features for drivers including ratings and activity metrics
 ```
 
 ### Step 6: Import Your dbt Model to Feast
@@ -174,10 +173,10 @@ Found 1 model(s) with tag 'feast':
 Now for the magic—automatically generate production-ready feature definitions from your dbt model:
 
 ```bash
-feast dbt import target/manifest.json \
+feast dbt import -m target/manifest.json \
     --entity-column driver_id \
     --data-source-type bigquery \
-    --tag-filter feast \
+    --tag feast \
     --output feature_repo/driver_features.py
 ```
 
@@ -244,7 +243,7 @@ Now you can use standard Feast commands to materialize these features:
 ```bash
 cd feature_repo
 feast apply
-feast materialize-incremental $(date +%Y-%m-%d)
+feast materialize-incremental $(date -u +%Y-%m-%dT%H:%M:%S)
 ```
 
 ## What Just Happened?
@@ -265,10 +264,10 @@ And here's the best part: when you update your dbt model (maybe you add a new co
 For features involving multiple entities (like user-merchant transactions), specify multiple entity columns:
 
 ```bash
-feast dbt import target/manifest.json \
+feast dbt import -m target/manifest.json \
     -e user_id \
     -e merchant_id \
-    --tag-filter feast \
+    --tag feast \
     -o feature_repo/transaction_features.py
 ```
 
@@ -283,7 +282,7 @@ Feast's dbt integration supports multiple data warehouse backends:
 
 **Snowflake:**
 ```bash
-feast dbt import manifest.json \
+feast dbt import -m manifest.json \
     -e user_id \
     -d snowflake \
     -o features.py
@@ -291,7 +290,7 @@ feast dbt import manifest.json \
 
 **File-based sources (Parquet, etc.):**
 ```bash
-feast dbt import manifest.json \
+feast dbt import -m manifest.json \
     -e user_id \
     -d file \
     -o features.py
@@ -302,13 +301,12 @@ feast dbt import manifest.json \
 You can fine-tune the import with additional options:
 
 ```bash
-feast dbt import target/manifest.json \
+feast dbt import -m target/manifest.json \
     -e driver_id \
     -d bigquery \
     --timestamp-field created_at \
     --ttl-days 7 \
     --exclude-columns internal_id,temp_field \
-    --no-online \
     -o features.py
 ```
 
@@ -347,12 +345,12 @@ jobs:
   update-features:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      
+      - uses: actions/checkout@v4
+
       - name: Setup Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '3.11'
       
       - name: Install dependencies
         run: |
@@ -366,10 +364,10 @@ jobs:
       
       - name: Generate Feast definitions
         run: |
-          feast dbt import dbt_project/target/manifest.json \
+          feast dbt import -m dbt_project/target/manifest.json \
             -e user_id \
             -d bigquery \
-            -t feast \
+            --tag feast \
             -o feature_repo/features.py
       
       - name: Apply to feature store
@@ -383,7 +381,7 @@ jobs:
 Before generating code, preview what will be created:
 
 ```bash
-feast dbt import manifest.json -e driver_id --dry-run
+feast dbt import -m manifest.json -e driver_id --dry-run
 ```
 
 This helps catch issues like missing columns or incorrect types before committing.
@@ -424,7 +422,7 @@ We're actively working on enhancements including:
 If you encounter issues or have questions:
 
 - **Documentation**: Check our [dbt integration guide](https://docs.feast.dev/how-to-guides/dbt-integration)
-- **Community**: Join our [Slack community](http://slack.feast.dev/)
+- **Community**: Join our [Slack community](https://slack.feast.dev/)
 - **Issues**: Report bugs or request features on [GitHub](https://github.com/feast-dev/feast/issues)
 
 ## Conclusion: Your dbt Models Deserve Production AI
@@ -447,12 +445,12 @@ Ready to see your dbt models in production? Install Feast and try it out:
 pip install 'feast[dbt]'
 cd your_dbt_project
 dbt compile
-feast dbt import target/manifest.json -e your_entity_column -d bigquery
+feast dbt import -m target/manifest.json -e your_entity_column -d bigquery
 ```
 
 Your models are already great. Now make them do more.
 
-Join us on [Slack](http://slack.feast.dev/) to share your dbt + Feast success stories, or check out the [full documentation](https://docs.feast.dev/how-to-guides/dbt-integration) to dive deeper.
+Join us on [Slack](https://slack.feast.dev/) to share your dbt + Feast success stories, or check out the [full documentation](https://docs.feast.dev/how-to-guides/dbt-integration) to dive deeper.
 
 ---