Databricks Unveils Serverless Postgres With Cross-Cloud Failover

Inside Lakebase: fully-managed serverless Postgres – Nikita Shamgunov, VP, Engineering, Databricks — Databricks

Databricks

Decoupling Postgres compute from data lake storage is necessary to deliver the sub-second branching and automated cross-cloud disaster recovery required by autonomous AI agents.

AI-assisted summary of Inside Lakebase: fully-managed serverless Postgres – Nikita Shamgunov, VP, Engineering, Databricks — original source. Check the original for full context.

Source published:

Key ideas

  • Databricks has launched Lakebase, a fully-managed serverless Postgres platform built to power the surge of AI-generated applications and autonomous agents by decoupling compute from lake storage. (1:53)
  • To overcome the inherent latency and consistency limitations of object lakes, Lakebase splits intermediate storage into Paxos-driven Safekeepers for writes and low-latency Page Servers for reads. (1:53)
  • The platform provisions compute instances and branches complete databases in under 500 milliseconds, featuring automatic scale-to-zero and instant snapshot rollbacks for agent sandboxing. (3:44)
  • In TPC-C benchmark testing, Lakebase sustained over 600,000 operations per second with sub-10ms latencies, comfortably outpacing major incumbent cloud databases. (6:03)
  • Lakebase introduced fully-managed cross-cloud disaster recovery between providers like AWS and Azure, surpassing 3,500 enterprise customers within its first year. (7:44)

Detailed notes

## Background Published by Databricks on YouTube on June 24, 2026, this keynote session from the Data + AI Summit 2026 features Nikita Shamgunov, VP of Engineering at Databricks. The presentation details the architecture and features of Lakebase, a fully-managed, serverless Postgres database designed to support AI applications and autonomous agents with built-in cloud disaster recovery.

## TL;DR Addressing the surge of AI-generated software, Nikita Shamgunov introduces Lakebase, a serverless, decoupled Postgres database tailored for modern agents and mission-critical enterprise workloads. Databricks split Postgres compute from storage by engineering intermediate consensus safekeepers and page-serving nodes backed by lake storage, enabling sub-500ms provisioning, scale-to-zero, instant branching, and quick snapshot-restores. In TPC-C benchmark testing, Lakebase sustained over 600,000 operations per second with sub-10ms latencies, well outperforming legacy cloud competitors. The system also introduces fully-managed cross-cloud disaster recovery, allowing seamless failover between major cloud providers like AWS and Azure.

## Atmosphere & style The presentation carries the brisk, authoritative momentum typical of a flagship tech summit keynote, blending ambitious industry forecasting with deep infrastructure architecture. Shamgunov speaks with confident precision and enthusiasm, shifting smoothly from the macro realities of AI code generation to the technical mechanics of Paxos consensus and page servers. The delivery is focused and persuasive, punctuated by clear visual architectural diagrams and performance charts that frame Lakebase as an indispensable pillar for the next era of computing.

## Bulletin - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Databricks has launched Lakebase, a fully-managed serverless Postgres platform built to power the surge of AI-generated applications and autonomous agents by decoupling compute from lake storage. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) To overcome the inherent latency and consistency limitations of object lakes, Lakebase splits intermediate storage into Paxos-driven Safekeepers for writes and low-latency Page Servers for reads. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) The platform provisions compute instances and branches complete databases in under 500 milliseconds, featuring automatic scale-to-zero and instant snapshot rollbacks for agent sandboxing. - [06:03](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=363s) In TPC-C benchmark testing, Lakebase sustained over 600,000 operations per second with sub-10ms latencies, comfortably outpacing major incumbent cloud databases. - [07:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=464s) Lakebase introduced fully-managed cross-cloud disaster recovery between providers like AWS and Azure, surpassing 3,500 enterprise customers within its first year.

## Key takeaways - [00:05](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=5s) Software engineering is undergoing an AI transition, with more code projected to be generated over the next year than in all prior human history. - [00:05](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=5s) Next-generation autonomous agents and AI applications impose three essential database requirements: ecosystem familiarity, infrastructure nimbleness, and mission-critical reliability. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) PostgreSQL was selected as the engine of choice because its open-source adoption and vast web presence make it uniquely familiar to AI agents. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Monolithic Postgres couples compute and storage, making it ill-suited for cloud-native agility without a fundamental architectural decoupling. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Persisting operational database data directly into data lakes resolves storage costs and scale, but introduces latency and transactional consistency challenges. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Databricks introduced Safekeeper nodes running the Paxos consensus protocol to guarantee low-latency writes and ACID consistency on top of lake storage. - [01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Page Servers act as an intermediate caching layer that serves requested database pages directly to decoupled compute instances with ultra-low latency. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) Postgres compute instances can be spun up in less than 500 milliseconds and automatically scale to zero when idle to prevent runaway cloud bills. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) Instant branching enables engineers and agents to spin up fully isolated sandboxes for testing and pull requests in under 500 milliseconds. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) One-click snapshot and restore capabilities provide a safety net against destructive schema alterations or data corruption introduced by autonomous agents. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) Dynamic autoscaling lets administrators configure minimum and maximum compute error bars, adjusting capacity automatically between peak hours and off-peak periods. - [03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) Direct persistence to lake storage delivers infinite capacity, entirely eliminating manual disk expansion and out-of-space operational incidents. - [06:03](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=363s) In TPC-C benchmark evaluations, Lakebase scaled past 600,000 operations per second while preserving transaction latencies below 10 milliseconds. - [06:03](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=363s) Incumbent cloud database offerings exhibited capacity plateaus or severe latency spikes well below Lakebase's throughput ceiling. - [07:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=464s) As enterprises automate operational workflows with agents, single-cloud vendor outages become potentially catastrophic single points of failure. - [07:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=464s) Lakebase provides the first fully-managed cross-cloud disaster recovery, supporting active replication and instant failover between clouds such as AWS and Azure. - [08:57](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=537s) Over 3,500 enterprise customers adopted Lakebase for mission-critical production workloads within its first year of release.

## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=5s) What Next-Generation AI Applications and Agents Require from a Database

Software development has undergone a fundamental shift: code is increasingly being generated by artificial intelligence rather than handwritten by human developers. Reflecting on the momentum from early 2026, Nikita Shamgunov observes: “And now we can confidently say we're going to have more software generated in the next year than in the history of humanity.” Yet despite this automated deluge, the core architecture remains rooted in fundamental infrastructure: every application still requires a database.

Next-generation AI applications and autonomous agents impose three non-negotiable requirements on their operational databases: - **Familiarity**: Agents operate significantly better when interacting with platforms they understand through their web crawls of internet forums, Stack Overflow, and Reddit. The database needs to be open source, widely adopted, and extensible so organizations can consolidate diverse primary and niche workloads onto a single platform. - **Nimbleness**: To accommodate the flood of AI-generated applications, testing, staging, and development environments, systems must be fully serverless, support instant branching for agent isolation, and maintain strict cost-effectiveness at volume. - **Mission-Critical Reliability**: Operational systems run core business logic. They must offer infinite scalability, low-latency performance, and enterprise-grade reliability.

[01:53](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=113s) Decoupling Postgres and Re-Architecting Storage for the Lake

To build on a proven standard, Databricks selected PostgreSQL, recognized as the world's most advanced open-source database, with an unmatched extension ecosystem and ubiquitous agent familiarity. However, standard Postgres is a traditional monolithic database where storage and compute are tightly coupled. To make it nimble and cloud-native, Databricks had to decouple compute from storage and move the persistence layer directly into the data lake.

Moving operational storage to data lake storage is notoriously challenging. While lake storage is inexpensive and easily scalable, it is inherently slow and transactionally inconsistent. To reconcile standard Postgres ACID guarantees with lake persistence, Databricks split the storage layer into two purpose-built intermediate services: - **Safekeepers**: Dedicated write-path consensus nodes that implement the Paxos consensus protocol to guarantee low-latency writes and strict transactional consistency. - **Page Servers**: Dedicated read-path caching and retrieval nodes designed to serve requested database pages directly to Postgres compute instances with ultra-low latency.

The combination of this decoupled architecture, Paxos consensus write nodes, page-serving read nodes, and underlying lake storage constitutes **Lakebase**: a fully-managed serverless Postgres platform.

```mermaid flowchart TD accTitle: Lakebase Decoupled Architecture accDescr: Diagram showing the decoupled compute, consensus safekeepers, page servers, and lake storage layers of Lakebase.

subgraph ComputeLayer["Compute Layer"] PC["Postgres Compute Engine"] end

subgraph ServiceLayer["Storage Intermediate Services"] SK["Safekeepers (Paxos Consensus / Low-Latency Writes)"] PS["Page Servers (Page Serving / Low-Latency Reads)"] end

subgraph StorageLayer["Persistence Layer"] Lake["Lake Storage (Cost-Effective / Infinitely Scalable)"] end

PC -->|"Write WAL / Transactions"| SK SK -->|"Replicate & Persist"| Lake PC -->|"Request Data Pages"| PS PS -->|"Fetch / Cache Data"| Lake ```

[03:44](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=224s) The Transformative Capabilities of Lakebase

By decoupling compute and storage, Lakebase achieves operational speeds and lifecycle controls tailored directly to AI agent workflows. Postgres compute instances can be provisioned in under 500 milliseconds. To prevent runaway cloud expenditures across dozens of ad-hoc environments created per GitHub pull request, Lakebase automatically scales compute to zero, shutting down inactive instances when not in use.

Shamgunov highlights two database patterns essential for agentic workflows: - **Instant Branching**: Any database can be branched within 500 milliseconds, allowing engineers or autonomous agents to spawn isolated sandbox environments for dev, test, or staging without manual cloning. - **Instant Snapshot and Restore**: Developers or pipelines can take a snapshot via a single API call or mouse click before delegating a task to an autonomous agent. If the agent makes improper schema adjustments or corrupts data, the entire database can be instantly rolled back to the prior snapshot.

From a mission-critical capacity standpoint, administrators only configure guardrail "error bars"—specifying minimum and maximum compute limits for budget and operational bounds. Lakebase automatically scales compute up during peak traffic hours and scales down over weekends and nights. Because storage resides directly in the lake, it is infinitely scalable, completely eliminating manual disk-expansion procedures and out-of-space alerts.

[06:03](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=363s) Industry Benchmarks and Fully-Managed Cross-Cloud Disaster Recovery

Operational database workloads require executing small, highly concurrent queries while sustaining minimal latencies. When tested against standard industry benchmarks such as TPC-C, Lakebase significantly outperformed incumbent cloud solutions: - **Cloud Vendor 1**: Reached capacity at roughly 130,000 operations per minute. - **Cloud Vendor 2**: Sustained operations up to approximately 350,000 operations per second before latencies spiked severely. - **Databricks Lakebase**: Maintained transaction latencies below 10 milliseconds per operation, scaling past 600,000 operations per second.

Beyond standard compliance, encryption, and enterprise security features, Shamgunov unveiled Lakebase's flagship capability: fully-managed cross-cloud disaster recovery. As businesses automate mission-critical operations with autonomous agents, outages at a single cloud provider can halt entire operations. Shamgunov notes: “Cloud outages don't happen every day. Uh but when they do happen, they're they're devastating to your business.”

To eliminate this vulnerability, Lakebase supports instant cross-cloud failover. Users can provision a primary Lakebase instance in AWS US West with an active replica hosted in Azure US East; in the event of an AWS outage, workloads instantly fail over to Azure to maintain uninterrupted business operations. Within one year on the market, over 3,500 enterprise customers have adopted Lakebase for their production workloads.

## Notable quotes > [00:05](https://www.youtube.com/watch?v=NqJIyP9rIW8&t=5s) And now we can confidently say we're going to have more software generated in the next year than in the history of humanity. — Nikita Shamgunov

## Mentioned AWS, Azure, Data + AI Summit 2026, Databricks, GitHub, Lakebase, Nikita Shamgunov, Paxos, PostgreSQL, Reddit, Stack Overflow, TPC-C

## Video description More software will be built in the next year than throughout the whole history of humanity. And every one of these new systems requires an database designed for AI.

It's why Databricks built Lakebase, a fully-managed, serverless Postgres database for AI apps and agents. At Data + AI Summit 2026, Nikita Shamgunov, VP, Engineering of Databricks, explained how the team re-architected Postgres and outlined the features that help Lakebase out perform industry rivals, including the first fully-managed cloud disaster recovery.

00:00 — How AI is changing software development 01:56 — The pros and cons of Postgres 02:28 — Re-architecting Postgres 03:45 — The transformative power of Lakebase 07:27 — Why Lakebase is ready for any workload 07:44 — The first fully-managed cloud DR 08:57 — Lakebase momentum

[Source](https://www.youtube.com/watch?v=NqJIyP9rIW8)

Reading summary

Nikita Shamgunov, Vice President of Engineering at Databricks, argues that the rapid rise of AI-generated software and autonomous agents requires operational databases to provide open-source familiarity, serverless agility, and mission-critical reliability. To address these requirements, Databricks developed Lakebase, a fully-managed serverless Postgres platform decoupled into consensus-driven intermediate services and data lake storage. Database Requirements for AI Agent Workflows (0:05) As artificial intelligence increasingly writes code, Shamgunov asserts that more software will be generated over the coming year than in the entirety of human history prior to early 2026. This proliferation puts distinct operational burdens on underlying database infrastructure. Autonomous agents function most effectively when interacting with familiar, open-source systems like PostgreSQL, which are extensively represented in internet documentation, forums, and developer communities. Simultaneously, autonomous agents require highly nimble environments capable of supporting rapid testing, ephemeral staging branches, and strict budget controls without risking mission-critical performance. Meeting these demands requires an operational database capable of scaling to zero to minimize spend while sustaining the low latencies and reliability expected of core transactional systems. Decoupling Storage for Lake-Based Persistence (1:53) Standard PostgreSQL couples compute and storage tightly within a monolithic engine, restricting cloud elasticity. To modernize this foundation, Databricks decoupled Postgres compute from persistence, relocating the storage layer directly to data lake infrastructure. Because raw lake storage is inherently high-latency and transactionally inconsistent, Databricks introduced two intermediate services to preserve ACID compliance. The write path routes transactions through Safekeepers—dedicated consensus nodes utilizing the Paxos protocol to guarantee low write latency and transactional consistency before persisting to the lake. For the read path, dedicated Page Servers cache and retrieve requested database pages, serving them to Postgres compute engines with sub-millisecond responsiveness. Lifecycle Controls and Guardrails for Agents (3:44) The decoupled Lakebase design enables Postgres instances to boot in under 500 milliseconds and automatically scale compute to zero when inactive, curtailing infrastructure expenses across pull-request environments. Database branches can also be created in under 500 milliseconds, allowing human engineers and autonomous agents to isolate environments for development, testing, and staging without performing slow manual clones. To manage the risks of delegating operational tasks to AI, Lakebase incorporates single-call instant snapshot and restore capabilities. If an agent executes an erroneous schema migration or corrupts data, operators can roll back the database instantly. System capacity is managed through administrative guardrails, where users define minimum and maximum compute limits while Lakebase handles dynamic workload scaling and infinite storage expansion. Performance Benchmarks and Cross-Cloud Recovery (6:03) In TPC-C industry benchmark evaluations, Shamgunov reported that Lakebase sustained transaction latencies under 10 milliseconds while scaling beyond 600,000 operations per second. By comparison, Databricks measured two incumbent cloud vendor offerings topping out at roughly 130,000 operations per minute and 350,000 operations per second before latencies degraded. Addressing the operational risks of single-cloud outages, Lakebase includes fully-managed cross-cloud disaster recovery. Workloads provisioned on a primary instance in AWS can maintain an active replica in Azure, allowing automated failover between providers during outages. According to Databricks, more than 3,500 enterprise customers deployed Lakebase for production workloads within its first year on the market. Lakebase demonstrates how re-architecting PostgreSQL around distributed consensus layers and data lake storage can accommodate agentic workflows, though production success across its 3,500 enterprise adopters depends on maintaining predictable sub-10-millisecond latencies across complex multi-cloud deployments.

Source quotes

[0:05] Nikita Shamgunov: And now we can confidently say we're going to have more software generated in the next year than in the history of humanity.

Original transcript

[0:05] Thanks to AI, [0:07] we now generate software. We're not [0:09] writing it by hand. [0:11] And we're looking at the trends for the [0:12] first 6 months of year 26. And now we [0:15] can confidently say we're going to have [0:18] more software generated in the next year [0:21] than in the history of humanity. [0:24] And every application still needs a [0:27] database. [0:29] So, [0:30] what do next-generation application and [0:32] agents need from a database? [0:36] So, the first thing is it needs to be [0:39] familiar. [0:40] And the reason to that is the more [0:42] agents know about the systems, and they [0:44] know by scanning the internet and [0:46] scanning all the Stack Overflow forums [0:48] and Reddit, the better they are at [0:50] running and operating it. So, it needs [0:52] to be open source. [0:54] It needs to be popular, and it needs to [0:56] be extensible, so you can consolidate [0:58] all your main and also niche workloads [1:01] on the single database platform. [1:04] It also needs to be nimble. [1:07] With this onslaught of applications that [1:09] are coming at us and all their various [1:11] dev, test, and staging environments, [1:13] uh the system needs to be serverless, [1:16] and it needs to be branchable, so you [1:17] can easily create environments for your [1:20] agents in which they can safely operate. [1:23] And finally, as you run those things at [1:25] scale and at volume, uh it needs to be [1:28] cost-effective. [1:30] The final thing it needs to be [1:31] mission-critical. Operational databases [1:34] run your business. And so, [1:36] um that means is it needs to be [1:38] infinitely scalable, it needs to be [1:40] fast, and it needs to be extremely [1:42] reliable. [1:45] So, [1:47] familiar, [1:49] nimble, [1:50] and mission-critical. [1:53] So, we decided to start with Postgres, [1:55] the most advanced open source database [1:57] in the world. [1:59] It has a largest [2:01] uh ecosystem in the world and also lots [2:03] and lots of extensions. Again, you can [2:05] consolidate all your additional [2:07] workloads to the main one, to the [2:09] operational database system one, into [2:11] the platform. [2:13] It's also open-source and understood by [2:15] every agent on the planet. [2:18] But Postgres is a monolith. [2:20] And the compute and storage in the [2:22] monolith are tightly coupled. So, if you [2:25] want to make it nimble, [2:27] um you need to do something. You need to [2:28] re-architect that system. [2:32] The main idea we had is we can decouple [2:34] storage and compute and move storage [2:37] into the lake. [2:39] But it's actually, you know, much harder [2:42] than you might think. [2:43] And so, for that, we need to [2:45] re-architect storage from the ground up. [2:48] The lake storage is, you know, has a lot [2:51] of very, very good properties. It's [2:52] inexpensive. It's very easy to scale. [2:55] But it's also slow and transactionally [2:57] inconsistent. [2:59] So, as we are rebuilding [3:01] uh the storage for Postgres to run it on [3:03] the lake, we had to introduce two [3:05] additional services, one for reads and [3:07] one for writes. [3:09] For writes and transactional consistency [3:11] consistency, [3:13] uh we built safekeepers. They implement [3:15] a consensus protocol called Paxos. [3:17] So, they give you low latency writes. [3:19] And then, we introduce another service [3:21] called page servers that serve pages to [3:24] Postgres compute. Those systems are [3:26] called page servers and they deliver on [3:28] low latency reads. [3:30] Then, we put it all together and [3:32] integrate with the lake. [3:33] And that gives us uh [3:35] Lakebase. [3:36] The fully managed serverless Postgres [3:39] that runs on the lake. [3:44] So, what does Lakebase give us? [3:46] Well, um it certainly is nimble, right? [3:50] So, we can provision Postgres in under [3:52] 500 milliseconds. And as you have lots [3:55] and lots of developer [3:57] staging [3:59] environments for every potentially PR [4:01] that you you want to move into GitHub, [4:03] um we can scale it also to zero, right? [4:06] So, with lots and lots of environments [4:09] and they're serverless, we need to [4:11] deliver on TCO. So, we automatically [4:13] shut down environments that you don't [4:15] use. [4:18] We introduced two more patterns that are [4:21] incredibly useful in this new agentic [4:22] world. The first one is branching. Every [4:25] Postgres database you can [4:28] easily branch, and it also branches in [4:30] about 500 milliseconds. So, you can [4:33] create an additional environment for you [4:35] to create dev, test, or staging. [4:38] Another another pattern that kind of [4:40] emerged in that agentic development is [4:43] uh snapshot restore. [4:45] With any with a simple mouse click or an [4:47] API call, you can snapshot your [4:49] database, then unleash your agent to do [4:52] work [4:53] uh to build some software, change the [4:55] schema, change the data, whatever. Uh if [4:57] the work is to your liking, you can [4:59] proceed. If not, you can instantly roll [5:02] back to the previous snapshots. [5:06] So, now uh it's built for agents, but is [5:09] it mission-critical? Can it support your [5:11] business? [5:13] Let's start with scalability. [5:15] With Lake Base, all you need to set is [5:18] uh error bars for your compute. You can [5:20] say, "Well, don't scale my compute below [5:23] this minimum or over that maximum." And [5:25] you want to do it for potentially cost [5:27] controls. But within two those error [5:30] bars, you actually can [5:32] uh scale up and down automatically [5:36] um as your workload changes. So, we'll [5:38] scale the system up at your peak hours, [5:41] scale things down um at maybe on [5:44] weekends or nights. [5:47] Storage, of course, is on the lake, and [5:49] that gives you infinite scalability. You [5:52] will never run out of storage, and you [5:54] will never run out you will never need [5:56] to run management operations if you're [5:58] approaching, you know, your disk size or [6:00] whatever. [6:03] So, now you might be wondering though, [6:06] so you change the architecture of [6:08] Postgres at the storage level. [6:11] So, is it fast? [6:13] How does it compare with the industry [6:15] implementations of Postgres as a [6:17] service? [6:18] So, this is a very similar [6:20] graph to what Rail is showing for Aiden [6:23] where we're measuring latency as we [6:25] scale throughput. [6:27] Obviously here, it's an operational [6:29] system. So, it runs much smaller queries [6:32] that in analytical systems, but they run [6:34] it at at very high concurrency. [6:37] And we're comparing it with [6:39] the first cloud vendor, which is quite [6:41] popular. And that cloud vendor taps out [6:44] about at about 130 [6:46] operations per minute. And by the way, [6:49] we're running a a fairly standard [6:50] industry benchmark called TPC-C. [6:53] Another cloud vendor with slightly [6:55] different architecture was able to push [6:59] its throughput to about 350,000 [7:02] operations a second, but after that, of [7:04] course, latencies started to spike as [7:06] well. [7:08] And I'm very excited to to to showcase [7:10] some of the incredible performance work [7:12] that we've delivered, and Lake Base can [7:14] scale under 10 milliseconds for each [7:17] transaction for each operation all the [7:19] way north of 600,000 operations per [7:23] second. [7:26] Lake Base is is ready for [7:29] almost any workload. [7:31] Mission critical also means a lots of [7:33] features, right? And those features are [7:35] security, compliance, encryption, you [7:39] name it, and we have it. [7:41] But I also wanted to showcase something [7:44] that we are in a very very unique [7:46] position to deliver on. [7:48] So, cloud outages don't happen every [7:51] day. [7:52] Uh but when they do happen, they're [7:54] they're devastating to your business. [7:56] And now that a lot of your business is [7:59] increasingly automated and run by agents [8:01] themselves, [8:02] cloud outages could could be really [8:04] really disruptive to your operation. [8:08] So, I'm incredibly excited [8:10] uh [8:11] to introduce [8:13] first fully managed cross-cloud disaster [8:16] recovery. [8:19] >> [applause] [8:23] [applause] [8:24] >> This is what we mean by truly [8:25] mission-critical. [8:27] With fully managed cross-cloud disaster [8:29] recovery, you can set up your system to [8:31] run cross-clouds. So, you can provision [8:35] Lake Base, let's just say US West [8:39] AWS, [8:40] and then a a replica US East Azure. [8:44] And in the case of AWS outage, you can [8:48] instantly fail over from one cloud to [8:51] another and continue your uninterrupted [8:53] business operations. [8:56] So, this is Lake Base. [8:58] It's fully managed serverless Postgres [9:00] that runs on the lake and it is [9:02] mission-critical. [9:04] We've only been on the market for a [9:06] year, [9:07] but we already have over 3,500 [9:10] enterprise customers that trust us with [9:12] their mission-critical workloads. [9:15] >> [music]