At the first Gilbert Databricks User Group 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, 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, 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.
Databricks' engineering post 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 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:
- 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.
- Put a primary-key read in
lookups.sql(\set id random(1, 1000000)thenSELECT * FROM app.orders WHERE id = :id;) against a different table on the same branch. Connectpgbenchwith an OAuth token as the password andsslmode=require, and runpgbench -n -c 8 -T <seconds> -l -f lookups.sql, with-Tlong enough for a few minutes of baseline, the whole load and a margin.-llogs every transaction, and p50 and p99 per five-second bucket come from that log. - Create the synced table without Direct Writes in the Create synced table dialog, and time from submit to
SYNCED_TABLE_ONLINE_NO_PENDING_UPDATEby pollingdatabricks postgres get-synced-table(the Gilbert script'swait_synced_tabledoes this), with its ownpgbenchrun alongside. - 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.
- Run one manual refresh of each (
databricks pipelines start-update <pipeline_id>), withpgbenchrunning, 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.
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.