Built Technologies uses Amazon Bedrock and AWS Intelligent Document Processing to automate document-heavy real estate finance workflows, improve accuracy, and power agentic AI applications.
Real estate finance depends on a continuous flow of documents, including loan agreements, construction draw packages, invoices, insurance certificates, inspection reports, appraisals, and financial models. Reviewing these documents manually is slow, costly, and vulnerable to errors—especially when the information is spread across hundreds of pages and presented in inconsistent formats.
Built Technologies, a real estate finance software provider that supports more than $500 billion in real estate projects, developed an AI-powered document intelligence solution on AWS to address this challenge. Built on Amazon Bedrock and the AWS Intelligent Document Processing Accelerator, the solution can classify, split, extract, evaluate, and reason over more than 250 document types. It is designed to reduce workflows that previously required three to nine days to just minutes per document package. [aws.amazon](https://aws.amazon.com/blogs/machine-learning/built-technologies-builds-an-ai-powered-document-intelligence-solution-on-aws-to-power-agents-across-real-estate-finance/)
More importantly, the platform is not limited to one workflow. It acts as a reusable intelligence layer for agentic applications across construction lending, insurance, underwriting, compliance, asset management, and portfolio monitoring.
Real estate finance is not simply document-heavy; it is also highly contextual. A single transaction may involve hundreds or thousands of pages created by lenders, borrowers, contractors, insurers, appraisers, attorneys, and regulators.
These documents differ widely in structure and quality. Some follow standardized templates, while others contain:
- Scanned pages and handwritten notes.
- Nested tables and complex financial schedules.
- Embedded images, signatures, and stamps.
- Non-standard labels and borrower-specific terminology.
- Legal clauses distributed across multiple sections.
- Excel-based models and inconsistent formatting.
- Documents combined into large PDF packages.
A construction draw package, for example, may contain a cover letter, contractor invoices, lien waivers, inspection reports, insurance certificates, and payment applications—all merged into one file. Before the information can be reviewed, the system must first identify where one document ends and another begins.
Traditional document automation often struggles with this level of variation. Optical character recognition (OCR) can convert images into text, but text extraction alone does not explain what the information means or whether it satisfies a business requirement.
That distinction is critical in financial workflows. Extracting an insurance policy’s coverage limit is one task. Determining whether that coverage meets the requirements of a loan agreement is a much more complex one.
Earlier document-processing systems typically relied on OCR, templates, rules, and traditional machine learning. These tools work well when a document has a predictable layout and clearly labeled fields.
For example, an invoice processor may be able to identify:
- Invoice number.
- Vendor name.
- Invoice date.
- Total amount.
- Purchase order number.
However, the same approach becomes less reliable when information is implied or distributed across a lengthy document.
Consider loan covenants. A covenant may not appear under a heading called “Covenants.” Instead, it may be described through:
- Borrower obligations.
- Minimum financial thresholds.
- Restrictions on additional debt.
- Reporting requirements.
- Default conditions.
- Remedies for non-compliance.
A keyword search may locate the word “covenant,” but it may not identify the actual obligation or understand the consequences of a breach.
An agentic document workflow approaches the problem differently. It can interpret the document in context, identify relevant clauses, organize the information into a structured format, and provide evidence for human review.
1. Identify the document type and its overall structure.
2. Locate sections related to financial obligations and restrictions.
3. Detect covenant clauses even when they are not explicitly labeled.
4. Extract thresholds, reporting frequency, responsible parties, and effective periods.
5. Link each extracted value to the relevant page or passage.
6. Assign confidence scores to the results.
7. Escalate ambiguous findings to a subject matter expert.
This represents a shift from - text extraction - to - business-context comprehension -.
Built designed its document intelligence engine as a horizontal capability rather than a single-purpose tool. The initial production use case focused on commercial construction loan draw packages.
This was a demanding test case because draw packages are often:
- Large and time-sensitive.
- Submitted as combined PDF files.
- Made up of multiple document types.
- Essential to loan disbursement decisions.
- Subject to validation and compliance requirements.
The same underlying capabilities can support several other real estate finance applications.
A draw review agent can classify documents, identify missing items, extract invoice data, validate lien waivers, and flag inconsistencies before funds are released.
An AI system can identify covenants, borrower obligations, reporting requirements, financial thresholds, default provisions, and restrictions on additional borrowing.
An insurance-focused agent can review certificates and policy documents to identify coverage limits, expiration dates, exclusions, endorsements, additional insureds, and loss payees.
Underwriting teams can use document intelligence to summarize appraisals, offering memorandums, rent rolls, budgets, financial models, and market reports.
Asset managers can process recurring reporting packages, monitor changes, and identify portfolio-level risks or exceptions.
Compliance workflows can use AI to inspect permits, inspection reports, regulatory forms, and other required documentation.
The advantage of this horizontal model is reuse. Teams do not need to create a separate document pipeline for every application. They can reuse the same infrastructure for ingestion, classification, schema management, extraction, evaluation, and review.
Built developed the solution with AWS Generative AI Innovation Center, AWS Partner AND Digital, and AWS account teams. The architecture uses the AWS Intelligent Document Processing Accelerator and Amazon Bedrock to support generative AI-powered document processing.
The pipeline is orchestrated through AWS Step Functions and includes several stages:
When a user uploads a document, it is stored in an Amazon Simple Storage Service (Amazon S3) input bucket.
The upload triggers an Amazon EventBridge event. A queue-management process then records the event in Amazon DynamoDB and places a message in Amazon Simple Queue Service (Amazon SQS).
This approach helps manage concurrency. It allows the platform to process a single document upload or a large batch without exceeding service limits.
Amazon Textract extracts text, tables, forms, signatures, and page-level structure. The system stores the raw text, parsed text, and page images in Amazon S3.
This structural information is important because later stages need more than plain text. They may need to understand:
- Which words appear in a table.
- Where a signature is located.
- Which page contains a particular value.
- How fields relate to one another.
- Whether a scanned page contains handwritten information.
For documents that are difficult for traditional OCR—such as low-quality scans or pages with dense handwriting—the architecture can also use a vision-capable foundation model through Amazon Bedrock.
Real estate packages frequently combine several documents into one file. The classification stage determines what type of document each page or page group represents.
For instance, a 150-page construction draw package might be divided into:
Page 1 - Cover letter
Pages 2–6 - Invoices
Pages 7–8 - Lien waiver
Pages 9–10 - Insurance certificate
Once the system identifies these sections, each group can be processed independently.
This is particularly useful because extraction requirements vary by document type. An invoice requires a different set of fields from a lien waiver or insurance certificate.
After classification, the system sends each document section to the appropriate extraction workflow. AWS Step Functions Map states allow multiple sections to be processed in parallel.
Instead of waiting for every page group to be processed sequentially, the platform can process invoices, lien waivers, and insurance documents concurrently. As a result, the overall processing time is determined primarily by the longest individual task rather than the combined time required for every task.
This parallel design is one of the main reasons document workflows can move from several days to minutes.
One of the solution’s important capabilities is dynamic schema generation.
A schema defines what the system should extract from a particular document type. It can include field names, data types, nested objects, descriptions, and validation requirements.
For a lien waiver, a schema may include:
- Waiver type.
- Contractor or subcontractor name.
- Project name or address.
- Payment period.
- Amount waived.
- Exceptions or exclusions.
- Signature details.
A field description can provide additional guidance about where the information usually appears and what alternative labels may be used.
For example, a “Through Date” field might be described as a date labeled “Period Ending,” “For Work Through,” or “Through Date.” This gives the model more context than the field name alone.
A generic field name such as `AmountWaived` may not be sufficient when a document contains several different dollar values. A detailed description can guide the model toward the correct amount by explaining:
- What the field represents.
- Where it is usually found.
- Which labels may identify it.
- How it differs from related values.
This schema-driven approach helps align AI outputs with the way real estate professionals understand their documents.
Generating schemas from examples
Rather than manually creating every schema from scratch, teams can upload sample documents and allow Amazon Bedrock to propose an initial schema.
Subject matter experts can then:
- Rename fields.
- Add or remove attributes.
- Define nested structures.
- Clarify field descriptions.
- Add examples.
- Test the schema against historical documents.
This makes it more practical to support hundreds of document types while keeping business experts involved in the process.
Choosing the Right Model
Different documents require different levels of reasoning. A standard invoice may not need the same model capabilities as a complex loan agreement or offering memorandum.
The architecture supports a flexible model-selection strategy:
- Smaller, faster models can process straightforward and standardized documents.
- More capable models can handle complex legal language, irregular layouts, and multi-step reasoning.
- Model selection can be configured at the processor level.
- Teams can compare model outputs during evaluation before deployment.
This avoids forcing every document through the most expensive or complex model. It also allows organizations to balance accuracy, speed, and cost according to the business use case.
Confidence Scoring and Human Review
Automation is valuable only when users can trust the results. In real estate finance, incorrect information can affect loan disbursements, compliance decisions, underwriting outcomes, and risk assessments.
Built’s system therefore includes field-level confidence scoring. A separate assessment stage compares the extracted value with the source document and generates:
- A confidence score.
- A short explanation.
- The page number.
- The location of the supporting evidence.
- A visual bounding box around the relevant text.
For example, the system may assign a high confidence score to a clearly printed waiver type but a lower score to an amount that is partially obscured by a handwritten note.
Results below the defined threshold can be routed to a human reviewer. Built’s production workflows require confidence levels above 95 percent for key use cases, according to the AWS case study.
The reviewer experience
Reviewers can work in a split-screen interface:
- The original document page appears on one side.
- Extracted fields appear on the other.
- Supporting text is highlighted with bounding boxes.
- Low-confidence values are visually flagged.
- Reviewers can correct classifications and extracted data.
This approach does not attempt to remove experts from the process. Instead, it focuses human attention where it is most needed.
Feedback Loops Improve the System
Human review can serve a second purpose beyond correcting individual documents. Reviewer corrections can become part of evaluation datasets and future improvement cycles.
This creates a continuous feedback loop:
1. The AI extracts information.
2. The system identifies low-confidence results.
3. A reviewer corrects the output.
4. The correction is added to a labeled evaluation set.
5. Teams refine schemas, prompts, or model configurations.
6. The updated processor is tested before deployment.
This process helps organizations improve accuracy over time without treating every correction as a one-off manual fix.
It also creates a shared working environment for technical teams and industry experts. Engineers can manage infrastructure and model orchestration, while lending professionals, compliance specialists, and operations teams can define what accurate outputs should look like.
Document intelligence becomes even more valuable when it can determine whether extracted information satisfies a business rule.
For example, an insurance document may state a coverage limit of a specific amount. But the more important question is whether that limit meets the requirements in the related loan agreement.
Built’s approach separates this process into two stages.
Stage 1: Fact extraction
The system identifies relevant facts from the source documents and records where each fact was found.
Stage 2: Policy evaluation
An orchestration step evaluates those facts against defined business questions and returns a result such as:
- Compliant.
- Non-compliant.
- Insufficient evidence.
This separation improves traceability. The system first gathers the evidence and then uses that evidence to support a conclusion.
Business rules can be expressed as questions that subject matter experts understand, such as:
- Does the loan agreement specify a debt service coverage ratio?
- Is there a minimum net worth requirement?
- Are additional borrowings restricted?
- Does the insurance coverage meet the required limit?
- Is the lender listed as an additional insured?
- Does the document provide enough evidence to confirm compliance?
The result is more than a collection of extracted fields. It is an evidence-supported assessment that can help professionals make decisions faster.
The AWS case study highlights several outcomes from Built’s document intelligence solution:
- Workflows that previously required three to nine days can be completed in minutes per package.
- The architecture supports more than 250 document types.
- The platform is designed to scale to millions of documents per month.
- The same document intelligence layer can support multiple AI agents.
- Large document packages can be processed through parallel workflows.
- Confidence thresholds and human review help maintain quality.
- Evaluation tools enable teams to test schema and model changes before production deployment.
These capabilities can create tangible benefits for real estate finance organizations:
Faster capital deployment
Automated draw-package review can help lenders validate documentation more quickly and release funds with less administrative delay.
Lower operational workload
Teams can spend less time searching for fields, sorting pages, and manually comparing documents.
Better exception management
Instead of reviewing every page with equal attention, professionals can focus on missing documents, inconsistent values, and low-confidence findings.
Greater scalability
Organizations can process increasing document volumes without expanding manual operations at the same rate.
Stronger auditability
Evidence references, confidence scores, and review histories make it easier to understand how an AI-generated result was produced.
Built’s implementation offers several lessons for organizations planning their own AI document-processing initiatives.
Start with a high-value workflow
Choose a process that is document-heavy, repetitive, measurable, and operationally important. Construction draw review is a strong example because it directly affects funding timelines.
Build a reusable foundation
Avoid creating isolated AI tools for individual departments. Shared capabilities for ingestion, classification, extraction, evaluation, and review can support multiple use cases.
Involve subject matter experts
AI systems perform better when industry professionals help define schemas, field descriptions, business rules, and evaluation criteria.
Design for evidence and review
In finance and compliance, an answer without supporting evidence is difficult to trust. Every important output should be traceable to the source document.
Use human review strategically
Human-in-the-loop workflows do not undermine automation. They help organizations deploy AI responsibly by directing expert attention toward ambiguous or high-risk cases.
Measure before scaling
Organizations should evaluate accuracy, processing time, exception rates, review effort, and cost before expanding to additional document types or business units.
The application of generative AI in real estate finance is moving beyond chatbots and basic data extraction. The next generation of systems will understand documents, connect related information, apply business rules, identify exceptions, and support decisions across the property lifecycle.
A construction lending agent may review draw documentation. An underwriting agent may compare an appraisal with a financial model. An insurance agent may determine whether coverage satisfies loan requirements. An asset management agent may monitor portfolio reporting for emerging risks.
All of these applications depend on a common capability: converting unstructured documents into structured, explainable, and actionable intelligence.
Built Technologies’ AWS-based solution demonstrates how that foundation can be developed at enterprise scale. By combining generative AI, document processing, schema management, confidence scoring, parallel orchestration, and human oversight, real estate finance organizations can modernize document-heavy operations without sacrificing control.
The broader lesson is clear: the most effective AI systems in real estate will not simply read documents. They will understand the business context behind them and help professionals turn that understanding into faster, better-informed decisions.
—----------------------
Raising capital? Explore 3,000+ PropTech and ConTech VCs in one place →https://www.proptechbuzz.com/vc
If you are a proptech company and want to promote your products for free, go to proptechbuzz.com and submit your products. For investors or proptech buyers, sign up on our platform to stay informed about exciting updates and trends in the Proptech Ecosystem.