Why the Future of Data Is Compiled, Not Queried
When SQL Is Becoming More and More Like Assembly in Today's World
When SQL stopped being a language and became a target
There is a quiet but irreversible shift happening in data engineering.
Nobody announced it. There was no keynote. No actual manifesto. No widely circulated blog post charting the change.
Yet if you look closely at what the in analytics are actually doing, beyond the marketing rhetoric and fancy dashboards, a single pattern emerges:
SQL is no longer being interpreted at runtime. It is getting compiled, not just into intermediate query plans but into fully optimized execution artifacts that anticipate access patterns, dependencies, and business logic.
Compiled into columnar execution plans. Into LLVM IR. Into WASM. Compiled into materializations that live in memory or distributed storage.
Compiled into knowledge graphs that encode relationships and semantics. Compiled into final form, with dependencies resolved and optimization baked in, before it is ever even “queried.”
This is the inversion: the future of data will no longer be a reactive exercise. Something more like “I send a query and the warehouse responds.”
Instead, it will be much more proactive: “I define intent, and the system pre-compiles the optimal state of the world, with every intermediate result, join, and aggregation already prepared for instant consumption.”
AI is accelerating this transition faster than the industry is emotionally prepared for. Copilots are not merely making SQL easier: they are making it nearly invisible, replacing the manual craft of query-writing with intent-based instruction.
What remains for the human is not the orchestration of SELECTs and JOINs but the management of semantic posture: defining meaning, relationships, and correctness before any execution occurs.
And this is why SQL is becoming assembly.
SQL was never the star
We often talk about SQL as if it were a language, a craft, a skill. Yet historically, SQL is really an API layered over a planner: something more like a negotiation with a black box.
Spoiler alert: an analytics engineer never truly “executes SQL.” I know that you alredy knew it, but just wanted to point it out clearly: their job is to describe algebraic intent and hope the optimizer interprets it correctly.
For nearly three decades, this compromise was acceptable: compute was scarce, and latency dictated caution.
But the cloud flipped the economic axis: compute became cheap and disposable, while engineering time became the real constraint.
Warehouses lagged behind philosophically: they continued to treat query execution as the primary goal, rather than the compilation of insight into pre-usable form.
The innovators, however, quietly defected to a new paradigm:
DuckDB and MotherDuck transformed queries into vectorized native pipelines instead of ephemeral plans
ClickHouse fuses storage and execution into a single compiled boundary
Materialize compiles views into a continuously updated intermediate representation, sidestepping SQL text entirely
BigQuery’s BI Engine compiles frequently accessed aggregates directly into memory, bypassing the warehouse at runtime
The winning pattern is no longer “faster SQL.” It is less SQL, more pre-computed structure, pre-shaped for instant consumption. Interpretation is now a liability; compilation, the new moat.
The demotion nobody talks about
We are witnessing what can only be described as a prestige collapse. SQL, once the pinnacle of analytics expertise, is no longer the crown jewel.
Instead, it has been demoted to a leaf node in a far taller stack: the intermediate representation (IR) that links the semantic layer above to the compiled execution layer below.
The semantic layer defines meaning: business concepts, metrics, dimensions, and their relationships. It is the plane where intent is articulated, validated, and made unambiguous.
The compiled layer defines shape: how data is physically structured, stored, and executed for maximum efficiency. Between these two, SQL exists merely as a bridge, more like a machine-readable but human-unfriendly format. It is, in essence, the assembly language of the data world.
It carries no inherent meaning for humans. It is not intended to communicate insight to business stakeholders. Its purpose is to serve as a universal translation medium, converting high-level intent into executable instructions.
And this is why AI copilots matter so profoundly: they take declarative human input (the questions, the business concepts, the analytical intent) and generate SQL behind the scenes. For the human, SQL essentially disappears. For the machine, it becomes the precise, last-mile code that drives execution.
In this new world, humans no longer write SQL by hand. Their role shifts toward approving and verifying SQL, ensuring the machine’s interpretation of semantic intent aligns with business reality.
SQL becomes a verification tool rather than a creative one, a formal artifact that signals correctness rather than a playground for ingenuity.
The human hand is suddently replaced by a guiding mind, shaping meaning at the semantic level while leaving the mechanics of execution to the compiler.
Forces driving industry convergence
The industry is converging along trajectories that were once invisible, guided by forces both inexorable and silent. Three such forces stand out, reshaping the fundamental mechanics of analytics.
Latency Collapse
Hot paths are increasingly moving into memory, into vectorized execution engines, into WASM at the edge. The traditional cloud warehouse, once the pinnacle of data velocity, is already too slow to claim the final mile.
The final mile, a.k.a. that instant, immediate access to the state of truth, demands pre-compilation and locality, not reactive queries.
Topological Awareness
Modern DAGs are evolving beyond mere orchestration diagrams. They do not describe transforms; they encode semantics over time.
Once a DAG represents meaning rather than procedure, it becomes inherently compilable. The edges of the graph become the vessels of intent, the nodes repositories of pre-materialized knowledge.
AI Mediation
Human expression is transitioning from procedural to declarative. Analysts and data professionals articulate intent, not instructions. Optimizers, in response, are shifting from cost-based heuristics to meaning-aware orchestration.
The implication is profound: what begins as a SQL engine becomes a compiler backend; what begins as metadata becomes a semantic IR;
what begins as a dbt model becomes a fully declarative semantic compiler. In this paradigm, the concept of a “query” as an active, immediate transaction is obsolescent.
The Warehouse and the final mile
It is 2025, and the data world feels... smaller. The warehouse, once the undisputed hub of analytical gravity, is no longer the center of the universe.
Consider the platforms that dominate today. S3-compatible object stores with Iceberg or Hudi no longer just store data: they compile it.
Physical layouts are no longer neutral; they are tuned to access patterns, sculpted to answer specific intents before they even arise.
DuckDB and MotherDuck blur the line between local and cloud execution, transforming pipelines into compiled artifacts that run seamlessly wherever the query needs them.
Materialize, along with Kafka-based streaming pipelines, keeps continuous incremental state, ensuring that the data is never stale, never a lagging reflection of reality.
Velox and Substrait serve as the new execution substrates, enabling compiled execution across heterogeneous systems.
And in this world, the warehouse has been demoted. It is no longer an engine, no longer a place of power, because it is a clearance house.
The final mile, the act of transforming raw data into actionable insight, has migrated upstream, closer to the consumer, into execution surfaces that the warehouse cannot match in latency, locality, or immediacy.
Ask yourself: if your warehouse can’t pre-assemble meaning, if it can only react to the query once it is issued, is it still a warehouse, or it is just storage in disguise?
The shift for analytics engineers
The role of the analytics engineer is no longer about crafting the perfect SELECT statement. SQL gymnastics, once a badge of honor, are becoming quaint.
Today, the unit of work is a meaningful state: a pre-computed articulation of business intent that exists before it is ever asked for.
What does this mean in practice? It means reasoning about topology instead of syntax:
which entities should be continuously updated?
Which should be compiled to the edge?
Which can safely remain dormant until triggered by a business event?
Which materializations make the organization more epistemically ready tomorrow?
The analytics engineer becomes a semantic architect. The head of data becomes a compiler strategist. AI becomes the mediator, the layer translating intent into execution, generating code to propagate meaning across the system.
Questions shift from “How do I join these tables?” to “Which truths should I pre-assemble, and where?” SQL remains, but it becomes the assembly language of a deeper, more meaningful computation.
Think about that for a moment: are we training engineers to write queries, or are we training them to try to anticipate the state of the organization?
Who wins in a compiled world
Once SQL is assembly, control moves upward. Power no longer resides in raw compute or storage, because it resides in ownership of semantic layouts, in the graphs of pre-materialized state that define where, when, and how computation happens.
Which parts of the system execute near the consumer? Which parts live in a centralized warehouse? These decisions define speed, locality, and insight.
The cloud warehouses we know (Databricks, Snowflake) are not disappearing. But they are shifting roles.
Databricks is racing toward Unity Catalog semantics. Snowflake is evolving Snowpark-native compiled applications. dbt is moving toward an intermediate representation (IR), treating semantic graphs as the primary object.
The battle is no longer about faster SQL: it is about dominion over intent.
Control of meaning becomes the new axis of power. Who dictates which state exists, where, and for whom? Which truths are verified and ready before a question is ever asked?
The head of data evolves from a logistician to an architect of epistemic infrastructure. The key question is no longer how data is stored or retrieved. It is which truths should exist, where, and for whom. Performance is no longer compute-bound; it is topology-bound.
Do you optimize for faster joins? Or do you optimize for pre-assembled knowledge, waiting at the edge the moment the business needs it?
Winners and losers
The stakes are real. The old guard, which is a series of instruments, comprising dashboard-first BI, SaaS ETL tools that produce tables rather than semantic graphs, query accelerators that optimize syntax but ignore meaning, all faces obsolescence.
A warehouse that cannot embed locality awareness is already a step behind. Winners are those who embrace semantic compilation and continuous materialization:
dbt Mesh, MetricFlow, Malloy—tools that treat the semantic graph as the primary object.
DuckDB, MotherDuck—engines designed to compute where it matters, near the consumer.
Materialize—platforms maintaining state continuously, never asking questions twice.
Velox, Substrait—execution substrates for heterogeneous, compiled execution surfaces.
The common principle is simple: the query is no longer the product. The state is.
End users are starting to stop thinking in terms of queries. Data teams no longer optimize for latency in the traditional sense. They optimize for epistemic readiness: the organization’s ability to know instantly, without interpretation cost, the states that matter.
The architectural endgame is a world where meaning is pre-assembled, verified, and distributed before any human request. The system does not wait to answer a question: it anticipates it.
Ask yourself:
in five years, will your analysts be crafting queries, or will they be verifying that the pre-compiled truths in your semantic system still align with reality?
From SQL Wizards to Semantic Architects
In the interpreted era, apex skills were defined by syntax mastery. SQL wizards ruled. In the compiled era, apex skills are defined by semantic foresight.
The engineer who anticipates the needs of the organization, pre-shapes models and materializations, and orchestrates execution topology will wield real influence.
AI diminishes the need for query literacy but amplifies the need for governance. Engineers no longer teach the system how to join: they teach it what concepts mean. Meaning itself becomes the primitive of performance.
The modern data stack once promised faster answers. The compiled data stack promises pre-answered questions.
Warehouses survive. Queries survive. SQL survives, just as assembly survived in computing. But prestige, power, and influence migrate upward: from syntax to semantics to compiled state.
In the next five years, the defining power in data will not reside in storage or compute. It will reside in ownership of the semantic operating system.
Control of meaning is control of execution.
SQL is assembly.
Semantics is the OS.
Everything else follows.
“From SQL Wizards to Semantic Architects” interesting approach!
Thanks for writing this, it clarifies a lot. This really hits the nail on the head; the shift from reactive querying to proactive, compiled data, especially with AI, feels like such a natural and inevitable evolution. It makes me think about how the human skill set will need to adapt - will future data professionals need a deeper understanding of the underlying compilation logic, perhaps more like a compiler engineer, for effective management, even if the SQL orchestation is gone?