A practical guide to cost optimization with Lakebase Postgres

Lakebase, a fully managed Postgres database, is crafted to meet the operational demands of contemporary application development. Its distinguishing feature lies in its innovative architecture, which separates storage and compute, incorporating a serverless compute layer. This design is seamlessly integrated with the Lakehouse and the data intelligence platform, offering a unique advantage over other database vendors that also provide a Postgres engine. For an in-depth exploration of this architecture and its benefits, you can read more here. One often overlooked advantage of this architecture is its remarkable cost efficiency. In this discussion, we will delve into the sources of these cost efficiencies and provide practical tips for maximizing them.

How Lakebase is cost-efficient by design

Avoid duplicate storage costs with branching

Database branches empower developers to establish isolated environments using production data for development, testing, or experimentation. Unlike traditional methods that necessitate the creation of separate physical copies of the database for each environment, Lakebase branches utilize the same underlying storage and monitor changes as the branch diverges from its parent. This approach proves particularly cost-effective for short-lived development and testing environments, allowing teams to engage with production-like data without the overhead of provisioning and maintaining entirely separate database copies.

Pay only for the compute you use

Autoscaling dynamically adjusts the compute resources of your Lakebase instance in response to fluctuating activity levels. Users can define the minimum and maximum thresholds for scaling. The cost advantages of this feature are evident: compute capacity aligns with workload demands rather than being statically provisioned for peak usage. By setting a maximum compute size, organizations can maintain predictable costs, avoiding unexpected expenses by capping the upper limit of compute costs. During periods of low activity, compute resources scale down, further reducing costs. When combined with the scale-to-zero feature, compute can be suspended entirely after a period of inactivity, effectively bringing compute costs to zero. This is particularly beneficial for scenarios that are not highly latency-sensitive, such as development workflows, non-production application variants, and production applications that do not require rapid response times. When scale-to-zero is disabled, Lakebase offers always-on pricing, which provides a 25% discount on baseline capacity, applicable to any compute that cannot scale to zero, including high availability configurations.

Add replicas and high availability without duplicating storage

The separation of storage and compute in Lakebase enhances the cost efficiency of read replicas and high availability. Read replicas function as independent compute instances that draw from the same underlying storage layer as the primary instance, meaning that scaling read capacity does not incur the cost of creating another database copy. Similarly, high availability configurations introduce redundant compute across availability zones while leveraging the existing highly available storage layer. This design allows for increased read capacity and compute redundancy without inflating the storage footprint.

Practical tips for optimizing Lakebase costs

Serve a subset of Lakehouse data with Lakebase Synced Tables

The close integration of Lakebase with the Databricks Intelligence Platform facilitates managed syncs between the two environments. Synced tables enable the presentation of Unity Catalog data within your Lakebase database, supporting low-latency transactional reads for application or feature-serving scenarios. A common pitfall for customers is transferring a large Delta table into Lakebase when only a smaller active subset is queried by the application. This practice can inflate Lakebase storage, elevate sync costs, and potentially lead to performance challenges. The solution is straightforward: sync only the necessary working set for the application. For instance, define the required data using a Materialized View, such as a rolling 60-day window, and sync exclusively that subset. Lakebase sync pipelines can utilize the automatic change data feed to compute row-level changes at read time, ensuring that updates to the Materialized View, including deletions as rows age out of the rolling window, are incrementally propagated into Lakebase. This results in a fresh, low-latency active subset in Lakebase while retaining the complete history in Delta. Coupling this with the most efficient sync mode that meets your requirements can establish a more cost-effective reverse ETL pattern.

Using the appropriate Lakehouse → Lakebase sync mode

Synced Tables operate as managed Serverless Spark Declarative Pipelines (SDP) and run for the duration of the sync process. Consequently, sync costs are influenced by factors such as the volume of data transferred and the size of the Lakebase instance or Capacity Units (CUs). There are three distinct sync modes for transferring data from the Lakehouse into Lakebase, and selecting the appropriate mode is crucial for balancing freshness and cost.

Source: Sync Modes Snapshot mode is the most cost-effective option for infrequently updated or highly volatile tables, while Continuous can be the most expensive due to its continuous pipeline operation, consuming compute even without changes to process. Snapshot mode is recommended when over 10% of the source data changes between syncs, as it can be up to 10x more efficient. For incremental workloads, Triggered mode strikes an ideal balance between cost and latency. Achieving near-continuous freshness on a budget is possible by pairing Triggered mode with a table-update trigger, ensuring it runs only when source data changes. Generally, it is advisable to avoid long intervals between runs, as a significant backlog of changes can lead to slow and costly subsequent syncs. Another effective cost optimization is the ability to binpack, or group, multiple tables into a single sync pipeline. If your use case permits, the same pipeline can sync changes from various Delta tables into Lakebase, allowing those tables to share the same underlying compute. This becomes particularly advantageous for Continuous syncs, where the pipeline is always active, as it prevents the need to pay for separate continuously running pipelines for each table.

Right-size Lakebase from the start

Upon creating a Lakebase project, it automatically includes a production branch and a primary read-write compute instance. By default, this compute is configured to autoscale between 8 and 16 CU, with scale to zero activated after 24 hours of inactivity. While these defaults may suit your workload, failing to adjust them if your application requires less compute could result in unnecessary costs. Instead of waiting to resize after project creation, you can programmatically set the initial compute range during provisioning. For instance, using the Databricks SDK:

If you manage Lakebase declaratively with Declarative Automation Bundles (DABs), you can similarly define the compute range for the endpoints you provision:

The most critical factor in sizing is your working set: the data and indexes your application frequently accesses, rather than the total size of your database on disk. For example, a 2500 GB database with a 20 GB hot working set does not require 2500 GB of RAM; it only needs enough memory to accommodate those 20 GB, plus some additional headroom. This is significant because of how compute utilizes memory. RAM scales linearly with compute size, and up to 75% of a compute’s RAM is available as its compute cache. When your working set fits within that cache, the majority of reads are served from memory, ensuring fast and consistent latency. Conversely, if it does not fit, Postgres must retrieve pages that miss the cache from storage, resulting in slower performance and introducing latency variability that your application will experience. Thus, sizing primarily involves selecting a compute size that exceeds your working set while allowing for headroom for other operations. Additionally, consider query complexity, concurrency, and latency targets, as workloads that are highly concurrent or sensitive to latency will require more headroom than lightly used internal tools with the same data size.

Connections to the database also warrant careful consideration. The max_connections parameter, which sets the limit on concurrent Postgres connections, is determined by your compute size. For autoscaling compute, this limit is dictated by the smaller of your maximum CU and eight times your minimum CU. Increasing the maximum only raises connections up to eight times your minimum, and beyond that, a small minimum restricts how much a larger maximum can extend. Applications that open a significant number of connections can reach this ceiling and begin rejecting new connections with errors. If connection volume is a constraint, factor it into your minimum CU and implement a connection pooler in front of Lakebase. A pooler enables many client connections to share a pool of Postgres connections and can support up to 10,000 concurrent client connections. Pooling is typically the optimal solution for applications that open numerous connections and is more cost-effective than merely increasing compute size to raise the connection limit.

Fortunately, you do not have to rely on guesswork. The Lakebase Metrics dashboard provides insights into your working set size over 5-minute, 15-minute, and 1-hour intervals, displayed alongside your available compute cache for a quick assessment of whether your hot data fits. Reviewing this data in conjunction with cache hit rate, CPU, RAM, and connection utilization allows you to validate your initial sizing and make adjustments as needed. For workloads with stable access patterns, comparing the 1-hour working set against available compute cache serves as a particularly useful indicator. Autoscaling is most beneficial when your working set comfortably fits in memory at the minimum CU, as otherwise, you incur a cold cache penalty each time the compute scales up. Utilize these metrics to establish a minimum that accommodates your working set and a maximum that can handle peak demands.

What an undersized compute feels like

• Slow and inconsistent query latency. When the working set no longer fits in cache, reads that miss the cache must access storage. Your median latency may appear acceptable while p95 and p99 metrics rise and become erratic, as performance now hinges on whether a specific query’s data is cached.
• A falling cache hit ratio. This serves as a leading indicator that your working set has outgrown the available cache, and it begins to decline before latency visibly deteriorates.
• CPU saturation and query queuing. An undersized compute can max out CPU under load, causing queries to wait, throughput to plateau, and latency to increase across the board.
• Connection errors. Each compute size has a cap on concurrent connections; when clients exceed this limit, new connections are rejected with “too many clients” errors instead of degrading gracefully.
• A cold cache penalty after scaling or waking. Following a scale-to-zero wake or an initial autoscale, the cache starts empty and requires time to warm up. You will observe a spike in slower queries until the working set is cached again, highlighting the importance of the minimum compute size.

Optimize your PITR and Snapshot strategy

Point-in-time restore (PITR) continuously maintains the history necessary to restore your database to any moment within a configurable recovery window of 2–30 days. In contrast, snapshots are discrete point-in-time captures of a root branch that can be created manually or on a scheduled basis (daily, weekly, or monthly). The storage requirements for PITR grow with both write activity and the length of your recovery window, as Lakebase must retain the history of changes throughout that period. For write-heavy applications, an extended PITR window can lead to significant storage consumption. A cost-effective strategy is to select a PITR window that aligns with your incident recovery needs and complement it with scheduled snapshots for longer-term recovery points. The good news is that both options are priced lower than standard Lakebase branch storage. Snapshot storage ([cyberseo_openai model=”gpt-4o-mini” prompt=”Rewrite a news story for a technical publication, in a calm style with creativity and flair based on text below, making sure it reads like human-written text in a natural way. The article shall NOT include a title, introduction and conclusion. The article shall NOT start from a title. Response language English. Generate HTML-formatted content using

tag for a sub-heading. You can use only

,

,
,
• , and HTML tags if necessary. Text: Lakebase is a fully managed Postgres database, built for the operational realities of modern application development. What sets it apart from other database vendors in the market also offering a Postgres engine is the architecture underneath, separated storage and compute with a serverless compute layer, and its tight integration with the Lakehouse and the data intelligence platform. You can read more about this architecture and some of the benefits here. A benefit that often flies under the radar, however, is that this architecture also makes Lakebase highly cost efficient. In this blog, we’ll break down where those cost efficiencies come from and share practical tips for getting the most out of them.
  

  How Lakebase is cost-efficient by design

  Avoid duplicate storage costs with branching

  Database branches allow developers to create isolated environments with production data for development, testing, or experimentation purposes. Unlike approaches that require creating a separate physical copy of the database for each environment, Lakebase branches share the same underlying storage and track changes as the branch diverges from its parent. This makes branching particularly cost-efficient for short-lived development and testing environments, where teams can work with production-like data without needing to provision and maintain a completely separate copy of the database.

  Pay only for the compute you use

  Autoscaling actively changes the compute resources of your Lakebase instance in response to varying levels of activity. You can control the minimum and maximum range that the instance can scale between. The cost benefits of this feature are clear: compute capacity can scale with workload demand instead of being statically provisioned for peak usage.Setting a maximum compute size helps make costs predictable because you prevent unexpected spend by capping the upper bound of your compute costs. During moments of low usage, your compute scales down, reducing costs. When coupled with scale to zero, the compute gets suspended entirely after a period of inactivity, reducing compute costs to zero. Compute resumes from scale to zero in a few hundred milliseconds. This makes it especially attractive for scenarios that aren’t exceptionally latency sensitive, such as development workflows, non-production variants of apps, and production apps that don’t need double-digit latencies.When scale to zero is turned off, Lakebase has always on pricing, which is a 25% discount on your baseline capacity. This cost reduction also applies to any compute that cannot scale to zero, such as HA configurations.

  Add replicas and high availability without duplicating storage

  Lakebase’s separation of storage and compute also makes read replicas and high availability more cost efficient. Read replicas are independent compute instances that read from the same underlying storage layer as the primary, so scaling read capacity does not require creating and paying for another copy of the database. Similarly, high availability adds redundant compute across availability zones while continuing to use the existing highly available storage layer. This means you can add read scale and compute redundancy without multiplying your storage footprint.

  Practical tips for optimizing Lakebase costs

  Serve a subset of Lakehouse data with Lakebase Synced Tables

  The tight integration of Lakebase with the broader Databricks Intelligence Platform allows for managed syncs between the two environments. Synced tables surface Unity Catalog data in your Lakebase database to support low-latency transactional reads for application or feature-serving use cases.A common misstep customers make is pushing a large Delta table into Lakebase when the application only queries a much smaller active subset. This inflates Lakebase storage, increases sync costs, and can even lead to performance issues in some scenarios. The fix is simple: sync only the working set needed for the application. Define exactly the data your app needs with a Materialized View, for example a rolling 60-day window, and sync just that. Lakebase sync pipelines can use MV’s automatic change data feed to compute row-level changes at read time. This means changes to the MV, including deletions as rows age out of a rolling window, can be propagated incrementally into Lakebase. The result is a fresh, low-latency active subset in Lakebase while the full history remains in Delta. Pair this with the leanest sync mode that meets your requirements, covered below, and you have a much more cost-efficient reverse ETL pattern.

  Using the appropriate Lakehouse → Lakebase sync mode

  Synced Tables are managed Serverless Spark Declarative Pipelines (SDP) under the hood and run for the duration of the sync. Consequently, sync cost is driven by factors such as the amount of data being moved and the Lakebase instance size / Capacity Units (CUs).There are three different sync modes for moving data from the Lakehouse into Lakebase, and it is important to match the mode to how fresh the data truly needs to be. Choosing the right mode allows you to meet your latency requirements while keeping costs under control.

  Mode	Description	Best to use when
  Snapshot	Copy of all data	Source changes >10% of rows per cycle. Will be substantially more cost-effective than Triggered in those scenarios.
  Triggered	Incremental updates that run on demand or at intervals	Source rows change on a known cadence. Inserts, updates, and deletes are propagated each refresh.
  Continuous	Real-time streaming with seconds of latency	Changes must appear in Lakebase in near real time. This provides the lowest lag at the highest cost.

  Source: Sync ModesSnapshot is the most cost-effective option for infrequently updated or highly volatile tables, while Continuous can be the most expensive because its pipeline runs continuously and consumes compute even when there are no changes to process. Snapshot mode is recommended when more than 10% of the source data changes between syncs because it can be up to 10x more efficient. For incremental workloads, Triggered mode offers the ideal balance of cost and latency. You can achieve near-continuous freshness on a budget by pairing Triggered mode with a table-update trigger, ensuring it runs only when source data changes. In general, avoid long intervals between runs, as a massive backlog of changes can make the subsequent sync slow and costly.Another useful cost optimization is the ability to binpack, or group, multiple tables into a single sync pipeline. If your use case allows for it, the same pipeline can sync changes from multiple Delta tables into Lakebase, allowing those tables to share the same underlying compute. This can be particularly valuable for Continuous syncs, where the pipeline is always running, because it avoids paying for separate continuously running pipelines for each table.

  Right-size Lakebase from the start

  When a Lakebase project is created, it automatically comes with a production branch and a primary read-write compute. By default, that compute is configured to autoscale between 8 and 16 CU, with scale to zero enabled after 24 hours of inactivity. Those defaults may be perfectly reasonable for your workload, but if your application requires less compute, leaving them unchanged can mean paying for more capacity than you need.Rather than creating the project and remembering to resize it afterward, you can set the initial compute range when provisioning the project programmatically. For example, using the Databricks SDK:If you manage Lakebase declaratively with Declarative Automation Bundles (DABs), you can similarly define the compute range for the endpoints you provision:The single most important input to sizing is your working set: the data and indexes your application accesses frequently, as opposed to the full size of your database on disk. A 2500 GB database with a 20 GB hot working set does not need 2500 GB of RAM. It only needs enough memory to keep those 20 GB, plus some headroom, cached. This matters because of how the compute uses memory. RAM scales linearly with compute size, and up to 75% of a compute’s RAM is available as its compute cache. When your working set fits in that cache, the vast majority of reads are served from memory, so they stay fast and their latency stays consistent. When it does not fit, Postgres has to fetch the pages that miss the cache from storage, which is far slower than a memory hit and introduces the latency variability your application will feel. Sizing is therefore largely the exercise of choosing a compute whose cache exceeds your working set, while also leaving headroom for other operations. Memory is not the only thing that scales with compute size, though. Weigh query complexity, concurrency, and your latency targets too, because a workload that is highly concurrent or sensitive to latency needs more headroom than a lightly used internal tool at the same data size.Connections to the database also deserve particular attention. max_connections, the hard ceiling on concurrent Postgres connections, is also determined by your compute size, and for an autoscaling compute it follows a specific rule: the limit is set by the smaller of your maximum CU and eight times your minimum CU. Raising the maximum therefore adds connections only up to eight times your minimum, and past that point a small minimum caps how far a larger maximum can take you. An application that opens a large number of connections can hit this ceiling and start rejecting new connections with errors. If connection volume is a real constraint, factor it into your minimum CU, and put a connection pooler in front of Lakebase. A pooler lets many client connections share a pool of Postgres connections and supports up to 10,000 concurrent client connections. Pooling is usually the right answer for apps that open a lot of connections, and it is cheaper than sizing compute up purely to raise the connection ceiling.You do not have to guess at any of this. The Lakebase Metrics dashboard reports your working set size over 5 minute, 15 minute, and 1 hour windows and shows it directly alongside your available compute cache, so you can see at a glance whether your hot data fits. Read it together with cache hit rate, CPU, RAM, and connection utilization to validate your initial sizing and adjust up or down. For workloads with stable access patterns, comparing the 1 hour working set against available compute cache is a particularly useful signal. Autoscaling delivers the most benefit when your working set already fits in memory at the minimum CU, because otherwise you pay a cold cache penalty every time the compute scales up. Use these metrics to set a minimum that holds your working set and a maximum that absorbs your peaks.

  What an undersized compute feels like

  Undersizing rarely shows up as an outright failure. More often it appears as symptoms that are easy to misdiagnose:

  • Slow and inconsistent query latency. When the working set no longer fits in cache, reads that miss the cache go to storage. Your median latency may still look fine while p95 and p99 climb and become erratic, because performance now depends on whether a given query’s data happened to be cached.
  • A falling cache hit ratio. This is the leading indicator that your working set has outgrown available cache, and it starts to slip before latency visibly degrades.
  • CPU saturation and query queuing. An undersized compute pegs CPU under load, so queries wait, throughput plateaus, and latency rises across the board.
  • Connection errors. Each compute size has a ceiling on concurrent connections; when clients exceed it, new connections are rejected with “too many clients” errors rather than degrading gracefully.
  • A cold cache penalty after scaling or waking. After a scale to zero wake, or when autoscaling first scales up, the cache starts empty and has to warm up. You will see a burst of slower queries until the working set is cached again, which is why the minimum compute size matters as much as the maximum.

  Optimize your PITR and Snapshot strategy

  Point-in-time restore (PITR) continuously maintains the history needed to restore your database to any moment within a configurable recovery window of 2–30 days. Snapshots, on the other hand, are discrete point-in-time captures of a root branch that can be created manually or on an automated daily, weekly, or monthly schedule.PITR storage grows with both write activity and the length of your recovery window, since Lakebase must retain the history of changes throughout that period. For a write-heavy application, a long PITR window can result in significant storage consumption. A cost-conscious approach is to choose a PITR window that meets your incident-recovery requirements and supplement it with scheduled snapshots when you need longer-term recovery points.The good news is that both are priced at a lower rate than regular Lakebase branch storage. Snapshot storage ($0.090/GB-month) is roughly 74% cheaper than regular branch storage, while PITR storage ($0.200/GB-month) is about 42% cheaper. Scheduled snapshots can be particularly storage efficient: the first snapshot in a schedule is stored as a full snapshot, while subsequent snapshots are charged only for incremental changes.Use PITR to recover from unexpected incidents such as accidental deletes or bad writes that could occur at any time within your recovery window. Use snapshots for planned recovery points. For example, take a manual snapshot before a risky migration or bulk update, and use scheduled snapshots for routine, longer-term protection.Ultimately, match your recovery configuration to your actual recovery requirements. Keeping more history or recovery points than you need can increase storage costs without providing meaningful additional value.

  Finding your Lakebase costs

  As discussed above, Lakebase costs fall into three areas: database compute, database storage, and, when using Synced Tables, the serverless pipeline compute used to sync data from the Lakehouse into Lakebase.Compute is metered based on CU usage over time. With Autoscaling, usage follows the compute capacity consumed as the database scales within its configured range.Storage includes database branch storage, point-in-time restore (PITR) history, and snapshot storage. These are metered separately based on their underlying storage usage.Synced Tables use managed pipelines to move data from Unity Catalog into Lakebase. The pipeline compute used for the sync is billed separately from the Lakebase database compute.

  View Lakebase compute and storage costs

  Lakebase compute and storage usage is available in system.billing.usage. Storage usage can be broken down further using product_features.lakebase.storage_type:

  • BRANCH_DATA_STORAGE: storage for non-expiring database branches
  • BRANCH_CHANGE_STORAGE: changed data stored for expiring branches
  • BRANCH_HISTORY_STORAGE: history retained for PITR

  The query below joins usage to system.billing.list_prices to estimate daily cost at the effective list price.Lakebase exposes separate compute and storage SKUs in billing system tables, with the storage type field providing the additional breakdown shown above.You can find the project UID in the Lakebase UI under Project > Settings > UID. Programmatically, if you know the project name, list projects and match on status.display_name to retrieve its uid.

  View Synced Table pipeline costs

  Synced Table pipeline usage can also be queried from system.billing.usage. Filter on the underlying pipeline ID and join to system.billing.list_prices to estimate the pipeline’s daily cost.These queries estimate cost using the effective list price for the usage period. Customer-specific contractual discounts are not reflected.You can find the pipeline ID by opening the Synced Table in the UI and copying Pipeline ID. Programmatically, retrieve the Synced Table and read status.pipeline_id:

  Putting it all together

  Lakebase is designed to be cost efficient from the architecture up, from shared storage and branching to autoscaling and serverless compute. Pair those built-in efficiencies with thoughtful configuration around sizing, sync strategy, and recovery, and you can keep costs predictable while still getting the performance, availability, and developer experience your applications need.” temperature=”0.3″ top_p=”1.0″ best_of=”1″ presence_penalty=”0.1″ ].090/GB-month) is approximately 74% cheaper than regular branch storage, while PITR storage ([cyberseo_openai model=”gpt-4o-mini” prompt=”Rewrite a news story for a technical publication, in a calm style with creativity and flair based on text below, making sure it reads like human-written text in a natural way. The article shall NOT include a title, introduction and conclusion. The article shall NOT start from a title. Response language English. Generate HTML-formatted content using

  tag for a sub-heading. You can use only

  ,

  ,
  ,
  • , and HTML tags if necessary. Text: Lakebase is a fully managed Postgres database, built for the operational realities of modern application development. What sets it apart from other database vendors in the market also offering a Postgres engine is the architecture underneath, separated storage and compute with a serverless compute layer, and its tight integration with the Lakehouse and the data intelligence platform. You can read more about this architecture and some of the benefits here. A benefit that often flies under the radar, however, is that this architecture also makes Lakebase highly cost efficient. In this blog, we’ll break down where those cost efficiencies come from and share practical tips for getting the most out of them.
    

    How Lakebase is cost-efficient by design

    Avoid duplicate storage costs with branching

    Database branches allow developers to create isolated environments with production data for development, testing, or experimentation purposes. Unlike approaches that require creating a separate physical copy of the database for each environment, Lakebase branches share the same underlying storage and track changes as the branch diverges from its parent. This makes branching particularly cost-efficient for short-lived development and testing environments, where teams can work with production-like data without needing to provision and maintain a completely separate copy of the database.

    Pay only for the compute you use

    Autoscaling actively changes the compute resources of your Lakebase instance in response to varying levels of activity. You can control the minimum and maximum range that the instance can scale between. The cost benefits of this feature are clear: compute capacity can scale with workload demand instead of being statically provisioned for peak usage.Setting a maximum compute size helps make costs predictable because you prevent unexpected spend by capping the upper bound of your compute costs. During moments of low usage, your compute scales down, reducing costs. When coupled with scale to zero, the compute gets suspended entirely after a period of inactivity, reducing compute costs to zero. Compute resumes from scale to zero in a few hundred milliseconds. This makes it especially attractive for scenarios that aren’t exceptionally latency sensitive, such as development workflows, non-production variants of apps, and production apps that don’t need double-digit latencies.When scale to zero is turned off, Lakebase has always on pricing, which is a 25% discount on your baseline capacity. This cost reduction also applies to any compute that cannot scale to zero, such as HA configurations.

    Add replicas and high availability without duplicating storage

    Lakebase’s separation of storage and compute also makes read replicas and high availability more cost efficient. Read replicas are independent compute instances that read from the same underlying storage layer as the primary, so scaling read capacity does not require creating and paying for another copy of the database. Similarly, high availability adds redundant compute across availability zones while continuing to use the existing highly available storage layer. This means you can add read scale and compute redundancy without multiplying your storage footprint.

    Practical tips for optimizing Lakebase costs

    Serve a subset of Lakehouse data with Lakebase Synced Tables

    The tight integration of Lakebase with the broader Databricks Intelligence Platform allows for managed syncs between the two environments. Synced tables surface Unity Catalog data in your Lakebase database to support low-latency transactional reads for application or feature-serving use cases.A common misstep customers make is pushing a large Delta table into Lakebase when the application only queries a much smaller active subset. This inflates Lakebase storage, increases sync costs, and can even lead to performance issues in some scenarios. The fix is simple: sync only the working set needed for the application. Define exactly the data your app needs with a Materialized View, for example a rolling 60-day window, and sync just that. Lakebase sync pipelines can use MV’s automatic change data feed to compute row-level changes at read time. This means changes to the MV, including deletions as rows age out of a rolling window, can be propagated incrementally into Lakebase. The result is a fresh, low-latency active subset in Lakebase while the full history remains in Delta. Pair this with the leanest sync mode that meets your requirements, covered below, and you have a much more cost-efficient reverse ETL pattern.

    Using the appropriate Lakehouse → Lakebase sync mode

    Synced Tables are managed Serverless Spark Declarative Pipelines (SDP) under the hood and run for the duration of the sync. Consequently, sync cost is driven by factors such as the amount of data being moved and the Lakebase instance size / Capacity Units (CUs).There are three different sync modes for moving data from the Lakehouse into Lakebase, and it is important to match the mode to how fresh the data truly needs to be. Choosing the right mode allows you to meet your latency requirements while keeping costs under control.

    Mode	Description	Best to use when
    Snapshot	Copy of all data	Source changes >10% of rows per cycle. Will be substantially more cost-effective than Triggered in those scenarios.
    Triggered	Incremental updates that run on demand or at intervals	Source rows change on a known cadence. Inserts, updates, and deletes are propagated each refresh.
    Continuous	Real-time streaming with seconds of latency	Changes must appear in Lakebase in near real time. This provides the lowest lag at the highest cost.

    Source: Sync ModesSnapshot is the most cost-effective option for infrequently updated or highly volatile tables, while Continuous can be the most expensive because its pipeline runs continuously and consumes compute even when there are no changes to process. Snapshot mode is recommended when more than 10% of the source data changes between syncs because it can be up to 10x more efficient. For incremental workloads, Triggered mode offers the ideal balance of cost and latency. You can achieve near-continuous freshness on a budget by pairing Triggered mode with a table-update trigger, ensuring it runs only when source data changes. In general, avoid long intervals between runs, as a massive backlog of changes can make the subsequent sync slow and costly.Another useful cost optimization is the ability to binpack, or group, multiple tables into a single sync pipeline. If your use case allows for it, the same pipeline can sync changes from multiple Delta tables into Lakebase, allowing those tables to share the same underlying compute. This can be particularly valuable for Continuous syncs, where the pipeline is always running, because it avoids paying for separate continuously running pipelines for each table.

    Right-size Lakebase from the start

    When a Lakebase project is created, it automatically comes with a production branch and a primary read-write compute. By default, that compute is configured to autoscale between 8 and 16 CU, with scale to zero enabled after 24 hours of inactivity. Those defaults may be perfectly reasonable for your workload, but if your application requires less compute, leaving them unchanged can mean paying for more capacity than you need.Rather than creating the project and remembering to resize it afterward, you can set the initial compute range when provisioning the project programmatically. For example, using the Databricks SDK:If you manage Lakebase declaratively with Declarative Automation Bundles (DABs), you can similarly define the compute range for the endpoints you provision:The single most important input to sizing is your working set: the data and indexes your application accesses frequently, as opposed to the full size of your database on disk. A 2500 GB database with a 20 GB hot working set does not need 2500 GB of RAM. It only needs enough memory to keep those 20 GB, plus some headroom, cached. This matters because of how the compute uses memory. RAM scales linearly with compute size, and up to 75% of a compute’s RAM is available as its compute cache. When your working set fits in that cache, the vast majority of reads are served from memory, so they stay fast and their latency stays consistent. When it does not fit, Postgres has to fetch the pages that miss the cache from storage, which is far slower than a memory hit and introduces the latency variability your application will feel. Sizing is therefore largely the exercise of choosing a compute whose cache exceeds your working set, while also leaving headroom for other operations. Memory is not the only thing that scales with compute size, though. Weigh query complexity, concurrency, and your latency targets too, because a workload that is highly concurrent or sensitive to latency needs more headroom than a lightly used internal tool at the same data size.Connections to the database also deserve particular attention. max_connections, the hard ceiling on concurrent Postgres connections, is also determined by your compute size, and for an autoscaling compute it follows a specific rule: the limit is set by the smaller of your maximum CU and eight times your minimum CU. Raising the maximum therefore adds connections only up to eight times your minimum, and past that point a small minimum caps how far a larger maximum can take you. An application that opens a large number of connections can hit this ceiling and start rejecting new connections with errors. If connection volume is a real constraint, factor it into your minimum CU, and put a connection pooler in front of Lakebase. A pooler lets many client connections share a pool of Postgres connections and supports up to 10,000 concurrent client connections. Pooling is usually the right answer for apps that open a lot of connections, and it is cheaper than sizing compute up purely to raise the connection ceiling.You do not have to guess at any of this. The Lakebase Metrics dashboard reports your working set size over 5 minute, 15 minute, and 1 hour windows and shows it directly alongside your available compute cache, so you can see at a glance whether your hot data fits. Read it together with cache hit rate, CPU, RAM, and connection utilization to validate your initial sizing and adjust up or down. For workloads with stable access patterns, comparing the 1 hour working set against available compute cache is a particularly useful signal. Autoscaling delivers the most benefit when your working set already fits in memory at the minimum CU, because otherwise you pay a cold cache penalty every time the compute scales up. Use these metrics to set a minimum that holds your working set and a maximum that absorbs your peaks.

    What an undersized compute feels like

    Undersizing rarely shows up as an outright failure. More often it appears as symptoms that are easy to misdiagnose:

    • Slow and inconsistent query latency. When the working set no longer fits in cache, reads that miss the cache go to storage. Your median latency may still look fine while p95 and p99 climb and become erratic, because performance now depends on whether a given query’s data happened to be cached.
    • A falling cache hit ratio. This is the leading indicator that your working set has outgrown available cache, and it starts to slip before latency visibly degrades.
    • CPU saturation and query queuing. An undersized compute pegs CPU under load, so queries wait, throughput plateaus, and latency rises across the board.
    • Connection errors. Each compute size has a ceiling on concurrent connections; when clients exceed it, new connections are rejected with “too many clients” errors rather than degrading gracefully.
    • A cold cache penalty after scaling or waking. After a scale to zero wake, or when autoscaling first scales up, the cache starts empty and has to warm up. You will see a burst of slower queries until the working set is cached again, which is why the minimum compute size matters as much as the maximum.

    Optimize your PITR and Snapshot strategy

    Point-in-time restore (PITR) continuously maintains the history needed to restore your database to any moment within a configurable recovery window of 2–30 days. Snapshots, on the other hand, are discrete point-in-time captures of a root branch that can be created manually or on an automated daily, weekly, or monthly schedule.PITR storage grows with both write activity and the length of your recovery window, since Lakebase must retain the history of changes throughout that period. For a write-heavy application, a long PITR window can result in significant storage consumption. A cost-conscious approach is to choose a PITR window that meets your incident-recovery requirements and supplement it with scheduled snapshots when you need longer-term recovery points.The good news is that both are priced at a lower rate than regular Lakebase branch storage. Snapshot storage ($0.090/GB-month) is roughly 74% cheaper than regular branch storage, while PITR storage ($0.200/GB-month) is about 42% cheaper. Scheduled snapshots can be particularly storage efficient: the first snapshot in a schedule is stored as a full snapshot, while subsequent snapshots are charged only for incremental changes.Use PITR to recover from unexpected incidents such as accidental deletes or bad writes that could occur at any time within your recovery window. Use snapshots for planned recovery points. For example, take a manual snapshot before a risky migration or bulk update, and use scheduled snapshots for routine, longer-term protection.Ultimately, match your recovery configuration to your actual recovery requirements. Keeping more history or recovery points than you need can increase storage costs without providing meaningful additional value.

    Finding your Lakebase costs

    As discussed above, Lakebase costs fall into three areas: database compute, database storage, and, when using Synced Tables, the serverless pipeline compute used to sync data from the Lakehouse into Lakebase.Compute is metered based on CU usage over time. With Autoscaling, usage follows the compute capacity consumed as the database scales within its configured range.Storage includes database branch storage, point-in-time restore (PITR) history, and snapshot storage. These are metered separately based on their underlying storage usage.Synced Tables use managed pipelines to move data from Unity Catalog into Lakebase. The pipeline compute used for the sync is billed separately from the Lakebase database compute.

    View Lakebase compute and storage costs

    Lakebase compute and storage usage is available in system.billing.usage. Storage usage can be broken down further using product_features.lakebase.storage_type:

    • BRANCH_DATA_STORAGE: storage for non-expiring database branches
    • BRANCH_CHANGE_STORAGE: changed data stored for expiring branches
    • BRANCH_HISTORY_STORAGE: history retained for PITR

    The query below joins usage to system.billing.list_prices to estimate daily cost at the effective list price.Lakebase exposes separate compute and storage SKUs in billing system tables, with the storage type field providing the additional breakdown shown above.You can find the project UID in the Lakebase UI under Project > Settings > UID. Programmatically, if you know the project name, list projects and match on status.display_name to retrieve its uid.

    View Synced Table pipeline costs

    Synced Table pipeline usage can also be queried from system.billing.usage. Filter on the underlying pipeline ID and join to system.billing.list_prices to estimate the pipeline’s daily cost.These queries estimate cost using the effective list price for the usage period. Customer-specific contractual discounts are not reflected.You can find the pipeline ID by opening the Synced Table in the UI and copying Pipeline ID. Programmatically, retrieve the Synced Table and read status.pipeline_id:

    Putting it all together

    Lakebase is designed to be cost efficient from the architecture up, from shared storage and branching to autoscaling and serverless compute. Pair those built-in efficiencies with thoughtful configuration around sizing, sync strategy, and recovery, and you can keep costs predictable while still getting the performance, availability, and developer experience your applications need.” temperature=”0.3″ top_p=”1.0″ best_of=”1″ presence_penalty=”0.1″ ].200/GB-month) is about 42% cheaper. Scheduled snapshots can be particularly efficient: the first snapshot in a schedule is stored as a full snapshot, while subsequent snapshots incur charges only for incremental changes. Use PITR to recover from unexpected incidents, such as accidental deletions or erroneous writes, within your recovery window. Employ snapshots for planned recovery points, such as taking a manual snapshot before a risky migration or bulk update, and utilize scheduled snapshots for routine, long-term protection. Ultimately, align your recovery configuration with your actual recovery requirements; retaining more history or recovery points than necessary can escalate storage costs without delivering meaningful additional value.

    Finding your Lakebase costs

    As outlined, Lakebase costs are categorized into three areas: database compute, database storage, and, when utilizing Synced Tables, the serverless pipeline compute required to sync data from the Lakehouse into Lakebase. Compute is measured based on CU usage over time. With Autoscaling, usage corresponds to the compute capacity consumed as the database scales within its designated range. Storage encompasses database branch storage, point-in-time restore (PITR) history, and snapshot storage, all measured separately based on their underlying usage. Synced Tables leverage managed pipelines to transfer data from Unity Catalog into Lakebase, with the pipeline compute for the sync billed separately from the Lakebase database compute.

    View Lakebase compute and storage costs

    Lakebase compute and storage usage can be accessed through system.billing.usage. Storage usage can be further detailed using product_features.lakebase.storage_type:

    • BRANCH_DATA_STORAGE: storage for non-expiring database branches
    • BRANCH_CHANGE_STORAGE: changed data stored for expiring branches
    • BRANCH_HISTORY_STORAGE: history retained for PITR

    The accompanying query joins usage to system.billing.list_prices to estimate daily costs at the effective list price.

    Lakebase provides distinct compute and storage SKUs in billing system tables, with the storage type field offering the additional breakdown mentioned above. You can locate the project UID in the Lakebase UI under Project > Settings > UID. Programmatically, if you know the project name, you can list projects and match on status.display_name to retrieve its UID.

    View Synced Table pipeline costs

    Usage of Synced Table pipelines can also be queried from system.billing.usage. By filtering on the underlying pipeline ID and joining to system.billing.list_prices, you can estimate the daily cost of the pipeline.

    These queries provide cost estimates based on the effective list price for the usage period, excluding customer-specific contractual discounts. You can find the pipeline ID by accessing the Synced Table in the UI and copying the Pipeline ID. Programmatically, retrieve the Synced Table and read status.pipeline_id: