
DELOS AG
First paying enterprise customers in sixteen weeks
Streaver took Apeironix from a proof of concept that timed out on a single document to a multi-tenant, self-service platform that cuts agency busywork by more than 80% and now processes live carrier data in production.
Apeironix is an insurance-automation company that turns the unstructured chaos of the insurance back office into clean, actionable data. It extracts information from disparate documents, PDFs, and carrier emails, uses it to hydrate agency management systems and CRMs, and layers automation on top to eliminate the mundane work that drains an agent's day.
The company was born inside Triforta, a tech-forward insurance agency where founder Rodney Mattos had been training his own language models to understand insurance terminology and solve his own team's problems. Triforta became the first proving ground, and the demand from peers who saw it working became the reason to turn an internal tool into a product.
Rodney came to Streaver through a referral from a longtime collaborator after a US consulting firm vouched for the team. The first ask was sharp and unglamorous: the existing proof of concept didn't scale.
One file at a time. The moment two documents (or two users) hit the system at once, it timed out.
Zero job tracking. No way to give a user feedback while extraction was running.
Meant to live inside Salesforce and serve a whole agency, but it couldn't survive concurrent requests.
Every new agency required Apeironix engineers. The tool was still a service.
The AI document extractor ran on a synchronous, blocking API. It could process exactly one file at a time. The moment two documents (or two users) hit the system at once, it timed out. There were no retries, no job tracking, and no way to give a user feedback on progress. For a tool meant to live inside Salesforce and serve a whole agency, that was a hard ceiling.
The deeper challenge was strategic. Apeironix needed to become a product other agencies could buy and run themselves, without Apeironix's engineers in the loop for every onboarding.
Streaver embedded a dedicated pod that worked in synchronized cycles with Apeironix's leadership and delivered in two deliberate phases: first making the engine reliable, then turning it into a platform.
Streaver designed an AWS-native serverless middleware to sit between Salesforce (where users trigger extraction) and the AI extractor. It introduced asynchronous processing, concurrent handling of many documents from many users, automatic retries, queue-based job scheduling, and clear progress feedback, all under a multi-tenant model with API-key authentication, file encryption, and data-lifecycle policies built for insurance compliance.
As the system matured and outside investors came on board, scope accelerated. Streaver architected the full integration backbone linking Salesforce CRM, Apeironix's own small and large language models, and AWS infrastructure into a single coordinated engine, then built the self-service portal: onboarding, role-based access, subscriptions, and a modular tool catalog any agency can adopt on day one.
A serverless, multi-tenant architecture that coordinates job dispatch, document intelligence, carrier automation, and human review: the engine behind every tool in the catalog.
A modular catalog of AI tools that agencies enable through a self-service portal, with onboarding that recommends the right modules, role-based administration, and subscription management built in.
API keys and data mapping let agencies onboard with zero dev work.
Pulls policy data from PDFs documents, ending manual rekeying.
Turns carrier commission statements into clean, reconciled revenue data.
Retrieves bind-ready premiums across carriers via AI parsing and APIs.
Auto-generates white-labeled proposals in seconds.
Side-by-side AI comparison that surfaces coverage gaps instantly.
Insurance policies arrive as PDFs — dense tables, forms, and fine print that someone has to read and retype into a system. We built a serverless extraction service that does it automatically and shows its work: every field it returns is traceable to the exact spot on the page it came from.
A policy PDF lands in storage and the platform starts an extraction job. The API responds immediately and the rest runs asynchronously, so long documents never hold up the user's screen.
AWS Textract runs OCR, capturing text, form fields, and tables. Tables are rebuilt in place so the model reads them as tables rather than as scrambled lines of text.
A language model fills in a versioned schema defined per line of business. For every value it returns, it must also return the verbatim text and page number it took that value from.
Each citation is matched back against the OCR layer to recover the field's exact coordinates on the page. That's what lets a reviewer click any value and see it highlighted in the original PDF.
Results are stored and pushed back to the platform by webhook, together with coverage metrics, confidence signals, and the AI and OCR cost of the job.
For high-stakes documents, the service reads each policy twice in parallel — once from the OCR text, once from the PDF itself — and compares the results. Fields where both readings agree pass through. Where they disagree, a second AI pass weighs the evidence and explains which value it trusts and why. Reviewers get a short, ranked list of what actually needs a human instead of a wall of data with no signal.
No value ships without its source text, page, coordinates, and confidence.
Routing sits behind a gateway, so switching between OpenAI, Anthropic, and Google models is a request parameter — with cost tracked per model.
Adding a field or a new line of business is a new schema version, not a deploy. Every extraction records the exact version that produced it.
Jobs are idempotent and safe to retry, OCR results are cached so reprocessing with a different model doesn't pay for OCR twice, and every stage has its own dead-letter queue.
Commercial insurance carriers rarely expose quoting APIs. The one channel that always exists is their agent portal — a 10-to-15-screen wizard that a human fills out by hand, one carrier at a time. This service turns that manual process into a single API call.
One API call carries the business details — company, vehicles, drivers, coverages — along with the carrier and line of business. The payload is validated against a carrier-specific schema before anything else happens, so bad data fails in milliseconds instead of halfway through a portal session.
Requests land in a FIFO queue partitioned by client and carrier. No single high-volume account can starve the others, and no carrier gets hit with more concurrent sessions than it tolerates.
Each job runs in its own ephemeral cloud container with a real browser. It logs in, clears MFA, and walks the carrier's wizard screen by screen — filling forms, adding vehicles and drivers, selecting coverages — exactly as an agent would.
The primary path is a deterministic script: fast, cheap, predictable. But portals change without notice. When a script hits a screen it doesn't recognize — a new required field, a question added overnight — an AI layer reads the page, answers it from the business data, records what it assumed, and hands control back. The run adapts instead of failing.
Bound premium, decline, or referral to underwriting — the outcome is written to durable storage and delivered to the caller via webhook. Every run keeps its own audit trail: screenshots, page snapshots, structured logs, and per-run AI cost.
If a run breaks mid-wizard, the retry reopens the same submission in the carrier's portal, reconciles what was already entered, and continues from where it stopped. No orphaned quotes cluttering the carrier's system, and no repeated work.
The hard part of this kind of system isn't the first carrier — it's the tenth. Each new integration is built by an AI-assisted pipeline: one stage explores the live portal page by page and writes the implementation plan from what's actually on screen, the next generates the code, and the last runs the integration against a real browser, diagnoses its own failures, and fixes until it passes. Production issues are reproduced locally from a single quote ID.
13 integrations across 8 carriers and 2 lines of business, maintained by a small team.
Streaver carried Apeironix from prototype to a market-ready product, on time and on budget, while absorbing waves of new ideas that would have stalled most teams. Work that could have taken an average shop 6 to 12 months of change requests was turned around fast enough that Apeironix chose to move its launch later simply to fit more value in before going to market.
Today the platform is live in production, processing real commission statements across national carriers, with agencies cutting back-office time by more than 80%. The relationship is ongoing and expanding into new modules and a fully embedded, portal-less integration path.
I wish I could give Streaver a six.

"Streaver has handled the extra work and additional requests amazingly." Verified Clutch review, 5.0 across quality, schedule, cost, and willingness to refer.
Apeironix gained a partner that thought like an owner. Streaver pushed back when it saw a better path, kept communication right-sized with weekly working syncs, and took a seat in Apeironix's own producer-training program to learn the language of insurance and shorten every future build.

Led development of an insurance automation platform on AWS: Next.js portal, serverless RPA engine with AI browser automation, and OCR-based document extraction.

Managed the product design for Triforta from concept to handoff. Acted as the link with the client to align expectations and translate complex requirements into an intuitive UI.

Co-architected the serverless RPA engine and its AI browser-automation flows alongside the team lead. Contributed to the new OCR-based document extraction pipeline.

Built a full-stack insurance broker portal from the ground up, delivering AI-powered automation tools, document workflows, and a complete billing system into production.

Contributed to building and maintaining an RPA that automates insurance agent workflows on real carrier and brokerage websites.
From a single-file proof of concept to a multi-tenant, self-service AI platform in production. If your AI demo works but won't scale, you're where Apeironix was a year ago.

First paying enterprise customers in sixteen weeks

Building a $1M product for $125K with a non-technical CEO at the keyboard