Engineering Intelligent Address Resolution for 150M+ Verified US Addresses

Introduction

Address resolution—the systematic process of standardizing, validating, and indexing property addresses—forms the foundation of modern real estate data infrastructure. At Parcl Labs, our platform manages hundreds of millions of properties, processing data from over 5,000 external sources and millions of address-level inputs daily. This mission-critical system ensures data consistency, enables rapid lookups, and powers everything from customer-facing APIs to internal workflows.

Property addresses represent one of housing data's most fundamental challenges—they lack standardization across regions, exist in multiple valid formats, and suffer from pervasive human error. While dedicated companies offer address resolution solutions, their high-cost, general-purpose approaches didn't meet our specific technical demands: maintaining exceptional precision at scale while processing an ever-expanding volume of real estate and geospatial data. For example, our system must accurately index address-level events (i.e., sales, listings, rentals) from different sources to construct complete property histories, and intelligently determine whether an incoming address represents a new property (e.g., a new build) or an existing one in our database.

These critical operations occur tens of thousands of times every day. Each resolution must be fast and accurate, as these directly impact data quality, user experience, and market insight delivery. We addressed these challenges by evolving from legacy architectures to a modern, decoupled, event-driven design. This system now delivers superior performance, greater cost efficiency, and improved accuracy at scale—forming the backbone of our data infrastructure as we expand across new data sources and geographies.

You can access the Parcl Labs Address Resolution service via our API Address Search endpoint. Sign up to test it for free.

The Technical Challenge: Legacy System Limitations

Prior to re-architecting our address resolution system, we faced significant technical limitations that hindered scalability and reliability:

• Tightly Coupled Architecture: Components were interdependent, preventing isolated updates or scaling
• Blocking Sequential Processing: Address resolution had to complete fully before downstream data flows could begin
• System Drift: External user addresses and internal processes used separate resolution systems, leading to inconsistencies
• Resource Overhead: Critical downstream dependencies forced use of expensive compute resources

These limitations became increasingly problematic as our data volume grew. With hundreds of millions of properties and thousands of data sources, we needed a more resilient, efficient, and scalable approach.

A Modern, Decoupled Architecture

Our new architecture embraces a decoupled, event-driven design that transforms address resolution into a dynamic, scalable pipeline. This modern approach delivers critical advantages:

• Event-Driven Processing: Asynchronous operations enable parallel data flows and eliminate blocking dependencies
• System Independence: Critical data pipelines operate independently of address resolution
• Self-Improving System: Continuous learning from user interactions and 5,000+ data sources
• Cost-Efficient Scalability: Serverless design with local caching optimizes both performance and resource utilization

The system comprises of two core components:

1. Internal Address Indexer: A lightweight API service that standardizes addresses and performs rapid lookups through distributed SQLite databases on AWS EBS. This component:
   • Handles all real-time address resolution requests
   • Maintains local caches for high-performance lookups
   • Manages property ID assignment and validation
2. Centralized Resolution Pipeline: A serverless workflow using AWS Lambda, S3, and SQS that:
   • Processes bulk address data from our warehouse
   • Integrates with external validation services
   • Enriches addresses with geocoding data
   • Maintains system-wide data consistency

These components work together to ensure both rapid real-time resolution and thorough background processing, while maintaining a single source of truth through continuous synchronization.

Internal Address Indexer

Our core resolution system is built around a lightweight API designed to handle high-volume address standardization and lookups with minimal latency. The architecture combines distributed SQLite databases with strategic caching to achieve both speed and reliability.

Architecture

SQLite serves as our database layer, chosen for its simplicity and speed. Its file-based, self-contained design makes it an ideal choice for mapping address hashes to Parcl property IDs with minimal overhead.

To optimize performance, we implement a distributed caching strategy using AWS EBS:

• High-Speed, Low-Latency Storage: AWS Elastic Block Store (EBS) provides the rapid disk access needed for fast SQLite operations
• Cost-Effective Scalability: EBS delivers the performance required for our workloads at a lower cost than networked storage option
• Independent Instance Scaling: Local caching on each instance running the Address Resolution Service eliminates network storage delays
• Reliable Data Access: Each instance maintains its own cached copy of the SQLite database

Resolution Flow

The system processes addresses through a defined sequence:

1. Initial Request Processing:
   • User submits address through Parcl Labs API
   • Standardization engine normalizes address format (e.g., "St" → "Street", "Dr" → "Drive", "N" → "North")
   • System generates unique hash from standardized address
2. Resolution Path:
   • System queries local SQLite database using address hash
   • If hash exists: return associated Parcl property ID immediately
   • If hash not found: forward to government-validated resolution service for processing
3. System Learning:
   • For every address processed, we log:
     • Original user input
     • Generated address hash
     • External validation results (when performed)
   • A Lambda job continuously processes these logs, updating our main SQLite repository with newly validated addresses
   • Each day, a cron job ensures all local SQLite instances match our main repository

This process means that if User A submits "123 Main St" and it requires external validation, User B submitting the same address later (even formatted as "123 Main Street") will get an instant response from our local cache. Our main SQLite repository maintains the single source of truth, while local instances on each server ensure fast lookups for previously processed addresses.

Centralized Address Resolution Pipeline

While our Internal Address Indexer handles real-time API requests, we developed a complementary system to process addresses from our data warehouse at scale. This pipeline ensures consistent address resolution across all data sources while maintaining system-wide data integrity.

Architecture

The pipeline implements a serverless, event-driven design built on AWS services:

• Snowflake Integration: Sources addresses from our data warehouse containing millions of records
• Lambda Processing: Three distinct functions handle different stages of resolution
• S3 and SQS: Enable reliable, scalable event-driven processing
• Internal Services: Leverages our Address Indexer and Lat/Long Resolver for standardized processing

Resolution Flow

1. ^Data Collection (Lambda 1)
   • Queries Snowflake for unresolved addresses
   • Writes these addresses to S3 bucket for processing
   • Same bucket collects logs from Address Indexer interactions
   • S3 events trigger our first processing queue
2. Core Processing (Lambda 2)
   • Processes each new address through:
     • Address Indexer for standardization and resolution
     • Lat/Long Resolver for geocoding
   • Updates Snowflake with resolution results
   • Analyzes Address Indexer logs to identify addresses needing new Parcl property IDs
   • Routes log files to secondary queue for processing
3. System Synchronization (Lambda 3)
   • Processes queued log files
   • Updates master SQLite repository with newly validated addresses
   • Ensures consistency between fast-access and warehouse data

This pipeline creates a continuous feedback loop between real-time API operations and batch processing. When users interact with our API, those interactions are logged and fed back through this pipeline, enabling the system to learn from and improve upon each resolution. The end result is a self-improving system that maintains consistency whether addresses come through real-time requests or batch processing.

Conclusion

The re-architecture of our address resolution system marks a significant advancement in our ability to process property data at scale. By developing a lightweight, distributed SQLite implementation combined with an event-driven processing pipeline, we've achieved both the performance and reliability our platform demands while maintaining strict data consistency across millions of property records.

This new architecture has transformed our address resolution capabilities. Local caching with SQLite provides rapid lookups, while our event-driven pipeline ensures thorough processing of our ever-growing data volume. The system continuously learns and improves through automated feedback loops, enhancing accuracy with each address processed. Importantly, we've achieved this while reducing infrastructure costs and eliminating the bottlenecks that plagued our previous implementation.

Looking ahead, this foundation positions us to handle increasing data volumes and complexity with confidence. Our modular, self-improving design enables easy integration of new data sources and adaptation to emerging property data challenges—all while maintaining the high performance and accuracy standards essential for real estate data infrastructure.

You can access the Parcl Labs Address Resolution service via our API Address Search endpoint. Sign up to test it for free.