From Client Need to Live Product in 60 Days: How OneSpring Built COI Dash with Agentic AI

OneSpring took COI Dash from a validated client need to a live certificate of insurance management product in about 60 days. A four-person team used AI across discovery, development, testing, and design, while COI Dash used AI-assisted document processing to extract certificate data and compare it with configured insurance requirements.

The project shows how a small team can use agentic workflows to shorten product-development cycles without removing human review, acceptance criteria, or production safeguards.

What Is a Certificate of Insurance?

Before getting into the build, it helps to understand the document at the center of it all.

A Certificate of Insurance (COI) reports policy information as represented when the certificate is issued. It summarizes items such as coverage types, policy limits, effective dates, expiration dates, and the named insured, but it is not the policy and does not amend, extend, or alter coverage.

COIs are exchanged constantly in business. Any time an organization hires a vendor, contractor, or service provider, it typically requires a COI to review whether the certificate appears consistent with the organization’s insurance requirements and identify provisions that need confirmation in the policy or applicable endorsements. The risk is straightforward: if a vendor causes damage, injury, or loss and isn't properly insured, the hiring organization may be left holding liability it never intended to carry.

Why COI Management Becomes a Real Problem at Scale

For a small business with a handful of vendors, managing COIs is a minor administrative task. For organizations operating at scale, it becomes a serious operational burden.

Consider the numbers:

• A construction company managing 200 vendors may need current insurance evidence for each relationship

• Many underlying policies run on annual terms, so certificates and policy evidence require ongoing renewal tracking

• Each certificate can list multiple insurance policies (general liability, workers' comp, commercial auto, umbrella coverage, and more), each with its own limits and expiration dates

• Missing, expired, or insufficient evidence can create contractual, operational, and risk-management concerns

Cities and municipalities face the same challenge, often at even greater scale. A mid-size city may have hundreds of active vendor contracts across public works, parks, IT, facilities, and more, each requiring proof of insurance that must be tracked, validated, and renewed.

The manual reality: the clients OneSpring spoke with were handling this through spreadsheets, email threads, and shared drives. Someone had to open each PDF, read the coverage details, compare them against requirements, log the expiration dates, and follow up when renewals were due. It was slow, error-prone, and nobody's favorite job.

That was the problem COI Dash was built to solve.

The Opportunity: A Client Problem That Became a Product

COI Dash didn't start as an internal R&D initiative. It started as a sales conversation.

OneSpring heard the same pain point from multiple clients: managing certificates of insurance was a manual, time-consuming process with real compliance risk attached. The need was clear, and OneSpring saw an opportunity for a more focused workflow. AI had matured to the point where document parsing, compliance validation, and workflow automation could be delivered in a single, affordable platform.

The decision was made to build it, not just as a client deliverable, but as a standalone product that OneSpring itself would bring to market. That distinction matters. Building something you intend to own and operate raises the bar on every decision: the architecture has to be durable, the UX has to be polished, and the AI integration has to perform reliably under real-world conditions.

The target market took shape around risk and compliance density. Three verticals emerged as the highest-priority targets:

The insurance company angle proved especially strategic. By partnering with an insurer whose clients included cities and municipalities, COI Dash gained an immediate distribution channel into exactly the organizations that needed it most.

With the market defined and the problem validated, OneSpring set a two-month target to go from concept to live product. AI-assisted workflows were central to meeting that timeline, not just as the product's core feature, but as the team's primary development accelerator.

COI Dash brings certificate review, vendor compliance status, and renewal tracking into one operational view.

The Build: Eight Weeks, Four People, AI at Every Layer

The COI Dash build followed four overlapping phases across roughly eight weeks. What made it unusual wasn't the phases themselves, which mirror a standard agile product cycle. What made it unusual was how deeply AI was embedded in each one.

Phase 1: Discovery and Story Definition (Weeks 1-2)

The first two weeks were dedicated entirely to defining what the product needed to do. The team used an MCP (Model Context Protocol) connection to Jira to generate and organize user stories directly from discovery conversations. By the end of this phase, they had documented more than 60 user stories with clearly defined acceptance criteria.

That number matters. Sixty-plus user stories in two weeks is a fast pace for any team. The MCP-to-Jira integration compressed work that, in OneSpring’s experience, often requires longer workshops and documentation cycles into a structured, actionable backlog that was ready for development on day one of phase two.

The acceptance criteria defined in this phase didn't just guide development. They became the testing framework later in the build, giving the team a structured basis for AI-assisted QA rather than relying solely on manual review.

Phase 2: AI-Accelerated Development (Weeks 3-6)

With the backlog in place, the team moved into implementation. The development stack was purpose-built for speed:

• Claude (Opus) as the primary AI coding model, with Claude Code driving implementation

• Cursor and AntiGravity as the AI-native IDEs

• GitHub for the code repository and daily pull request workflow

• Vercel for deployment and hosting

• Supabase for the backend database

The team of four split the user story backlog across individuals, with each developer working on a set of stories simultaneously. They followed a daily agile rhythm: write code, use AI to accelerate implementation, open a pull request, review, and merge. The pace was aggressive but sustainable precisely because AI was handling the implementation heavy lifting on routine logic, boilerplate, and integration scaffolding.

"We were using AI to move very fast on implementation. Each individual on the team had their own user stories they were working, and we were doing pull requests every day." Jason Moccia, CEO, OneSpring

OneSpring estimated that the same scope could have taken three to four months with its previous workflow; the parallel, AI-assisted approach concentrated active implementation into roughly four weeks.

Toward the end of this phase, the team reduced from four people to two. The AI tooling had scaled the output of the initial team to the point where the latter phases of implementation and testing could be carried by a smaller group while continuing implementation and testing.

Phase 3: Testing (Weeks 5-6, Overlapping)

Testing ran concurrently with the tail end of development. The acceptance criteria from the Jira user stories served as the direct input for AI-assisted testing: the team used AI to validate functionality against the criteria that had been defined in week one, creating a tight feedback loop between what was specified and what was built.

Human-in-the-loop testing ran alongside the automated checks. Team members worked through the product as real users would, surfacing edge cases and usability issues that automated testing couldn't catch. This combination of AI-driven acceptance testing and hands-on human review kept quality high without requiring a dedicated QA team.

Phase 4: Design Finalization (Weeks 7-8)

Design in the COI Dash build followed an unconventional sequence. The team worked from a medium-to-high-fidelity design concept from the beginning of the project, which was enough to align on structure and user flows. But the final visual design took a sharp pivot in style once the code was complete.

That sequencing was intentional. Once all the functionality was built and validated, applying a high-fidelity design system to the working product was fast. The design elements and the code were both done; the work was connecting them.

Tools used in the design phase:

• Figma for interface design and component work

• Claude's design capabilities for rapid iteration on visual direction

The result was a product that could have its entire visual identity swapped out by applying a different design system, giving COI Dash the flexibility to adapt its look and feel without touching the underlying functionality.

The AI at the Core: How COI Dash Actually Processes COIs

The AI-enabled build process is what got COI Dash to market in two months. But the AI integration inside the product is what makes it valuable to the organizations using it.

The Parsing Challenge

Processing a certificate of insurance is harder than it sounds. A COI is a dense document: it lists multiple coverage types, each with its own policy limits, effective dates, expiration dates, endorsements, and named insureds. The challenge isn't just reading the document. It's extracting the right data points, mapping them against a specific set of requirements, and returning a clear compliance determination quickly enough to be useful.

OneSpring connected COI Dash's parsing engine to OpenAI, using it to handle the extraction and comparison logic. When a COI is uploaded, the system:

1. Parses the document and extracts all relevant policy data

2. Compares the extracted data against the compliance requirements configured in the system

3. Returns a pass/fail compliance determination with specific findings

In OneSpring’s internal testing, most evaluated certificates processed in approximately 10 to 20 seconds, and the system achieved approximately 97% extraction accuracy on the evaluated document set. Results vary by document quality, format, configuration, and system conditions, and users should review flagged findings.

Choosing the Right Model

Model selection was a deliberate decision, not a default. The team evaluated options against two criteria that matter in a production environment: cost and latency. A system that takes two minutes to process a document or charges a dollar per parse doesn't scale for an organization managing 200+ COIs per year.

The OpenAI integration OneSpring landed on hits the right balance: fast enough to feel responsive in a real workflow, designed to support human review of configured requirements, and affordable enough to make the per-document economics work for clients of all sizes.

Critically, the architecture keeps that decision reversible. The LLM integration is modular. If a better or cheaper model emerges, the team can swap it out without rebuilding the product. That kind of architectural flexibility is a deliberate design choice, not an accident.

Automated Expiration Monitoring

Beyond initial compliance checks, COI Dash handles the ongoing management problem that makes manual tracking so painful. The system tracks expiration dates extracted during parsing and automatically notifies users 30 days before a COI expires, giving users time to request updated evidence before the listed expiration date.

For a construction company managing 200 vendors, that automated monitoring alone eliminates a significant chunk of manual tracking work that would otherwise fall to an administrator or project manager.

What This Build Demonstrates About AI-Enabled Product Development

COI Dash isn't just a useful product. It's a proof point for a different way of building software.

The conventional assumption is that a sophisticated SaaS application with AI-powered document processing, compliance validation, automated notifications, and a polished UI requires a large team and a long runway. COI Dash challenges that assumption directly.

The Multiplier Effect of Agentic AI

The reason a team of four could build COI Dash in two months isn't that the product is simple. It isn't. It's that AI acted as a force multiplier at every stage:

• Discovery: MCP-to-Jira integration produced 60+ structured user stories with acceptance criteria in two weeks

• Development: AI-native IDEs and Claude Code accelerated implementation across a parallel, distributed workstream

• Testing: AI-driven acceptance testing against predefined criteria supported testing without a separate dedicated QA role on this project

• Design: AI-assisted design tools enabled rapid visual iteration without slowing the engineering track

• Product core: OpenAI-powered parsing delivered document extraction and comparison capabilities used in the live product

Each of these individually is an incremental improvement. Together, they compound. The team wasn't just writing code faster. They were eliminating entire categories of delay that slow traditional product development: documentation overhead, testing bottlenecks, sequential handoffs between design and engineering, and the cost of building AI capabilities from scratch.

The Architecture Reflects the Strategy

The technical decisions made during the COI Dash build weren't just about shipping fast. They were about building something durable.

The modular LLM integration means the AI engine can be upgraded or replaced as the model landscape evolves. The design system approach means the visual layer can be updated without touching the codebase. The Vercel and Supabase stack reduced the team’s operational setup during the initial build.

"This is what modern AI-enabled product development looks like: lean teams, modular architecture, AI embedded in the process and the product, and a timeline measured in weeks rather than quarters." Jason Moccia, CEO, OneSpring

A Repeatable Model

Perhaps the most important thing about the COI Dash build is that it isn't a one-off. The methodology OneSpring applied here, AI-accelerated discovery, parallel agile development with AI-native tooling, acceptance-criteria-driven testing, and modular AI integration, is a framework OneSpring can adapt to similar validated product opportunities.

The two-month timeline wasn't luck. It was the result of deliberate choices about tools, process, and where to apply AI's leverage most effectively.

Key Takeaways

• A four-person team took COI Dash from a validated client need to a live SaaS product in about 60 days.

• The team used AI across discovery, implementation, testing, design, and the product’s document-processing workflow.

• In OneSpring’s internal testing, most evaluated certificates processed in approximately 10 to 20 seconds, with approximately 97% extraction accuracy on the evaluated set.

• More than 60 user stories with acceptance criteria connected discovery directly to implementation and testing.

• Modular model integration and a modern managed stack made speed compatible with long-term flexibility.

COI Dash Is Live

COI Dash is live for organizations that manage certificates across vendors, contractors, and other third parties. Learn more at coidash.com.

Need to turn a validated business problem into a working AI-enabled product? Talk with OneSpring about product strategy, design, development, and AI implementation.

Product performance figures reflect OneSpring’s internal testing and may vary by document quality, configuration, and operating conditions. COI Dash supports insurance-document review but does not replace policy review, legal advice, or qualified insurance guidance.

Frequently Asked Questions

What is a certificate of insurance (COI)?

A certificate of insurance reports policy information as represented when the certificate is issued. It summarizes items such as coverage types, policy limits, effective dates, expiration dates, and the named insured, but it is not the policy and does not amend, extend, or alter coverage.

Why is COI management difficult at scale?

COI management becomes difficult when an organization has dozens or hundreds of vendors because each certificate may contain multiple policies and the underlying evidence requires ongoing renewal tracking. Reading coverage details, tracking listed dates, and reviewing documents against requirements manually takes time and creates operational and risk-management concerns.

How is COI Dash different from a standard document workflow tool?

COI Dash does more than store documents. It parses COIs, compares extracted details against configured requirements, flags potential mismatches, and tracks listed expiration dates so users can request updated evidence before coverage lapses.

How did OneSpring use AI to build COI Dash?

OneSpring used AI across the build cycle, from generating and organizing user stories in Jira to accelerating implementation, supporting tests against acceptance criteria, and refining the final design. AI was part of the delivery process, not just a feature in the product.

How fast and accurate is COI Dash’s document processing?

In OneSpring’s internal testing, most evaluated certificates processed in approximately 10 to 20 seconds, and the system achieved approximately 97% extraction accuracy on the evaluated document set. Results vary by document quality, format, configuration, and system conditions, and users should review flagged findings.