How We Built Proof Autofill

Proof Autofill didn’t just make job creation faster… it transformed how our users work with Proof and set our business on a new trajectory.

At Proof, we handle service of process and eFiling for thousands of the country’s top law firms, property managers, and collection firms, connecting them with process servers who deliver legal documents to the right place, at the right time, while following local rules.

The job is high stakes: a late or incorrect serve can stall or even derail a case. That’s why so many firms choose Proof. Our nationwide marketplace, real-time pricing, and modern platform bring transparency, efficiency, and compliance to an industry that’s barely changed since the 1990s.

Still, one step remained slow: job creation. Paralegals had to fill out long forms, manually entering names, addresses, court information, and deadlines. Yet most of that data was already in the legal documents they uploaded.

That insight sparked our biggest leap forward: Proof Autofill, an AI that reads messy legal PDFs, turns them into structured data, and creates a new serve request in 60 seconds.

Proof Autofill didn’t just make job creation faster, it transformed how our users work with Proof and set our business on a new trajectory.

In this post, we’ll take you behind the scenes of how we built our first customer-facing AI experience called Proof Autofill. Along the way, we’ll cover:

• Exploring the hidden complexities behind this problem

• Designing for accuracy, trust, and transparency

• Building technical architecture and managing engineering tradeoffs

• Defining go-to-market considerations in LegalTech

• Planning what’s next

The Messy World of LegalTech

Over the course of Proof’s history, we’ve processed over 1 million documents. The first instinct was obvious: throw an LLM at the problem. These models are great at understanding unstructured text. But in practice, legal documents are chaotic:

• PDFs range from 2 to 150+ pages

• Multiple documents are often packaged together into a single PDF

• Documents are often scanned, contain annotations, court stamps, and handwritten notes

• Formatting is wildly inconsistent across every client, court, and document type

Furthermore, the stakes are high in service of process, and compliance is critical. Every state and job type has unique rules that must be followed by process servers. Mistakes during service can cause delays, costing our clients time and money. In addition, process servers often have to meet deadlines that are imposed by the court, so every day counts.

Our Design Principles

Our customer base is made up of paralegals, property manager admins, and collection firm employees. Many of them have been doing their job the same way for decades. They are accustomed to manual workflows, copying and pasting information from one system to the next. Furthermore, there are strong sensitivities to AI because many in the industry question the accuracy of these tools.

Putting ourselves in the users’ shoes, we began this project with three critical questions:

1. How might we design systems that empower legal professionals, rather than replace them?

2. How might we instill trust and confidence, rather than skepticism and doubt?

3. How might we deliver meaningful value to our customers and business, instead of a shiny AI toy?

   
   

   These questions guided our approach to solving the problem and shaped Proof Autofill’s core design principles:

• Empower, don’t replace

  Our goal is to make our users more productive, not replace them. We design tools that streamline workflows, reduce errors, and save time so that legal professionals can focus on higher leverage tasks.

• Earn trust, don’t demand it

  Trust isn't a given. We prioritize transparency, control, and reliability so that users understand what the system is doing and can step in to correct it whenever needed.

• Solve real problems that drive business impact

  Our North Star metric is saving customers time. When we reduce the effort required to work with Proof, users return and trust us with more of their business.

Proof Autofill: A Simpler Way to Submit Jobs

Before Proof Autofill, submitting a job meant filling out a long, multi-step form. We asked users to manually provide details like:

• The type of documents being served (Summons, Complaint, Garnishment, etc.)

• The type of party (individual or business)

• Names and addresses of each party

• Court jurisdiction and court date

For high-volume customers, many of whom complete hundreds of serves a month, this process was time-consuming. Each submission took around 15 minutes on average, and even longer when multiple parties were involved.

Enter: Proof Autofill

Proof Autofill transforms job creation from a tedious task into a fast, intuitive experience. Here's how it works:

1. Upload your documents to Proof

2. Watch as your job form fills in automatically

3. Review, edit, and submit in seconds

No more repetitive typing. No more digging through documents. Just a faster way to get work done. The experience is designed for speed, control, and clarity. It hit all of our goals:

• 10x faster submissions: from ~10 minutes to just 1

• Users stay in control: every field is editable before submission

• Smart positioning: we highlight the value (time saved), not just the tech (AI)

Proof Autofill doesn’t just save time, it makes the experience of working with Proof feel modern, intelligent, and effortless.

Our Approach to System Architecture

Proof Autofill takes unstructured legal PDFs and converts them into structured, editable data in seconds. Behind the scenes is a highly engineered AI pipeline optimized for accuracy, speed, and scale in one of the most chaotic data environments: the American legal system.

Here’s how it works.

1. Upload Documents & Kickoff Workflow

When a user uploads legal documents, like a summons or complaint, Proof validates the request and kicks off an asynchronous AI workflow. This Temporal workflow manages the end-to-end pipeline, including text extraction, structured field extraction, validation, and user-facing form generation.

2. Smart Text Extraction

We process hundreds of thousands of legal documents each year, ranging from clean, text-based PDFs to messy court scans filled with stamps and signatures. Extracting accurate text from this wide range of formats is essential.

To handle this variability, we use a two-tiered approach that balances speed with accuracy.

• Text-based PDFs are parsed using pdftotext, a lightweight, open-source tool that efficiently handles machine-readable files. It runs in less than a second and is free to use. However, it does not perform well with scanned documents.

• Scanned or image-based PDFs are routed to an optimized multi-modal Large Language Model (LLM) designed for high-fidelity text extraction from visually complex documents.

If the LLM succeeds, the extracted text is passed downstream for structured field extraction. If it fails, due to file size or content restrictions, we fall back to our legacy OCR extraction pipeline.

Here’s how that fallback works:

1. Download the PDF from S3 and process with pdftotext

2. Check output size — if under 800 bytes, assume it’s scanned

3. Truncate document to less than 10MB and send to the LLM for extraction

Fallback to AWS Textract if the LLM still fails, converting the scanned image into text.

This layered system ensures Autofill can handle even the most unruly legal PDFs, while maintaining fast processing times and high accuracy.

3. LLM Evals, Prompts, and Post-Processing

New and improved LLMs emerge every month, and we evaluate them using a combination of public benchmarks like Seal Benchmark and rigorous internal testing. While we have millions of PDFs securely stored from past jobs, we handle all documents with strict security and privacy protocols, ensuring customer data is never used to train public models. We’ve carefully curated and labeled a dataset of hundreds of documents as a source of truth for our internal evaluations. As of the publishing of this article, we use a variety of LLMs in production and are actively testing the latest models, including GPT-4o, Gemini Flash 2.0, and Claude Sonnet 4.

Alongside the raw text file, we send a custom prompt to the LLM. There are 5 main components to the prompt:

1. Identity: describe the persona, style, and subject matter for the LLM to replicate

2. Instructions: explain the objective and actions required to achieve it

3. Context: add industry- or use case–specific context to improve performance

4. Output format: define the JSON structure for the expected data output

5. Examples: include few-shot input/output examples

Once we receive the JSON output from the LLM, the final step is post-processing. To ensure the results are production-ready, we:

• Deduplicate servee names across documents

• Validate addresses via Google’s Address API

• Transform data outputs into a frontend-ready schema

4. Accuracy & Field-Level Comparison Logic

In LegalTech, accuracy isn't optional, it's the baseline expectation. We evaluate Proof Autofill’s performance using rigorous field-level accuracy scoring. Each extracted value from the LLM is compared to what’s ultimately submitted by the user.

To handle variations (i.e., Mr. John Smith vs. Jonathan Smith), we use a mix of exact matching, fuzzy matching, and normalization. This approach allows us to track field-level performance at scale and continuously benchmark improvements as we iterate on prompts, models, and data pipelines.

Engineering Challenges & How We Solved Them

Challenge #1: Speed vs. Accuracy Tradeoff

The main tradeoff between using LLMs and traditional text extraction methods is speed vs. accuracy. In our tests, the LLM processed text-based PDFs up to 20x slower than pdftotext (20 seconds vs. 1 second). However, for image-based documents, that same LLM delivered a 5–10% improvement in extraction accuracy compared to legacy OCR tools. Based on this, we chose to use the LLM only for scanned or image-based PDFs, gaining accuracy where it matters most, without compromising performance across the board. In parallel, we are exploring newer vision models to eliminate the need for text extraction altogether.

Challenge #2: LLM Context Window Limits

Each LLM has unique errors and limitations that need graceful handling. The LLM we use has a strict input token limit, so we cap all scanned PDFs at 10MB before sending them for extraction. To support this, we built a lightweight truncation system that compresses or clips oversized files while preserving high-signal pages like captions and court headers. This ensures we stay within the LLM’s context limit, without sacrificing accuracy on the most critical content.

Challenge #3: Controlled Rollout Across Diverse Legal Jurisdictions

Rolling out Proof Autofill nationally meant accounting for wide variability in legal documents across different states. Each state has its own document formats, standards, and trends. Rather than launch all at once, we used a phased, state-by-state beta program to validate our system’s accuracy under real-world conditions.

We began with a small set of states and used internal evaluation tools to measure field-level accuracy while identifying edge cases. Once confident in performance, we gradually expanded coverage using feature flags to control access by geography. This approach allowed us to monitor performance, capture feedback, and iterate safely. It ensured the system could generalize well before being rolled out to all users nationwide.

Challenge #4: Building a Data-Driven Feedback Loop

To truly improve Proof Autofill, we needed more than gut checks or one-off accuracy samples. We built a full data feedback loop to understand how the system performed at scale and from the user's perspective.

We instrumented each stage of the pipeline to record processing time, extraction method, and other key signals. We enriched the raw processing metadata by joining it with platform context. This included job information, what types of documents were uploaded, and how often users made edits to the extracted results. Bringing these datasets together helped us evaluate performance from both a technical and user-centric perspective.

We built dashboards to surface trends across processing time, extraction behavior, and user outcomes. By visualizing this data over time and by document type, we were able to identify bottlenecks, uncover patterns, and measure the impact of improvements. These dashboards became essential tools for monitoring performance and guiding iteration.

Go-to-Market Strategy: Trust Before Scale

Accurate information at job intake isn’t just a nice-to-have, it’s critical. If Proof misclassifies the court state or a deadline, a case can be delayed or dismissed, costing our clients time, money, and trust. That’s why we didn’t rush Proof Autofill to market. We took a deliberate, phased approach to ensure the system was accurate, reliable, and ready for real-world use cases.

Phase 1: Benchmarking Against Source of Truth Data

We started by running Proof Autofill on hundreds of historical jobs, comparing Proof Autofill’s output to verified and labeled data. This allowed us to establish internal evals, identify failure points, fine-tune our prompts, and gain confidence in the results.

Phase 2: Opt-In Beta

We launched Proof Autofill as an opt-in beta, targeting a small cohort of users in specific geographies. This gave us a safe and controlled mechanism to introduce the feature without disrupting core workflows or risking user churn. Our customers could try Proof Autofill, and disable it at any time if it didn’t meet their expectations. We set up direct feedback loops to capture qualitative feedback, recorded user sessions to understand where the experience broke down, and tracked the accuracy of our AI. This helped us refine our prompts, improve the AI pipeline, and polish the user experience.

Phase 3: Public Rollout

Once we had confidence in the system’s performance and reached 90% accuracy rates, we rolled out Proof Autofill to all firms nationwide. With more usage, we saw more document types, and the opportunity to refine our prompt even further with more context. Autofill now powers mission-critical workflows for our largest clients, running all jobs uploaded to our platform. Our latest internal benchmarks show an industry-high 97% accuracy.

The Impact to Our Users and Our Business

Proof Autofill didn’t just make job creation faster — it transformed how our users work with Proof and set our business on a new trajectory.

Proof was the first nationwide service of process company to offer AI-powered job creation, giving customers an unprecedented level of speed and ease in starting new serves.

• We saved firms ~10 minutes on every job they upload. Power users upload hundreds of jobs to our platform every month

• We improved conversion rates for new users by 7%. Getting past the document upload step was the biggest drop-off point in our funnel. With Autofill, we streamlined the signup flow and reduced friction

• We increased retention rates by 35%. Users who engaged with Proof Autofill returned at a much higher rate

What’s Next

First, we plan to improve Autofill’s performance further by exploring alternatives to text extraction, fine-tuning our own models, and experimenting with prompt chaining.

Next, we’re thinking more broadly about where AI can help make an impact for our users and within the organization: from support, to sales, to new products and services.

Final Thoughts

We built Proof Autofill because we believe legal professionals deserve tools that save them time, without sacrificing trust. It’s easy to get caught up in AI hype. But in LegalTech, precision matters. The best tools don’t feel flashy, they just work. Quietly. Reliably. At scale. And when the tools work, customers have more time to focus on what matters most: their clients.

Want to help us build the future of LegalTech? Explore opportunities on Proof's Careers page.