# Databricks LTAP Direct Writes in beta: faster synced table loads

> LTAP Direct Writes loads synced tables straight to storage, off the app's endpoint. What it covers, and the latency test we'd run before trusting it.

By TechFabric, 13 September 2026, updated 19 October 2026. Databricks Field Guide, TechFabric. Canonical: https://databricks.techfabric.com/notes/ltap-direct-writes-is-the-first-piece/

At the first [Gilbert Databricks User Group](https://www.techfabric.com/events/building-applications-on-lakebase) session on 18 September 2026, where Preetham Reddy built an application on Lakebase live, a synced table in SNAPSHOT mode came online 51 seconds after the `create-synced-table` call, and a re-snapshot ran in about 33. The gold table behind it, in the session's [public script](https://github.com/Fabric-Pro/fabric-databricks-usergroup), is a product catalog of eight rows. Those 51 seconds were the managed pipeline provisioning and starting, with almost no data in them.

They tell you nothing about the question a team with a 500-million-row gold table actually has, which is what happens to the application's own queries while that table lands in Postgres.

That's the question LTAP Direct Writes is built to answer. LTAP's claim, set out in the [LTAP chapter](https://databricks.techfabric.com/guide/ltap/), is transactional and analytical work on one copy of the data with the two kinds of compute kept apart. Most of that is architecture you can't time. A synced table's load is the one place today where the analytical side pushes a large volume of data into the transactional side, and Direct Writes changes exactly that path.

## Two ways a synced table gets loaded

Without Direct Writes, the initial load (and every refresh in SNAPSHOT mode) goes in through the branch's Postgres compute endpoint, the same endpoint serving your application. That's the old HTAP problem in miniature, with a bulk write and your latency-sensitive queries competing for one machine. With it, the load is written to the storage layer behind the branch and the endpoint mostly sees a commit at the end.

```mermaid The load path Direct Writes changes: bulk pages go to storage beside the endpoint, and the primary only publishes the result
flowchart TB
  G[(Gold Delta table)] --> S[Sync pipeline<br/>Spark executors]
  S -->|without Direct Writes:<br/>rows through the endpoint| E[Postgres compute endpoint<br/>also serving the app]
  E -->|normal inserts| T[Synced table visible]
  S -->|with Direct Writes:<br/>Postgres pages and PK index built in Spark| ST[(Branch storage)]
  S -->|manifest| E
  ST -.->|staged pages| T
  E -->|one compact WAL record,<br/>atomic swap| T
  APP[Application queries] --> E
  class ST accent
  class E quiet
```

Databricks' [engineering post](https://www.databricks.com/blog/load-terabytes-data-minutes-lakebase-postgres) of 8 October says Spark builds the Postgres heap pages and the primary-key index on its executors and writes them to storage, after which the primary records the import as one compact WAL record and swaps the staged data in. It claims loads "up to 147x faster", from an internal 1 TB benchmark of heap-page building alone. We'd treat that as the vendor's best case and plan on our own number.

## What the documentation says it covers

Databricks' own pages still called Direct Writes a beta on 15 October 2026. The [synced tables documentation](https://docs.databricks.com/aws/en/oltp/projects/sync-tables) is clearer than the original release note, and three details change how we'd use it. It's opt-in per synced table, a checkbox under Synchronization settings when you create the table, and it can't be added to an existing one, so using it there means deleting the synced table and creating it again. On a table an application already reads, we'd build the replacement beside it and cut over, because the delete takes the Postgres copy with it. It needs a project on Postgres 16, 17 or 18, where the August release note said 17 only, so a project written off for being on 16 is back in scope. And the gain depends on the sync mode. Every mode gets a faster initial load, SNAPSHOT gets it on every refresh because each refresh is a full load, and TRIGGERED and CONTINUOUS get nothing after the first load, because later changes arrive incrementally through the change data feed.

So for a large table that refreshes nightly as a snapshot, Direct Writes speeds up every run and keeps it off the application's endpoint. For a table on CONTINUOUS, it buys one faster first load. For an eight-row catalog like the one at Gilbert there's nothing to gain, since provisioning the pipeline is most of the time.

The same page sets out what a sync costs around it. Each sync uses up to 16 connections to the Lakebase database, against the 1,000 concurrent connections Lakebase Postgres supports, and CONTINUOUS mode runs on a minimum 15-second interval. The connection figures are the ones we'd size an application's own connection pool against before adding synced tables to a busy branch.

## The test we'd run before believing it

The number we'd want first is whether the application's latency holds flat while a large load lands beside it. This is the measurement we'd make in a non-production workspace, and it takes an afternoon:

1. Create a Lakebase project on Postgres 17 with one branch, and pick as the SNAPSHOT-mode source the largest gold table an application of yours would plausibly read, ideally above 100 million rows.
2. Put a primary-key read in `lookups.sql` (`\set id random(1, 1000000)` then `SELECT * FROM app.orders WHERE id = :id;`) against a different table on the same branch. Connect `pgbench` with an OAuth token as the password and `sslmode=require`, and run `pgbench -n -c 8 -T <seconds> -l -f lookups.sql`, with `-T` long enough for a few minutes of baseline, the whole load and a margin. `-l` logs every transaction, and p50 and p99 per five-second bucket come from that log.
3. Create the synced table **without** Direct Writes in the Create synced table dialog, and time from submit to `SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE` by polling `databricks postgres get-synced-table` (the Gilbert script's `wait_synced_table` does this), with its own `pgbench` run alongside.
4. Delete the synced table and create it again from the same dialog **with** the LTAP Direct Writes checkbox, against the same source, and repeat both measurements.
5. Run one manual refresh of each (`databricks pipelines start-update <pipeline_id>`), with `pgbench` running, since SNAPSHOT refreshes are where the gain repeats.

That gives four timings, load and refresh with and without, and four latency traces. If the traces with Direct Writes stay flat where the ones without climb, the storage-layer argument has evidence behind it; if both climb, the endpoint is still doing work during the load and we'd keep large loads out of business hours whichever way the checkbox is set.

Raja Vemuri, who runs development at TechFabric, is running this measurement on one of our gold tables, and the four timings go on this note when they're in.

> **Our position**: Turn Direct Writes on for new SNAPSHOT-mode synced tables of any real size in non-production now, run the latency test above before relying on it in production, and don't expect anything from it on a CONTINUOUS table after the first load. For the wider LTAP decision the [chapter's](https://databricks.techfabric.com/guide/ltap/) advice stands: put new operational stores in Lakebase where an application and its analytics are designed together, and restructure nothing on the strength of a beta.

The parts of LTAP still to be shown are incremental sync latency and the cross-cloud recovery named alongside it. When a release note moves either, it belongs in this note as a dated update.
