Warehouse vs lakehouse vs Postgres: how to pick
Most companies buy a data platform one tier larger than their data. Here is the test for whether Postgres is still enough for yours.
12 min readBy Team Stallwart
On this page
The short answer
Most companies choosing a data platform for the first time are choosing one tier larger than their data requires. Postgres, which many of them already run, handles analytical reporting for a surprising amount of mid-market business data. A dedicated warehouse earns its cost when query volume, data volume, or concurrency start to interfere with the application. A lakehouse earns its cost when a meaningful share of the data is not tabular and the processing is not SQL.
The reason the wrong choice is common is that the failure a data platform is supposed to fix is almost never a platform failure. The usual complaint is that two dashboards disagree about revenue. That is a modelling and definitions problem, and moving the same inconsistent logic onto a larger platform reproduces it faithfully at higher cost. The platform decision matters, and it matters less than the layer above it.
So the useful sequence is: decide what the metrics mean and where the transformation logic lives, keep that logic portable, then pick the smallest platform that handles today's volume with room for the next year. Portable logic is what makes the platform decision reversible, and a reversible decision does not need to be made perfectly the first time.
What the three things actually are
Postgres is a general-purpose relational database. It is row-oriented, built for transactional work, and very good at it. Used for analytics it will happily run joins and aggregations across tables with millions of rows, especially with the right indexes, materialized views for the expensive aggregations, and extensions that add columnar storage or time-series handling. Its analytical limits are real but much further out than its reputation suggests.
A data warehouse is a database designed for analytical queries rather than transactional ones. The defining difference is columnar storage: because an analytical query usually reads a few columns across very many rows, storing data by column rather than by row means scanning far less of it. Warehouses also separate storage from compute, so a heavy query can be given more machine without affecting anything else, and concurrent users do not compete for the same resources. The product names change; the architecture is the point.
A lakehouse keeps data as files in object storage, in open columnar formats, with a table layer on top that provides transactions, schema enforcement, and time travel. The appeal is that one copy of the data serves both SQL queries and non-SQL processing, such as machine learning on raw files, and that the storage format is not owned by a single vendor. The cost is operational complexity: more moving parts, more ways for a pipeline to produce files that nothing can read, and a higher engineering bar to run well.
Worth noting that these categories have been converging for years. Warehouses read external files; lakehouse table formats are queryable from multiple engines; Postgres has columnar extensions. Choosing between them is less a choice between three worlds than a choice about where on one spectrum your data and your team actually sit.
The test for whether Postgres is still enough
There are five questions that settle this for most mid-market companies, and none of them is about which platform is more modern.
How large is the largest table you query analytically, in rows and in the bytes the query has to read? Tens of millions of rows with queries touching a handful of columns is ordinary Postgres territory with sensible indexing and pre-aggregation. Hundreds of millions of rows with queries that scan most of the table is where columnar storage stops being optional, because the row-oriented engine is reading data the query does not want.
Is the analytical load hurting the application? This is the most decisive signal and the easiest to check. If reporting queries are competing with production transactions for the same database, the first fix is a read replica, which is cheap and solves it for a long time. If the analytical load saturates the replica too, the workload has outgrown general-purpose storage rather than merely outgrown one machine.
How many people and tools query concurrently, and what happens at the peak? A handful of analysts and a dashboard refresh is fine. A few hundred people opening dashboards at the same hour every Monday is a concurrency pattern that separated storage and compute handles gracefully and a single Postgres instance does not.
How much of the data is not tabular? If the answer is almost none, a lakehouse is paying complexity for a capability you are not using. If a real part of the value is in documents, images, audio, event payloads with inconsistent shapes, or anything a data scientist wants to process outside SQL, that is the actual lakehouse case.
Who will operate it? A platform that nobody on the team can debug on a Monday morning is a liability regardless of its benchmarks. This question eliminates more candidates than any technical one, and it is the question most platform comparisons leave out.
- Largest analytical table: tens of millions of rows is Postgres territory; hundreds of millions with full scans is not.
- Application interference: try a read replica first. If the replica also saturates, the workload has outgrown row storage.
- Concurrency: a few analysts is fine; hundreds of simultaneous dashboard users is a separated-compute problem.
- Non-tabular share: close to none means a lakehouse is paying complexity for an unused capability.
- Operability: if nobody on the team can debug it under pressure, the benchmark does not matter.
The decision underneath the platform decision
The thing that determines whether a data platform is trusted is not the platform. It is whether every metric has exactly one definition, written down, version controlled, and used by every dashboard. When two dashboards disagree about revenue, it is almost always because two queries implemented revenue differently, both defensibly, and nobody arbitrated. No platform fixes that, and every platform will serve both answers with equal confidence.
This is why the transformation layer deserves the attention the platform usually gets. Transformation logic defined as version-controlled SQL models, with tests on the sources and a documented definition per metric, is the asset. The platform is where it runs. Keeping the logic in a portable form, rather than in a pile of dashboard-specific queries or a vendor's proprietary modelling tool, is what makes a platform migration a configuration change rather than a rewrite.
Tests on the sources matter more than they sound. A pipeline that loads without checking row counts, uniqueness, null rates, and accepted values will eventually publish a wrong number confidently, and the organisation will find out when somebody makes a decision on it. A failed test that marks a dashboard stale is a far better outcome than a successful load of bad data, and that choice is made in the transformation layer, not the platform.
The practical consequence for a platform decision is that if the logic is portable and tested, picking the smaller platform first carries very little risk. You will know from the warning signs above when it is time to move, and the move will be a redeployment of models you already have rather than a project. If the logic is not portable, the platform choice becomes permanent by accident, which is the worst version of this decision.
What each choice costs you in practice
Postgres costs the least to run and the least to hire for, and almost every engineer already understands it. Its costs appear as engineering effort: indexes that need maintaining, materialized views that need refresh schedules, and an eventual ceiling you will hit if the data keeps growing. For a company whose reporting fits comfortably inside it, that is a good trade, and the money not spent on a platform can be spent on the data model, which is where the value is.
A warehouse costs real money on a consumption model, and the cost is driven by how much data queries scan rather than by how much you store. This is where warehouse bills surprise people: a dashboard that refreshes every fifteen minutes and scans a large table each time is an expensive dashboard, and nothing in the platform will tell you that unless you look. The controls that matter are partitioning so queries read less, pre-aggregated models so dashboards query small tables rather than raw ones, and refresh schedules that match how often the number is actually read. In exchange you get concurrency and scale that do not require engineering attention.
A lakehouse costs the most in engineering capability. Open storage formats, a table layer, a query engine, and orchestration are more components than a warehouse presents, and each is a place for things to go wrong in ways that need someone who understands the stack. The payoff is genuine when the workload is mixed SQL and non-SQL at volume, or when avoiding storage lock-in is a real strategic requirement rather than a preference. For a mid-market company doing business reporting, it is usually buying a capability that will go unused while the complexity is paid for every week.
Licence and consumption costs should be billed to you by the vendor directly rather than passing through a partner, for the same reason ad spend should: it keeps the running cost visible and it means nobody has an incentive for your queries to be expensive. If a vendor cannot explain what drives your bill before you commit, that is information about the vendor.
Signals that you have outgrown what you have
Platform migrations are usually triggered by a specific, observable event rather than by a strategic review. These are the ones worth watching for, because each one is measurable rather than a matter of opinion.
The reporting queries are slowing down production, and a read replica has already stopped being enough. Dashboard refreshes have moved from seconds to minutes and the business has started scheduling around them. The daily load no longer finishes inside its window, and the window cannot be moved. Analysts have begun exporting to spreadsheets to do work the platform cannot do in time, which is the clearest sign of all because it means the platform has stopped being the source of truth. And a real share of the questions being asked now involve data the current platform cannot hold, rather than data it holds slowly.
What is not a signal: a vendor comparison, a conference talk, or the observation that a larger company uses something larger. The data volume decides this, not the category of company you aspire to be.
One more pattern worth naming. If the stated reason for moving is that nobody trusts the numbers, the move will not fix it, and the project will end with the same distrust on a more expensive platform. Trust is produced by one definition per metric, tests on every source, and a visible freshness timestamp so a reader knows whether they are looking at today's number. Those are all available on Postgres. The honest version of the recommendation, which is the same one that applies to deciding whether a predictive model is justified yet, is to fix the reporting foundation first and treat the platform as a capacity question. The same discipline applied to AI systems is described in [getting data ready for retrieval systems](/blog/ai-data-readiness-for-rag), where the failure mode is identical: the infrastructure gets blamed for a data definition problem.
For the build-versus-buy framing of this decision, including when an off-the-shelf product already covers the requirement, [build vs buy for custom development](/blog/build-vs-buy-ai-custom-development-vs-off-the-shelf) covers the general test, and it applies to data platforms as directly as it does to applications.
- Reporting is slowing production and a read replica is no longer enough.
- Dashboard refreshes have moved from seconds to minutes and the business schedules around them.
- The daily load no longer finishes inside its window, and the window cannot move.
- Analysts are exporting to spreadsheets to do work the platform cannot do in time.
- A real share of new questions involve data the platform cannot hold at all, not data it holds slowly.
The short version
- Most mid-market companies buy a data platform one tier larger than their data requires, because the problem they are fixing is a definitions problem rather than a capacity one.
- Postgres handles analytical reporting for a lot of mid-market data, especially with a read replica, sensible indexes, and pre-aggregated models.
- A warehouse earns its cost when concurrency or scan volume start to interfere with the application. A lakehouse earns its cost when a real share of the data is not tabular.
- One version-controlled definition per metric, with tests on every source, is what makes numbers trusted. No platform supplies that.
- Keeping transformation logic portable makes the platform decision reversible, which means it does not have to be made perfectly the first time.
- Warehouse bills are driven by how much data queries scan, so partitioning, pre-aggregation, and refresh schedules are cost controls rather than optimizations.
Questions this raises
- Can I use Postgres as a data warehouse?
- For a lot of mid-market reporting, yes. Postgres handles analytical joins and aggregations across tables with tens of millions of rows when it has sensible indexes, materialized views for the expensive aggregations, and ideally a read replica so reporting does not compete with production transactions. It becomes the wrong tool when queries routinely scan most of very large tables, or when hundreds of people query concurrently, because row-oriented storage and shared compute are the limits you hit.
- What is the difference between a data warehouse and a lakehouse?
- A warehouse stores data in its own columnar format and is optimized for SQL analytics, with storage and compute separated so queries scale independently. A lakehouse keeps data as files in object storage in open columnar formats, with a table layer adding transactions and schema enforcement, so the same copy serves both SQL and non-SQL processing. The warehouse is simpler to operate; the lakehouse handles mixed workloads and avoids storage lock-in at the cost of more moving parts.
- When do we actually need a data warehouse?
- When the analytical workload starts interfering with everything else and a read replica is no longer enough: queries scanning most of very large tables, a daily load that no longer finishes in its window, dashboard refreshes measured in minutes, or concurrency peaks where many people query at once. The trigger is an observable event in your own system, not a comparison with what a larger company runs.
- Why do our two dashboards show different revenue numbers?
- Almost always because two queries implemented revenue differently, both defensibly, and nobody arbitrated between them. This is a definitions problem, not a platform problem, and moving to a larger platform reproduces it faithfully at higher cost. The fix is one version-controlled definition per metric in a transformation layer every dashboard reads from, plus tests on the sources so a failed load marks the dashboard stale rather than publishing a wrong number.
- What drives the cost of a cloud data warehouse?
- Mostly how much data your queries scan, not how much you store. A dashboard that refreshes every fifteen minutes against a large raw table is an expensive dashboard, and the platform will not warn you. The controls are partitioning so queries read less, pre-aggregated models so dashboards query small tables, and refresh schedules matched to how often the number is actually read. Ask a vendor to explain what will drive your bill before committing.
- How do we avoid getting locked into a data platform?
- Keep the transformation logic portable. If your metric definitions live as version-controlled SQL models rather than inside dashboard-specific queries or a vendor's proprietary modelling tool, moving platforms is a redeployment rather than a rewrite. That portability is also what makes it safe to start on the smaller platform: you will see the warning signs when capacity runs out, and the move will not be a project.
- Should we fix reporting before adding predictive analytics?
- Yes. A forecast built on pipelines with no tests and metrics with no agreed definitions is a confident guess, and it will be wrong in ways nobody can trace. Get one definition per metric, tests on every source, and a freshness timestamp on every dashboard first. Then evaluate any predictive model on held-out data against a naive baseline, such as last month repeated, and report the error in units the business understands.
Recognize this in your own operation?
Bring us the version of it happening in your business and we will tell you which part a system can take over.