Meet OceanBase AI Lakebase, the unified database for operational data, real-time analytics, and AI.

Explore ->

Meet OceanBase AI Lakebase, the unified database for operational data, real-time analytics, and AI. Explore ->

Why Financial Institutions Build on OceanBase

Sean Wong
Sean Wong
Published on November 18, 2026Updated on 2026-11-19
10 minute read
Key Takeaways
  • OceanBase was built as a natively distributed system from day one, which is what lets it guarantee RPO = 0 and RTO under 8 seconds, with no idle standby and no DBA on call for failover.
  • More than 400 financial institutions, including nearly 70% of China's trillion-asset-scale banks, run core systems on it, with transactions and real-time analytics sharing one engine and one copy of the data.
  • On the AI side, DataPilot builds a business ontology from existing data, so an agent can answer "should this loan be approved?" and show where every number came from.

If you run a core banking or insurance system, speed is rarely what keeps you up at night. What matters is how the database behaves when something breaks, and how much you pay every month to make sure it behaves. Nobody in this business gets credit for being approximately correct. A payment settles or it doesn't.

I spent more than fifteen years at China Ping An Group, running the database department that served every subsidiary in the group: property, life, health and pension insurance, banking, securities, fund and asset management. In my last two years there I moved a lot of databases onto OceanBase, from Oracle, MySQL, PostgreSQL and TiDB. Then I moved myself and joined OceanBase. So I've now seen this platform from the customer's chair and from the vendor's. What follows is the path I've watched financial institutions take, starting with modernizing the core and ending somewhere newer: a data foundation that AI can actually work with.

The cluster is the database

When people hear "distributed database," many picture a traditional database with sharding or replication added on top. OceanBase isn't that. It was designed as a distributed system from the start, so there is no single machine that "is" the database. The database is the cluster, a set of nodes spread across physical machines. Nearly everything I describe below, from failover to scaling to cost, traces back to that one decision.

It's also multi-model. Relational SQL, key-value, vector, JSON, geospatial, full-text and graph all live in the same engine, so you operate and secure one system instead of several. For a regulated business I'd boil the value down to four things: low latency, elastic scale, enterprise-grade security and cost efficiency. I don't say that as a slogan. In my experience those are exactly the four places where a core banking system either holds up or doesn't.

None of this is new technology looking for its first customer. The foundation has run at Ant Group for more than fifteen years, through Double Eleven traffic peaks and under financial-grade consistency requirements. It took first place in both TPC-C (May 2020) and TPC-H 30,000 GB (May 2021) at the time of audit. OceanBase now has more than 4,000 customers worldwide. Over 400 of them are financial institutions, and nearly 70% of China's trillion-asset-scale banks run their core systems on it, as do more than 30 central state-owned enterprises. Analysts have noticed too. OceanBase was the only Chinese vendor named a Strong Performer in The Forrester Wave™: Multimodel Data Platforms, Q2 2026, with top scores in criteria including multimodel transactional consistency, multimodel translytical capabilities and deployment flexibility. This year it also received the World Internet Conference Distinguished Contribution Award.

Zero data loss should be a guarantee

Most enterprises still run monolithic, centralized databases. When a node fails, the instance fails over to another machine, and some data may be lost. Note the word may. Ask a vendor of that architecture to guarantee zero data loss and listen to how carefully the answer is phrased.

Then there's the standby. It's fully provisioned, its CPU sits idle, it carries no workload, and it waits for a failure that hopefully never comes. You've paid for the hardware, the licence and the rack space, and on a normal day it does nothing at all. As insurance goes, that's an expensive policy with a poor payout.

OceanBase was built the other way round. High availability comes from Paxos-based multi-replica consensus across the cluster, so a transaction isn't committed until a majority of replicas have its log. That's why we can guarantee an RPO of zero and an RTO under eight seconds, whatever fails. No data loss, and service back in under eight seconds. Touch wood, we've never had to invoke that guarantee.

The part that saves money is that nobody has to step in. Failover is automatic from end to end, with no home-grown orchestration scripts and no DBA paged at three in the morning. Maintenance follows the same logic. Because the cluster has many nodes, you upgrade them one at a time while the business keeps running.

Scale out, scale back, and stop migrating

You can start small. A few nodes, even a single server, makes a valid cluster. When the data outgrows it, you add nodes to the same cluster without interrupting the business, and there's no practical ceiling, since clusters run to thousands of nodes.

It works in the other direction as well, which people tend to forget. Run a campaign and you add capacity. Once the peak passes (Double 11 is the obvious case), you take the nodes out and put them to work somewhere else. You hold capacity for as long as you need it instead of owning it forever.

Two things make that workable in practice. Data rebalances automatically when nodes join or leave, so nobody is hand-moving partitions and risking a mistake. And performance scales close to linearly: go from one machine to two and you support roughly twice the workload. Most platforms promise something softer, that things improve for a while until they don't. At Alipay, OceanBase handles 42 million queries per second in production, serving more than a billion users.

This is the part I care about most as a former customer. If the database scales, you stop migrating. The usual life of a growing system is a chain of migrations, each one its own project with its own budget and its own risk, and I've led enough of them to know none is as simple as the plan claims. With one database that grows with the business, that chain goes away.

Growth costs storage too, and OceanBase works on that in two steps. It first encodes column data based on patterns within each column, then compresses it with algorithms such as LZ4 and zSTD. In one example, 3 TB of raw data comes down to about 1 TB, roughly a two-thirds reduction. Some workloads see savings of 70 to 90 percent, though that depends heavily on the data and on what you're measuring. The other lever is multi-tenancy. Instead of every system carrying its own database and its own admin overhead, you consolidate them as tenants in one cluster. Some mid-market companies we work with have cut total cost of ownership by 30 to 50 percent this way.

Transactions and analytics on one copy of the data

The traditional setup for transactions plus analytics is two databases with a pipeline in between. Analytics waits for fresh data to arrive from the transactional side, and in a bank, that wait means decisions made on stale numbers.

OceanBase keeps both workloads in one engine. The storage engine holds data in row format for transactions and in columnar format for analytics, so there's no second copy, no table synchronization and no ETL job to babysit. There's simply nothing to wait for.

Putting both workloads in one cluster does create an obvious risk. They behave completely differently, and if they share resources carelessly, a heavy report will hurt your payment latency. You can't patch that noisy-neighbour problem in later; isolation has to be part of the database from the start. OceanBase isolates the two so they run side by side without stepping on each other.

One global bank we work with shows what this looks like in production. It runs active-active across regions, with both regions serving reads and writes, on four replicas and one arbiter spread over three data centres. If a data centre goes down, failover is automatic rather than a manual switch, with targets of RPO zero and RTO within eight seconds. The bank also consolidated its existing databases into two production clusters integrated with its enterprise environment, so the team manages far fewer databases in far fewer places. For me, that's what makes the case worth telling. Resilience and operational efficiency are usually traded against each other, and here the bank got both from the same architecture.

AI needs operational data, and context

Modernizing the core is half the job. The other half is making that data useful to AI, and I'd argue agentic AI in finance won't get far without trusted operational data behind it. For decades, databases have been systems of record. Agents need them to become systems of action.

That's the direction OceanBase is heading. It's evolving from a distributed database built for consistency, reliability, real-time processing and scale towards an AI data platform, deployable across cloud and hybrid environments. The data goes well beyond tables, from JSON to images, audio and video, and it can include open table formats such as Apache Iceberg, held in object storage and reached through supported catalogue and query capabilities. Processing widens as well. SQL stays central, but alongside batch jobs and ETL, AI applications need conversion, chunking, embedding and transcription, and our open-compute approach is designed to bring that work into the platform.

Even so, more formats and more tools don't give an agent what it lacks most, which is context. What does this data mean? How does the application use it? What is the user really asking? Answering those questions is the job of the context layer.

DataPilot gives agents the business meaning behind the data

Ask a general-purpose agent for a customer's total assets and it has no idea what "total assets" means at your bank. It doesn't know which tables to join, which filters apply, or which field maps to which business concept, so it guesses. Traditional Text2SQL approaches top out at around 80% accuracy on standard benchmarks. In banking, getting one answer in five wrong is not something you can live with.

DataPilot puts a semantic layer between the agent and the data, in the form of a business ontology built from your existing data. Total assets, total debt and the asset-debt ratio become defined business objects with explicit metric definitions. The link between a customer and a loan becomes a structured relationship the agent can follow. So when someone asks whether a loan should be approved, the agent calls the risk evaluation model, pulls the credit level, checks overdue history, and ties every piece of supporting evidence back to source data.

We've seen teams build analytical applications 4x faster, mostly because they stop rebuilding semantic models from scratch for every project. Credit analysis speeds up because the agent already knows where to look. And since every answer traces back to specific data points and definitions, it holds up when a regulator or an auditor asks how the conclusion was reached.

A more everyday example: an executive asks why the same metric shows three different values in three reports. Anyone who has worked in finance IT knows what comes next. Engineers trace ETL pipelines, compare mappings and field lineage, inspect joins and filters, and work out which calculation each report used. That can take days. DataPilot reuses the logic already sitting in those assets to build metric definitions and relationships, so the agent can explain where the numbers diverge and point to the calculations and source data behind each one.

None of this works without governance, and we don't skip that step. Business experts review the ontology and agree on the definitions before anyone uses it. When ETL logic changes, the process is designed to catch it, check with the business owner and update the context. You end up with consistent definitions, answers that come with evidence, and less manual work because existing logic gets reused. Honestly, I think that's the only kind of AI a bank should put in front of its decision-makers: one that can show its working.

Openness and deployment choice

Financial institutions want control over their foundational software and over where it runs, and they're right to. The OceanBase community edition is open source under the Apache 2.0 licence, with MySQL compatibility. The value goes beyond access to the code, because shared technology gives an ecosystem room to grow around it.

For enterprise deployments, OceanBase runs on-premises and on AWS, Microsoft Azure, Google Cloud, Alibaba Cloud, Tencent Cloud and Baidu Cloud, either on bare-metal servers or on Kubernetes with the OceanBase operator. MySQL and Oracle modes are both supported today, on x86 and ARM, subject to compatibility. For financial workloads, it manages data access, protects sensitive information and supports auditing to meet FSI requirements. That mix of flexibility and control is a big part of why institutions such as ICBC Asia, HSBC and Ping An trust it.

My advice to anyone evaluating a platform like this is simple. Check the deployment, compatibility and hardware options against your own requirements, and judge what runs today rather than what's on a roadmap slide.

Reliability first, then intelligence

For the past decade, the work has been about building a foundation that mission-critical workloads can trust. The next stage is bringing that foundation, its data and the business context around it into the AI era. We're early in that second part, and I expect it to move quickly.

If you'd like to test the first part yourself, the community edition on GitHub is a good place to start. Spin up a cluster, point a MySQL application at it, then take a node down and watch what happens.

Share
X
linkedin
mail