Chalk

Editor’s note: We combine independent analysis, data collection, and hands-on testing to review data and AI tools. This Chalk review weighs pricing transparency, real-world adoption signals, development momentum, openness and exit costs, practitioner sentiment, and our editorial verdict.

Quick verdict: We recommend Chalk for ML teams running fraud, credit, risk or recommendation models that need features computed at request time, defined in plain Python rather than a vendor DSL. There is no public price list or free tier: you pay $0.85 per credit on AWS Marketplace plus your own cloud infrastructure, and every resolver you write is Chalk-specific code.

With Tecton inside Databricks since the acquisition announced in August 2025, Chalk is the main independent real-time feature platform left, computing Python-defined features at query time on a Velox-based engine. Founded in 2022, Chalk raised a $50M Series A at a reported $500M valuation in May 2025, and its customers include Whatnot, MoneyLion and Socure.

In this review, I’ll take a closer look at Chalk’s pricing, feature definitions, serving engine and deployment options, so you can see exactly whether it belongs in your real-time ML stack.

Key Takeaways

• Features are Python classes with resolvers in Python or SQL, and inline expressions compile to vectorized C++
• The same code serves online queries and builds point-in-time training sets
• Chalk runs hosted, in your own AWS, GCP or Azure Kubernetes cluster, or air-gapped
• No public price list or free tier: $0.85 per credit on AWS Marketplace, plus your own infrastructure costs
• The platform is proprietary with no open-source core, so leaving Chalk means rewriting every resolver

Pros and Cons

How Much Does Chalk Cost?

Chalk publishes no plan tiers and has no free tier: you book a demo, and the only public rates are on AWS Marketplace, where a standard credit costs $0.85. Credits cover feature computation, real-time serving and agent sandbox workloads, and idle or zero-scaled infrastructure draws no charge.

• Pay-as-you-go on AWS Marketplace ($0.85 per credit): no end date, cancel any time; suits a one-model proof of concept
• 12-month AWS Marketplace contract ($1,000 platform fee plus $0.85 per credit): overage billed at the same rate; suits teams that already know their monthly credit burn
• Custom contract (quote from sales): book a demo and ask for a custom quote if Marketplace billing does not fit your procurement

Option	Upfront fee	Usage rate	Commitment	Best for
Pay-as-you-go (AWS Marketplace)	None	$0.85 per standard credit	None, cancel any time	Proof of concept on one model
12-month contract (AWS Marketplace)	$1,000 platform fee	$0.85 per credit, overage at the same rate	12 months	Teams with measured credit burn
Custom contract	Quote from sales	Quote from sales	Negotiated	Teams that want terms outside AWS Marketplace

Your AWS, GCP or Azure bill for the Kubernetes cluster, the online store (Redis or DynamoDB, for example) and the offline warehouse comes on top of the credits. Chalk does not publicly state how many credits a query or core-hour burns, so ask for a sizing estimate against your own feature list during the demo.

Feast costs nothing under Apache 2.0 but you run all the compute yourself, Hopsworks starts you on a free serverless tier, and Tecton terms now run through Databricks, so of the four, Chalk AI pricing is the only one metered per credit.

Is Chalk Good Value for Money?

• Good value when it replaces a homegrown feature store: Melio says it grew feature development from a handful of engineers to 20+ across its risk organization after making that switch
• Cheap when quiet: idle or zero-scaled infrastructure draws no credits, so environments that scale down between test runs add little to the credit bill
• Poor value for batch-only teams: if your features already sit in Snowflake or Databricks tables built by dbt jobs, Feast or your warehouse’s own feature store covers that without a credit meter
• Budget risk from the credit meter: with no public credit-to-workload conversion, your first month’s bill is an estimate until you measure it

Author’s Testing Notes

I recommend starting on the AWS Marketplace pay-as-you-go option with a single model’s feature list, because it has no end date and cancels any time. Move to the 12-month contract and its $1,000 platform fee only once you have a month of measured credit burn to put against it. Teams that need the customer-cloud deployment should bring their Kubernetes and data-residency requirements to the first demo.

— Panoply team

My Experience With Chalk

Chalk has no self-serve signup: the ways in are a demo or an AWS Marketplace subscription, which puts it a step behind Hopsworks’ free serverless tier if all you want is a quick trial.

Installing the CLI and Starting a Project

I installed the CLI with one curl command, curl -s -L https://api.chalk.ai/install.sh | sh, then added chalkpy, pydantic and requests to requirements.txt and installed them with pip.

chalk init created two files in my project, chalk.yaml and .chalkignore, and I set the project field in chalk.yaml to my project name. chalk login opened a browser tab to approve the session; a dedicated environment needs the --api-host flag as well.

Defining My First Features

A feature class in Chalk looks like a dataclass with an @features decorator, and every class needs a primary key: a field called id by default, or any field marked Primary[str].

I declared a derived feature inline with the underscore syntax, subtotal: float = _.total - _.sales_tax. That line reads as Python, but Chalk statically analyzes it and runs it as vectorized C++ at both serve and train time.

Versioning is explicit when you want it (feature(version=2)), and Chalk also versions every feature automatically on each deployment.

Writing Resolvers

My SQL resolver was a plain .sql file with three comment headers: -- resolves: User, -- source: postgres and -- type: online. Those headers name the feature class the query fills, the source it reads and whether it runs online.

For logic that calls an external API or runs a model, I wrote a Python function decorated with @online. Online resolvers also run inside offline queries, so one function fed both the live endpoint and the training set.

Expressions work only in feature class definitions, not inside a Python resolver, so derived arithmetic has to live on the class. That split is the one rule I would explain to a new team member before their first deploy.

Deploying to a Branch and Querying

chalk apply --branch test deployed my features to a branch without touching production. From the CLI, chalk query --in user.id=u_F6zY0tE4w8 --out user.credit_score --branch test returned the feature, and in Python ChalkClient().query(input={User.id: "u_F6zY0tE4w8"}, output=[User.credit_score], branch="test") did the same.

Passing explain=True returned the planner’s execution plan, the first place to look when a resolver chain is slower than expected, though it slows the query itself and belongs nowhere near production traffic. High-throughput paths should call Chalk’s bulk query endpoint instead.

Building a Training Set

ChalkClient.offline_query took my entity ids and timestamps and computed every row as of its own timestamp rather than from today’s data, which is the point-in-time correctness that keeps a training set honest. Passing a dataset_name saved a versioned dataset revision, and get_data_as_pandas() (or the polars equivalent) handed back a frame ready for training.

The whole loop, from feature class to training frame, stayed inside Python and the Chalk CLI. With Feast I would have written the Spark or Airflow jobs that compute those values myself, and with Tecton I would have learned its declarative framework before writing a line.

Feature Definitions: Python Classes Instead of a DSL

Every Chalk project is built from three parts, feature classes, resolvers and expressions, and all three are written in the Python or SQL your team already knows.

Feature classes and versioning

A feature class sets default values for missing fields and carries a FeatureTime field that tells the engine which timestamp each value belongs to. The primary key is id by default, or any field marked Primary[str] or feature(primary=True). Chalk versions every feature on each deployment, and feature(version=2) pins an explicit version number on a single feature.

Resolvers and caching

SQL file resolvers cover anything a warehouse or Postgres query can answer, and Python resolvers handle API calls, external lookups and model inference. Offline resolvers run only in offline queries and take priority there, so a training set can read history from your warehouse while the online resolver calls a live API.

A max_staleness setting of “15m”, “1h”, “30d” or “infinity” returns a cached value when one is fresh enough, so an expensive enrichment call set to “1h” runs once an hour instead of once per request.

Expressions, the inline _ definitions from the walkthrough, are statically analyzed and executed as vectorized C++, so derived arithmetic belongs there rather than in a Python resolver.

Tecton asks you to learn its own declarative framework before you write a feature; Feast only registers features you computed elsewhere; Databricks ties each feature table to Delta and Unity Catalog. In our testing, the only new syntax a Python engineer meets in the Chalk feature store is the decorators, the _ expressions and the SQL comment headers.

The price of that convenience is lock-in: every resolver is Chalk-specific code, so a future move to Feast or Databricks means rewriting the lot rather than re-pointing it.

Real-Time Serving and Point-in-Time Training Data

Chalk’s query planner reads the dependency graph between your features, builds an execution plan, and runs it on a fork of Velox tuned for low-latency inference, with automatic parallelism and vectorization. Resolver code is transpiled through what Chalk calls a symbolic Python interpreter rather than run as plain Python.

Online stores on offer are Redis or Valkey, Memcached, DynamoDB, ElastiCache, Memorystore, Azure Cache for Redis and Cosmos DB. Offline stores are Snowflake, Delta Lake, BigQuery, Iceberg and Athena, and streaming sources include Kafka-compatible brokers such as Confluent and Redpanda, plus Kinesis, Pub/Sub and Event Hubs.

Chalk’s own figure for the entire online pipeline is under 5 ms. Whatnot reports 300M+ features per second at a P99 under 100 ms with over 99.99% uptime, Turo reports a P99 under 50 ms, and Apartment List cites sub-5 ms queries. Those are Chalk’s and its customers’ numbers, not ours; your latency depends on how much work each resolver does and how often max_staleness serves a cache hit.

Whatnot, by its own account, replaced an overnight batch pipeline making 10B+ predictions a night, cut cold start for new sellers from about 24 hours to under 1 hour, and lifted real-time personalization reach from about 90% of users to 99.9%. Its senior data engineer Jacob Burkett credits Chalk with “a single abstraction for online and offline features.”

The Winter 2026 update added metaplanning and autosharding for large offline queries, plus dashboard webhooks to Slack, PagerDuty or a custom endpoint when a scheduled query or deployment fails.

The engine’s strongest fit is a feature that only exists at request time, like a card’s transaction velocity in the seconds before a purchase or a seller’s live inventory on a marketplace feed. For nightly batch features a warehouse job can precompute, this real-time feature store is less differentiated, and Feast or your cloud’s native feature store will do.

Deployment, Integrations and LLM Tooling

Chalk runs in one of three models, and the one you pick decides who operates the Kubernetes cluster:

• Chalk-hosted: both the metadata plane and the data plane live in Chalk’s cloud, so you operate no cluster
• Customer Cloud: your data plane runs on EKS, GKE or AKS in your own account while Chalk runs the metadata plane; this is the most common setup
• Air-gapped: you host both planes yourself, for networks where nothing may leave your environment

Teams, Projects and Environments map onto Kubernetes namespaces. Data sources cover Snowflake, Databricks, PostgreSQL, MySQL, ClickHouse, Trino, DuckDB, Redshift, Athena, DynamoDB, BigQuery, Spanner and Azure SQL, with Iceberg supported natively, and model functions run scikit-learn, XGBoost and ONNX models inside a query.

The LLM toolchain sits in the same query layer:

• Completions: F.openai_complete calls a chat model inside a query, with structured output typed through Pydantic and Jinja prompts that inject live feature values
• Embeddings and search: embed() produces embeddings through OpenAI, Vertex AI or Bedrock, and nearest-neighbor search runs with l2, inner-product or cosine distance
• Prompts: named prompts are managed from the dashboard, run with P.run_prompt, and evaluated against historical datasets
• Model gateway: an OpenAI-compatible gateway fronts OpenAI, Anthropic, Bedrock, Azure OpenAI, Vertex and any OpenAI-compatible endpoint such as Groq or Ollama Cloud

Chalk now pitches the whole thing as “the platform for production AI” in three pillars, Context (feature store and 5 ms serving), Runtime (model serving, GPUs, sandboxes, model gateway) and Learning (evals, traces, notebooks, fine-tuning), a broader claim than the feature-store category it started in.

The customer-cloud model is the reason to pick Chalk over a hosted-only rival if your transaction data cannot leave your account; the cost is that your platform team operates a Kubernetes cluster that a Chalk-hosted or SageMaker setup would run for you.

How Does Chalk Compare to Competitors?

Chalk’s niche is request-time Python features that run outside any single cloud vendor’s platform. If that is not your situation, one of these Chalk alternatives wins a different niche:

• Tecton was built by the Uber Michelangelo team, last valued at $900M in 2022, and handles batch, streaming and request-time features with native monitoring. Databricks announced its acquisition in August 2025 to feed its Agent Bricks product, so it wins for teams already committed to the lakehouse; for everyone else weighing Chalk vs Tecton, Chalk publishes a Tecton migration guide
• Databricks Feature Engineering in Unity Catalog stores features as Delta tables with Unity Catalog lineage, and it wins for Databricks-only shops that already track models in MLflow; serving outside Databricks compute adds latency, and streaming features couple to Structured Streaming
• Feast is Apache 2.0, free, and incubated under Linux Foundation AI & Data after Gojek and Google Cloud built it in 2018, with Redis, DynamoDB, BigQuery and Snowflake backends, so it wins on cost and lock-in; it does not compute features, so you run the Spark, Flink or Airflow jobs yourself and real-time serving is its weak spot
• Hopsworks treats batch and streaming as first-class, ships an integrated model registry, and starts you on a forever-free serverless tier, so it wins for teams that want a free start and a self-hostable option; self-hosting needs Kubernetes skills and its community is smaller than Feast’s
• Redis Feature Form is Featureform after Redis announced the acquisition in October 2025 and relaunched it as an enterprise feature store in April 2026: a virtual feature store on Apache Iceberg with Snowflake, ClickHouse and Spark integrations; it wins for Redis-centric stacks
• Amazon SageMaker Feature Store and Vertex AI Feature Store win for single-cloud teams: SageMaker keeps its offline store in S3, Vertex sits on BigQuery with built-in monitoring, and both store rather than compute features, so engineering still happens upstream

Fennel, a feature engineering startup founded in 2023, also went to Databricks in 2025, which leaves Chalk as the main real-time feature platform not owned by a lakehouse or database vendor, with Hopsworks as the self-hostable alternative.

How We Test

We install, configure and run each tool ourselves on a realistic workload before writing a word, then weigh six areas: pricing transparency, real-world adoption signals, development momentum, openness and exit costs, practitioner sentiment, and our editorial verdict.

For Chalk, we worked through the CLI install, feature classes, SQL and Python resolvers, branch deploys, online queries and offline training-set queries, and compared the result against Tecton, Feast, Hopsworks and the cloud-native stores. On exit costs, we checked which parts of a Chalk project (feature classes, resolvers, SQL headers) would need rewriting to move to Feast or Databricks.

Public practitioner discussion of Chalk is still thin next to Feast or Tecton, so this verdict leans more on our own testing than on sentiment. Sponsors and affiliate partners cannot change a verdict, areas that do not apply to a tool are left out rather than scored zero, adoption signals refresh monthly, and the editorial review is repeated quarterly.

Prices current as of October 2026.

Chalk Review: Should You Build Your Real-Time Features on Chalk?

Buy Chalk if you run fraud, credit, risk or recommendation models whose best features only exist at request time, your ML engineers write Python, and you want those features served from your own AWS, GCP or Azure account rather than from one vendor’s lakehouse. Teams leaving Tecton who do not want to follow it into Databricks are the clearest fit, and Chalk publishes a Tecton migration guide for that move. Teams outgrowing a homegrown feature store belong on the list too, as Melio’s switch shows.

Skip it if your features are batch-only and already sit in warehouse tables, where Feast or Databricks Feature Engineering does the job without a credit meter. Skip it too if you are a small team that needs a free start, where Hopsworks’ serverless tier is the quicker way in, or if nobody on your team wants to own a Kubernetes cluster and the Chalk-hosted model does not clear your data-residency rules.

Book the demo with one model’s feature list in hand and ask for a credit-burn estimate against it, or start on the AWS Marketplace pay-as-you-go option at $0.85 per credit and measure the burn yourself before signing the 12-month contract. Visit chalk.ai to book the demo.

FAQ

Is Chalk free?

No. Chalk has no free tier and no self-serve trial; the only public rate is $0.85 per standard credit on AWS Marketplace, pay-as-you-go with no end date or on a 12-month contract with a $1,000 platform fee. Your own cloud infrastructure costs come on top, and Hopsworks is the rival with a free serverless tier.

Is Chalk open source?

No. The platform is proprietary commercial software; the public component is the chalkpy client on PyPI, which needs a Chalk environment to query. Feast is the open-source alternative under Apache 2.0, and it serves features you compute elsewhere rather than computing them for you.

Is Chalk a feature store?

Chalk is a feature store plus a compute engine. A conventional feature store serves precomputed values fed by ETL jobs; Chalk runs your resolvers at query time on a Velox-based engine and caches results per feature with max_staleness. It also handles LLM context: embeddings, vector search, named prompts and a model gateway sit alongside the feature definitions.

Where does Chalk run?

In one of three models: Chalk-hosted, where Chalk runs both the metadata and data planes; Customer Cloud, where your data plane runs on EKS, GKE or AKS in your own account while Chalk runs the metadata plane, which is the most common setup; or air-gapped, where you host both. See Deployment, Integrations and LLM Tooling above for the full breakdown.

How does Chalk compare to Tecton?

Both compute batch, streaming and request-time features for online serving. Tecton uses its own declarative framework and has belonged to Databricks since the acquisition announced in August 2025; Chalk defines features as Python classes with Python or SQL resolvers and remains independent. Chalk publishes a Tecton migration guide for teams that do not want to follow Tecton into Databricks.

Who uses Chalk?

Named customers include Whatnot, MoneyLion, Socure, Turo, Melio, Apartment List, Sunrun, Grindr, Mission Lane, Medely, Iwoca and Pipe. Whatnot runs feed ranking and show discovery on it; Melio replaced a homegrown feature store; Grindr uses Chalk Compute as the engine for agents running in its own environment.