How Built Turns Microservices into Live Context
"With Materialize, SQL is the primary language, so our whole team can work on our real-time pipelines. We trust our metrics, and we can verify every change before we deploy it. That gives us the confidence we need to move faster."

Executive summary
Built is the AI-first real estate and construction finance platform. Lenders, owners, developers and general contractors use it to fund and manage projects, and more than $300 billion in capital is managed on it. Behind the app is a microservices architecture, and the inputs to the numbers lenders care about most don’t live in any one service. A debt-service coverage ratio, for example, combines property cash-flow calculations with loan balances, interest rates and repayment terms maintained across separate services. Some balances are themselves calculated upstream from payment activity. Materialize joins those inputs to calculate annual debt service and determine how well the property’s income covers it.
Built first computed those metrics in Apache Flink jobs. This worked, but it had drawbacks that surfaced as Built’s team and business grew:
- Only a small set of people could change the jobs or review a change.
- The middle of the pipeline was a black box when something broke.
- Deploys had grown to roughly 8 hours. Every change was expensive, so the pipeline slowed down everyone who depended on it.
To keep up with demand, and to get its data into a shape that would support its broader agent and API strategy, Built moved the work to Materialize.
Events from each DynamoDB- and MySQL-backed service arrive through Kafka. The joins and the formulas required to respond to APIs are SQL views that Materialize keeps current as the data changes. Consolidated documents go out to the Elasticsearch indexes the app already reads.
The biggest change among Built’s platform team is who can do the work. Any engineer or agent who can understand SQL can now follow a calculation step by step, review a pull request against business logic they know, and check the result in an ephemeral environment before it merges. Deploys take about six minutes and go out blue/green with zero downtime inside Materialize, and the team can query old and new versions side by side before they switch to confirm correctness. Engineers who were not able to work on the Flink code have shipped changes to the Materialize project several times.
Built is extending the same pattern to its payments and receivables grid. Early proof-of-concept results showed page loads falling from 20–40 seconds to about a second.
Overview
Built started more than ten years ago focused on fixing construction lending. It has since grown to cover the whole real estate lifecycle, from origination to asset management. More than 340 lenders and 78,000 owners and contractors work on Built, and 45 of the top 100 US banks trust it.
Construction loans pay out in stages. When a builder finishes a phase, they ask the lender for the next draw, whether that’s $200,000 or $2 million, to start the next piece of work. Before money moves, someone has to inspect the work, collect proof of completion, and approve each step. Built runs that workflow, including with its AI Draw Agent.
Along the way, lenders need to know how healthy each loan is. That means financial calculations, and in lending the numbers have to be exact. “We’re a fintech company. We need precision,” says Joe Buszkiewic, the Sr. Staff Engineer on Built’s platform team.
The data behind those calculations is spread out across siloed operational databases. Property cash-flow calculations, loan terms and balances, and interest-rate indexes are maintained across separate services. Some balances are themselves calculated upstream from payment activity.
“We have to cross domain boundaries in order to calculate these. And so there’s not a natural place from an API perspective. And there’s a bunch of math. There’s a bunch of things that databases are really good at, but when joining across services we’d have to figure it out in the app tier.”
The result has to show up inline in the app, so building these pipelines in a lakehouse or warehouse is not feasible.
“These things have to be real time because you’re seeing it either on a project listings page, or you click through and you see it with the rest of the data that it lives next to.”
Challenges with their original Flink pipeline
A pipeline only a few people could touch
Initially the calculation pipeline was built as Flink jobs, which needed to be managed by specialized talent.
The practical effect was a bottleneck. Changes to business logic and reviews of those changes had to go through a narrow group of people.
A black box in the middle
When a calculation came out wrong, finding the cause was slow and tedious.
“It became a black box. We have inputs, we have outputs, and what’s happening in the middle is all static analysis from our perspective. We can trace through the code, but we can’t see any of the data in between.”
Deploys that took most of a working day
As Built grew and pushed more features through the pipeline, build and deploy times kept climbing.
“When we switched over and turned it off, it was running about eight hours for a deployment, up to 10 in some environments. It was crazy.”
An eight-hour deploy also means an eight-hour rollback, so every release was a big event. Slow deploys made the bottleneck worse: fewer releases, and more riding on each one.
Why Materialize and how Built uses it
Fast, flexible pipelines
In Flink, a change to the calculation logic meant building, packaging and redeploying jobs, and that took longer with every feature Built added.
In Materialize, a change to the logic is a change to a SQL view. There’s nothing to compile or package. A new or changed view builds its state from data Materialize already holds in its own storage layer, and Materialize’s docs note that this “does not read from the upstream system”. Nothing has to be replayed from Kafka or the source services.
Blue/green deployment makes the change safe. The new version of the views builds next to the live one while the live one keeps serving, and it’s swapped in once it has caught up, with no downtime. Rolling back is the same move in reverse.
Exact numbers
Precision was a hard requirement. Another streaming database was ruled out before a proof of concept because it couldn’t hold Built’s decimal values at the precision the calculations need. Materialize’s numeric type holds 39 digits of precision, with a scale the team sets (numeric type docs).
SQL anyone on the team can read
Materialize keeps SQL views current as the underlying data changes, using incremental view maintenance (docs). Every step of a calculation is a view, and every view can be queried. That fixed the black box, and it meant the logic was written in a language the whole engineering team already speaks.
Reference architecture

- Sources. Built’s services write to MySQL and DynamoDB and publish change events to Kafka through transactional outboxes and existing change-data-capture pipelines.
- Ingest. Materialize reads those Kafka topics continuously (Kafka source docs).
- Transform. SQL views join data across service boundaries and run the calculations. Materialize keeps them current as new events arrive.
- Serve. Results leave Materialize as change events through a Kafka sink (Kafka sink docs), and a Lambda function loads them into Elasticsearch, which internal and external applications already read from (Elasticsearch pattern docs).
Materialize takes about 1 second from source to sink. Loading into Elasticsearch adds roughly another second, so a change shows up in the app in a few seconds end to end.
Every change reviewable, every result checkable
Built’s Materialize project lives in git like the rest of its code. Each pull request gets an ephemeral environment: a brand new database with that PR’s changes, where the author and the reviewer can query the result before merging.
That changes who can review. Joe can send a PR that reimplements a piece of business logic to whoever knows that logic best, whether or not they’ve worked on streaming before.
“It evens the playing field for all of development, and not just a super narrow subset where only these people can review your code.”
Deploys measured in minutes
“Long and short of it is we went from an eight hour deployment to a six minute deployment once we got to Materialize. It’s super fast, which also means rollbacks are super fast. We can release constantly.”
Inside Materialize, Built runs blue/green deployments with zero downtime. Built still schedules releases off hours. The reason sits downstream: a large change can produce a burst of events, and the Lambda that loads Elasticsearch can fall 10 to 15 minutes behind while it catches up.
Expertise on tap from Materialize’s MCP server and Agent skills
Built didn’t need a Materialize expert in house to tune its views. Most of the optimizations came from Materialize’s own AI tooling: the developer MCP server, which lets a coding agent read the system catalog and EXPLAIN output (developer MCP docs), and Materialize’s open source skills for coding agents (skills docs).
“Part of how we found this and fixed this was through Materialize’s AI. The MCP and the skills played a big part in us being able to find these things, make the changes, and validate them.”
The team used Materialize’s developer MCP server and agent skills to inspect query plans and identify unnecessary memory use. Adding group-size hints to deduplication and aggregation queries reduced arrangement memory from 20 GB to 9.4 GB, a 53% reduction in a sandbox using production data.
Real-time calculations across services
The first production workload calculates financial metrics across services, including debt-service coverage, loan-to-value and debt yield, with variations for individual funding sources and the overall capital stack. Joins and math that used to be spread through Flink code now sit in SQL the team can read, query and review.
A payments and receivables grid
The next workload followed the same pattern. Built’s payments and receivables grid searched Elasticsearch for matching packets, then assembled the displayed rows through application-tier reads across 10 to 12 services.
The new approach moves that assembly into Materialize, combining deal and project details with payments, approvals and related records into consolidated search documents. Early proof-of-concept results showed page loads of about a second, compared with 20–40 seconds previously.
“Now that page loads in about a second. It’s very, very fast.”
Results
More of the team ships live context
The work that used to sit with a few Flink specialists is now open to the engineering team. Engineers who never touched the Flink code, or any streaming system, have pushed PRs to the Materialize project several times. A review can go to whoever knows the business logic best.
“We’ve had team members who never touched Flink push PRs to Materialize.”
Confidence turned into speed
Deploys went from hours to about 6 minutes, and rollbacks went the same way. Joe ties the speed to being able to see what a change does before it ships.
“Being able to see the impact of changes before they are promoted to production is amazing. It’s really hard to get that in Flink. The more we can have confidence in what is happening, the faster we can move, the faster we can ship.”
One pattern for any question that crosses services
“Materialize gives us a simple platform for aggregating across microservice domains.”
The calculations were the first case and the payments grid is the second. A third is taking shape: usage metrics on Built’s API.
Built wants to roll API usage events up by tenant and user, then later by action (reads versus writes) or by path. In DynamoDB or MySQL, each new grouping means more tables, hot and cold storage, and jobs to keep counts from doubling. In Materialize, each one is another materialized view over the same stream (materialized view docs). Built also plans a second stream for allowances, so the system can tell a customer they’ve gone over their limit, and then that a new allowance puts them back under, as the events arrive.
What’s next
Live context for customer-facing agents. Built is building MCP servers its customers can use. Some context an agent can retrieve from Built’s APIs today, such as which projects have a due date or an approval coming up soon. Other context requires more complex queries, for example to find which deals are high risk because a contract phase is 90 days overdue. Today those come from batch pipelines that run at least two hours behind. Built is exploring Materialize to turn operational data into analytics views, possibly writing them out to Iceberg as well (Iceberg sink docs, public preview), and putting agents in front of them.