MinervaDB: Full-Stack Data Infrastructure Engineering, Analytics, and Operations for Modern Retail with Snowflake and Databricks

Introduction: The Modern Retail Data Challenge

Retail data infrastructure for modern retail organizations is at a critical inflection point. Modern retail enterprises are facing an unprecedented convergence of data complexity, consumer expectation, and competitive pressure. From real-time inventory visibility and personalized customer experiences to supply chain optimization and fraud detection, retailers must now operate as data-first enterprises. The era of siloed transactional databases and batch-driven reporting is over. Today's retail leaders demand always-on, cloud-native data platforms capable of powering analytics, machine learning, and operational intelligence at enterprise scale. This whitepaper examines how MinervaDB delivers full-stack Data Infrastructure Engineering, Analytics, and Operations for modern retail organizations by leveraging two of the most powerful cloud-native data platforms available today — Snowflake and Databricks. Whether you are modernizing a legacy on-premises data warehouse, building a real-time data lakehouse, or operationalizing machine learning models for demand forecasting, MinervaDB provides the deep technical expertise, proven methodologies, and managed services to accelerate your journey.

The MinervaDB Advantage: Full-Stack Data Infrastructure Engineering

MinervaDB is a purpose-built Data Infrastructure Engineering and Operations company with deep expertise across the full data stack — from ingestion and storage to transformation, analytics, and ML operations. Unlike generalist system integrators, MinervaDB specializes exclusively in data infrastructure, which means our engineers bring production-grade depth across data architecture design, platform engineering, performance optimization, reliability engineering, and FinOps for cloud data platforms. For retail clients, this specialization translates directly into faster time-to-insight, lower total cost of ownership, and data infrastructure that scales seamlessly with business growth. Our retail data infrastructure engagements are structured around three core pillars:

• Data Infrastructure Engineering: Architecture design, platform deployment, pipeline development, and data modeling for Snowflake and Databricks environments.
• Analytics and Business Intelligence: Semantic layer design, KPI frameworks, self-service BI enablement, and advanced analytics including predictive and prescriptive models.
• Data Operations (DataOps): Continuous monitoring, SLA management, cost governance, security operations, and reliability engineering for production data platforms.

Snowflake for Modern Retail: The Cloud Data Warehouse of Choice

Snowflake's cloud-native architecture makes it an ideal platform for retail data warehousing, analytics, and data sharing use cases. Its separation of compute and storage, multi-cluster virtual warehouse architecture, and zero-copy cloning capabilities give retail organizations the performance and flexibility they need to serve diverse analytical workloads without compromising cost efficiency.

Retail Data Architecture on Snowflake

MinervaDB designs and implements retail data infrastructure on Snowflake environments using a layered medallion architecture — Raw (Bronze), Cleansed (Silver), and Curated (Gold) — that ensures data quality, lineage, and accessibility at every stage of the pipeline. Below is a representative Snowflake schema design for a retail data warehouse:

-- Snowflake Retail Data Warehouse: Core Schema Design
-- MinervaDB Cloud-Native Data Architecture

-- Bronze Layer: Raw ingestion from transactional systems
CREATE OR REPLACE SCHEMA retail_bronze
DATA_RETENTION_TIME_IN_DAYS = 7
COMMENT = 'Raw ingestion layer - immutable source records';

CREATE OR REPLACE TABLE retail_bronze.pos_transactions_raw (
transaction_id VARCHAR(64) NOT NULL,
store_id VARCHAR(16) NOT NULL,
terminal_id VARCHAR(16),
transaction_ts TIMESTAMP_NTZ NOT NULL,
customer_id VARCHAR(64),
basket_id VARCHAR(64),
payload_json VARIANT,
ingest_ts TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP(),
source_system VARCHAR(32),
_batch_id VARCHAR(64)
);

-- Silver Layer: Cleansed and validated transactions
CREATE OR REPLACE SCHEMA retail_silver;

CREATE OR REPLACE TABLE retail_silver.pos_transactions (
transaction_id VARCHAR(64) NOT NULL,
store_id VARCHAR(16) NOT NULL,
transaction_ts TIMESTAMP_NTZ NOT NULL,
customer_id VARCHAR(64),
total_amount NUMBER(12,2),
discount_amount NUMBER(12,2),
tax_amount NUMBER(12,2),
net_amount NUMBER(12,2),
payment_method VARCHAR(32),
num_items INTEGER,
is_return BOOLEAN DEFAULT FALSE,
data_quality_score DECIMAL(5,2),
processed_ts TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
) CLUSTER BY (TO_DATE(transaction_ts), store_id);

-- Gold Layer: Retail KPI-ready aggregates
CREATE OR REPLACE SCHEMA retail_gold;

CREATE OR REPLACE TABLE retail_gold.daily_store_sales (
sales_date DATE NOT NULL,
store_id VARCHAR(16) NOT NULL,
total_transactions INTEGER,
gross_revenue NUMBER(15,2),
net_revenue NUMBER(15,2),
avg_basket_size NUMBER(10,2),
units_sold INTEGER,
return_rate DECIMAL(5,4),
new_customer_rate DECIMAL(5,4),
PRIMARY KEY (sales_date, store_id)
);

MinervaDB engineers implement Dynamic Data Masking, Row-Level Security, and Column-Level Security in Snowflake to ensure compliance with PCI-DSS, GDPR, and CCPA regulations — critical requirements for any retailer handling payment card data and customer PII.

Real-Time Inventory Management with Snowflake Streams and Tasks

One of the most impactful use cases MinervaDB has delivered for retail clients is near real-time inventory visibility using Snowflake's native change data capture capabilities — Streams and Tasks. By combining CDC from operational databases with Snowflake's serverless tasks, retailers can maintain inventory accuracy within minutes rather than hours:

-- Snowflake Stream on inventory updates
CREATE OR REPLACE STREAM retail_silver.inventory_changes_stream
ON TABLE retail_silver.inventory_positions
SHOW_INITIAL_ROWS = FALSE;

-- Scheduled Task: Materialize inventory deltas every 5 minutes
CREATE OR REPLACE TASK retail_gold.refresh_inventory_positions_task
WAREHOUSE = COMPUTE_WH_SMALL
SCHEDULE = '5 MINUTE'
COMMENT = 'MinervaDB DataOps: Near-real-time inventory refresh'
WHEN
SYSTEM$STREAM_HAS_DATA('retail_silver.inventory_changes_stream')
AS
MERGE INTO retail_gold.current_inventory_positions tgt
USING (
SELECT
sku_id,
store_id,
dc_id,
SUM(CASE WHEN METADATA$ACTION = 'INSERT' THEN quantity_delta
WHEN METADATA$ACTION = 'DELETE' THEN -quantity_delta
ELSE 0 END) AS net_quantity_change,
MAX(METADATA$ROW_ID) AS latest_row_id
FROM retail_silver.inventory_changes_stream
GROUP BY sku_id, store_id, dc_id
) src ON (tgt.sku_id = src.sku_id AND tgt.store_id = src.store_id)
WHEN MATCHED THEN
UPDATE SET
tgt.on_hand_qty = tgt.on_hand_qty + src.net_quantity_change,
tgt.last_updated_ts = CURRENT_TIMESTAMP()
WHEN NOT MATCHED THEN
INSERT (sku_id, store_id, on_hand_qty, last_updated_ts)
VALUES (src.sku_id, src.store_id, src.net_quantity_change, CURRENT_TIMESTAMP());

ALTER TASK retail_gold.refresh_inventory_positions_task RESUME;

Databricks for Modern Retail: The Unified Analytics and AI Platform

While Snowflake excels at structured analytics and data warehousing, Databricks unlocks the full power of the Data Lakehouse architecture — combining the reliability and performance of a data warehouse with the flexibility and scale of a data lake. For retail organizations, Databricks is the platform of choice for large-scale data engineering, machine learning model training, real-time streaming analytics, and Generative AI applications.

Retail Data Lakehouse Architecture on Databricks with Delta Lake

MinervaDB designs Databricks environments on the Delta Lake open table format, enabling ACID transactions, schema enforcement, time travel, and unified batch/streaming pipelines. Our retail reference architecture separates the data lakehouse into compute clusters optimized for specific workloads — ingestion, transformation, ML training, and serving:

# MinervaDB Retail Data Lakehouse: Databricks Delta Lake Pipeline
# Unified batch + streaming ingestion for retail events

from pyspark.sql import SparkSession
from pyspark.sql.functions import (
col, from_json, current_timestamp, to_date
)
from pyspark.sql.types import (
StructType, StructField, StringType,
TimestampType, DoubleType, IntegerType
)

spark = SparkSession.builder .appName("MinervaDB_Retail_Lakehouse_Pipeline") .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension") .getOrCreate()

# Define schema for retail transaction events
transaction_schema = StructType([
StructField("transaction_id", StringType(), False),
StructField("store_id", StringType(), False),
StructField("customer_id", StringType(), True),
StructField("sku_id", StringType(), False),
StructField("quantity", IntegerType(), False),
StructField("unit_price", DoubleType(), False),
StructField("transaction_ts", TimestampType(), False),
StructField("channel", StringType(), True),
StructField("payment_method", StringType(), True)
])

# Stream from Kafka topic into Delta Bronze table
bronze_stream = (
spark.readStream
.format("kafka")
.option("kafka.bootstrap.servers", "kafka-broker:9092")
.option("subscribe", "retail.pos.transactions")
.option("startingOffsets", "latest")
.option("maxOffsetsPerTrigger", 50000)
.load()
.select(from_json(col("value").cast("string"), transaction_schema).alias("data"))
.select("data.*")
.withColumn("ingest_ts", current_timestamp())
.withColumn("partition_date", to_date(col("transaction_ts")))
)

# Write to Delta Bronze with Auto Optimize
(bronze_stream.writeStream
.format("delta")
.outputMode("append")
.option("checkpointLocation", "/mnt/retail-lakehouse/checkpoints/bronze/transactions")
.option("mergeSchema", "true")
.partitionBy("partition_date", "store_id")
.trigger(processingTime="30 seconds")
.toTable("retail_bronze.transactions")
)

print("MinervaDB: Bronze streaming pipeline initiated successfully.")

Demand Forecasting with Databricks AutoML and MLflow

One of the highest-value ML use cases MinervaDB has implemented for retail clients is SKU-level demand forecasting at scale. Using Databricks AutoML for rapid model iteration and MLflow for experiment tracking and model registry, MinervaDB delivers production-grade forecasting pipelines that drive better replenishment decisions, reduce stockouts, and minimize excess inventory carrying costs:

# MinervaDB Retail: Distributed Demand Forecasting with Databricks and MLflow
# SKU-level Prophet forecasting using Pandas UDF for horizontal scaling

import mlflow
import mlflow.sklearn
import pandas as pd
import numpy as np
from prophet import Prophet
from pyspark.sql.functions import pandas_udf, PandasUDFType
from pyspark.sql.types import StructType, StructField, StringType, DoubleType, DateType

mlflow.set_experiment("/MinervaDB/Retail/DemandForecasting")

forecast_schema = StructType([
StructField("sku_id", StringType(), False),
StructField("store_id", StringType(), False),
StructField("forecast_date", DateType(), False),
StructField("yhat", DoubleType(), True),
StructField("yhat_lower", DoubleType(), True),
StructField("yhat_upper", DoubleType(), True)
])

@pandas_udf(forecast_schema, PandasUDFType.GROUPED_MAP)
def forecast_sku_demand(pdf: pd.DataFrame) -> pd.DataFrame:
sku_id = pdf["sku_id"].iloc[0]
store_id = pdf["store_id"].iloc[0]

df_prophet = pdf.rename(columns={"sales_date": "ds", "units_sold": "y"})[["ds", "y"]]
df_prophet["ds"] = pd.to_datetime(df_prophet["ds"])
df_prophet = df_prophet.sort_values("ds").dropna()

if len(df_prophet) < 30: return pd.DataFrame(columns=forecast_schema.fieldNames()) with mlflow.start_run(run_name=f"sku_{sku_id}_store_{store_id}", nested=True): model = Prophet( seasonality_mode = "multiplicative", yearly_seasonality = True, weekly_seasonality = True, daily_seasonality = False, changepoint_prior_scale = 0.05 ) model.add_country_holidays(country_name="US") model.fit(df_prophet) future_df = model.make_future_dataframe(periods=30, freq="D") forecast = model.predict(future_df) mlflow.log_params({"sku_id": sku_id, "store_id": store_id, "periods": 30}) mlflow.log_metric("mape", np.mean( np.abs((df_prophet["y"] - forecast["yhat"][:len(df_prophet)]) / df_prophet["y"]) )) result = forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail(30) result["sku_id"] = sku_id result["store_id"] = store_id result = result.rename(columns={"ds": "forecast_date"}) return result[["sku_id", "store_id", "forecast_date", "yhat", "yhat_lower", "yhat_upper"]] sales_history_df = spark.table("retail_gold.weekly_sku_store_sales") .filter(col("sales_date") >= "2023-01-01")

forecasts_df = sales_history_df.groupby("sku_id", "store_id").apply(forecast_sku_demand)

(forecasts_df.write
.format("delta")
.mode("overwrite")
.option("overwriteSchema", "true")
.saveAsTable("retail_gold.demand_forecasts_30d")
)

print("MinervaDB: Demand forecasting pipeline completed successfully.")

Snowflake and Databricks: Complementary Platforms in the Retail Data Stack

A common question from retail data leaders is whether to standardize on Snowflake or Databricks. MinervaDB's perspective — informed by dozens of enterprise retail implementations — is that the most powerful retail data infrastructure architectures leverage both platforms in a complementary, best-of-breed architecture. Databricks handles large-scale data ingestion, transformation, ML model training, feature engineering, streaming analytics, and unstructured data processing. Snowflake serves as the enterprise analytics warehouse — the authoritative source of truth for business metrics, BI reporting, financial analytics, and cross-functional data sharing. Delta Sharing and Snowflake's native Apache Iceberg support enable seamless, zero-copy data movement between the two platforms, eliminating expensive and brittle ETL pipelines.

Databricks-to-Snowflake Production Data Pipeline

MinervaDB implements automated, low-latency data pipelines that move curated Delta Lake tables from Databricks into Snowflake for downstream BI consumption:

# MinervaDB: Databricks-to-Snowflake Production Data Pipeline
# Automated sync of Delta Gold tables to Snowflake Data Warehouse

from pyspark.sql import SparkSession
from datetime import datetime
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("MinervaDB.DataPipeline")

spark = SparkSession.builder.getOrCreate()

snowflake_options = {
"sfURL": dbutils.secrets.get(scope="minervadb-prod", key="sf_account_url"),
"sfUser": dbutils.secrets.get(scope="minervadb-prod", key="sf_user"),
"sfPassword": dbutils.secrets.get(scope="minervadb-prod", key="sf_password"),
"sfDatabase": "RETAIL_DW",
"sfSchema": "RETAIL_GOLD",
"sfWarehouse": "LOAD_WH_MEDIUM",
"sfRole": "SYSADMIN"
}

TABLES_TO_SYNC = [
("retail_gold.demand_forecasts_30d", "DEMAND_FORECASTS_30D"),
("retail_gold.customer_lifetime_value", "CUSTOMER_LTV_SCORES"),
("retail_gold.churn_propensity_scores", "CHURN_SCORES"),
("retail_gold.price_elasticity_index", "PRICE_ELASTICITY"),
]

def sync_delta_to_snowflake(delta_table: str, sf_table: str) -> dict:
start_ts = datetime.utcnow()
logger.info(f"Starting sync: {delta_table} -> Snowflake:{sf_table}")
df = spark.table(delta_table)
row_count = df.count()
(df.write
.format("net.snowflake.spark.snowflake")
.options(**snowflake_options)
.option("dbtable", sf_table)
.mode("overwrite")
.save())
duration_s = (datetime.utcnow() - start_ts).total_seconds()
logger.info(f"Completed: {sf_table} | Rows: {row_count:,} | Duration: {duration_s:.1f}s")
return {"table": sf_table, "rows": row_count, "duration_seconds": duration_s, "status": "SUCCESS"}

sync_results = [sync_delta_to_snowflake(src, tgt) for src, tgt in TABLES_TO_SYNC]
for result in sync_results:
logger.info(f"SYNC SUMMARY | {result['table']} | {result['rows']:,} rows | {result['status']}")

MinervaDB Retail Use Cases: Proven Impact Across the Value Chain

MinervaDB has delivered measurable business outcomes for retail organizations across a wide range of retail data infrastructure and analytics use cases. Below is a representative cross-section of the engagements we support for modern retail data infrastructure engineering and cloud-native analytics.

1. Unified Customer 360 Platform on Snowflake

Retail organizations typically have customer data fragmented across POS systems, e-commerce platforms, loyalty programs, email marketing, mobile apps, and customer service tools. MinervaDB builds Customer 360 data products on Snowflake that unify these identities through deterministic and probabilistic matching, enabling personalized marketing, targeted promotions, and lifetime value optimization.

-- MinervaDB Customer 360: Identity Resolution and LTV Scoring
-- Snowflake Gold Layer: Unified customer profile with RFM segmentation

CREATE OR REPLACE VIEW retail_gold.customer_360_profile AS
WITH identity_resolved AS (
SELECT
master_customer_id,
ANY_VALUE(email_address) AS email,
ANY_VALUE(phone_normalized) AS phone,
ANY_VALUE(loyalty_member_id) AS loyalty_id,
ARRAY_AGG(DISTINCT source_system) AS source_systems,
MIN(first_seen_ts) AS customer_since
FROM retail_silver.customer_identity_graph
GROUP BY master_customer_id
),
purchase_history AS (
SELECT
customer_id AS master_customer_id,
COUNT(DISTINCT transaction_id) AS total_transactions,
SUM(net_amount) AS total_spend,
AVG(net_amount) AS avg_order_value,
MAX(transaction_ts) AS last_purchase_ts,
DATEDIFF('day', MAX(transaction_ts), CURRENT_DATE()) AS days_since_last_purchase,
COUNT(DISTINCT store_id) AS stores_visited
FROM retail_silver.pos_transactions
GROUP BY customer_id
)
SELECT
ir.master_customer_id,
ir.email,
ir.loyalty_id,
ir.customer_since,
ph.total_transactions,
ph.total_spend,
ph.avg_order_value,
ph.last_purchase_ts,
ph.days_since_last_purchase,
CASE
WHEN ph.days_since_last_purchase <= 30 AND ph.total_transactions >= 10 THEN 'Champions'
WHEN ph.days_since_last_purchase <= 60 AND ph.total_transactions >= 5 THEN 'Loyal'
WHEN ph.days_since_last_purchase <= 90 THEN 'At-Risk'
WHEN ph.days_since_last_purchase <= 180 THEN 'Lapsed'
ELSE 'Churned'
END AS rfm_segment,
ltv.predicted_ltv_12m,
ltv.churn_probability_90d,
CURRENT_TIMESTAMP() AS profile_updated_ts
FROM identity_resolved ir
LEFT JOIN purchase_history ph ON ir.master_customer_id = ph.master_customer_id
LEFT JOIN retail_gold.ltv_scores ltv ON ir.master_customer_id = ltv.customer_id;

2. Real-Time Fraud Detection and Loss Prevention

Retail fraud — including return fraud, gift card fraud, employee theft, and payment fraud — costs the industry hundreds of billions of dollars annually. MinervaDB implements real-time fraud scoring pipelines on Databricks that process POS transaction streams, apply ensemble ML models, and surface anomalies to loss prevention teams within seconds of occurrence. Our implementations have reduced fraud loss rates by 18-32% for retail clients within the first six months of deployment.

3. Supply Chain and Replenishment Intelligence

By integrating ERP data, supplier lead times, historical sales velocity, and promotional calendars in a unified Databricks Delta Lakehouse, MinervaDB enables retailers to move from reactive replenishment to predictive, event-driven replenishment. Our implementations have reduced out-of-stock events by 25-40% and improved inventory turnover ratios by 15-20% for mid-market and enterprise retailers.

MinervaDB DataOps: Snowflake Cost Governance and Reliability Engineering

Deploying a cloud-native retail data infrastructure platform is only half the battle. Sustaining it in production — at scale, with high reliability, optimal cost, and robust data governance — requires a disciplined DataOps practice. MinervaDB's Managed DataOps service provides retail clients with 24/7 monitoring, automated incident response, cost governance dashboards, and continuous optimization of their Snowflake and Databricks environments.

-- MinervaDB DataOps: Snowflake Cost Governance Framework
-- Resource monitors to prevent runaway query costs in production

CREATE OR REPLACE RESOURCE MONITOR retail_analytics_monthly
WITH CREDIT_QUOTA = 500
FREQUENCY = MONTHLY
START_TIMESTAMP = IMMEDIATELY
TRIGGERS
ON 75 PERCENT DO NOTIFY
ON 90 PERCENT DO NOTIFY
ON 100 PERCENT DO SUSPEND;

ALTER WAREHOUSE ANALYTICS_WH_MEDIUM
SET RESOURCE_MONITOR = retail_analytics_monthly;

-- MinervaDB Cost Anomaly Detection: Flag statistical cost outliers
SELECT
DATE_TRUNC('day', start_time) AS usage_date,
warehouse_name,
SUM(credits_used) AS daily_credits,
AVG(SUM(credits_used)) OVER (
PARTITION BY warehouse_name
ORDER BY DATE_TRUNC('day', start_time)
ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
) AS rolling_7d_avg_credits,
ROUND(
(SUM(credits_used) - AVG(SUM(credits_used)) OVER (
PARTITION BY warehouse_name
ORDER BY DATE_TRUNC('day', start_time)
ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
)) / NULLIF(STDDEV(SUM(credits_used)) OVER (
PARTITION BY warehouse_name
ORDER BY DATE_TRUNC('day', start_time)
ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
), 0), 2
) AS cost_z_score
FROM snowflake.account_usage.warehouse_metering_history
WHERE start_time >= DATEADD('month', -3, CURRENT_TIMESTAMP())
GROUP BY 1, 2
HAVING ABS(cost_z_score) > 2.0
ORDER BY usage_date DESC, daily_credits DESC;

Why Choose MinervaDB for Your Retail Data Transformation?

Retail organizations choosing a retail data infrastructure partner need more than a vendor — they need a trusted technical advisor with production experience, platform depth, and a track record of delivering outcomes. MinervaDB brings platform-deep expertise with engineers holding Snowflake SnowPro Core/Advanced and Databricks Certified Associate/Professional certifications, and hands-on experience building production data lakehouses at petabyte scale. We understand the unique data challenges of retail — omnichannel data unification, seasonal demand spikes, supply chain complexity, loyalty analytics, and loss prevention — and have built proven solution accelerators for each use case. Our FinOps-driven delivery model has consistently yielded 20-35% cloud data platform cost reductions for clients coming from unoptimized Snowflake and Databricks environments.

MinervaDB Retail Data Modernization Engagement Models

MinervaDB offers flexible retail data infrastructure engagement models designed to meet retail organizations at whatever stage of their data modernization journey they are in. Our Data Infrastructure Assessment (2-4 weeks) provides a comprehensive evaluation of your current data architecture, identifying gaps, risks, and high-priority modernization opportunities. Our Platform Engineering Sprint (8-16 weeks) delivers your core data lakehouse or cloud data warehouse infrastructure, including ingestion pipelines, data modeling, and initial analytics workloads on Snowflake and Databricks. Our Managed DataOps Service provides 24/7 managed operations including performance monitoring, cost governance, security operations, and continuous optimization.

Conclusion: Building a Data-Driven Retail Enterprise with MinervaDB

The retailers who will define the next decade are those who treat retail data infrastructure not as a cost center but as a core strategic capability. The convergence of cloud-native platforms like Snowflake and Databricks, open table formats like Delta Lake and Apache Iceberg, and advanced ML and AI capabilities has created a once-in-a-generation opportunity for retailers to build data platforms that generate durable competitive advantage. MinervaDB exists to help retail organizations build optimal retail data infrastructure and seize that opportunity — faster, more reliably, and at lower cost than they could achieve alone. With deep expertise in full-stack data infrastructure engineering, analytics, and operations, MinervaDB is the ideal partner to help you architect, build, and operate a modern retail data platform powered by Snowflake and Databricks. Ready to transform your retail data infrastructure? Contact MinervaDB today to schedule a complimentary Retail Data Infrastructure Assessment and learn how we can accelerate your path to becoming a truly data-driven retail enterprise with cloud-native data platforms Snowflake and Databricks.