Action Guide: Parse for Loss Runs

Loss runs are insurance documents that summarize historical claims, loss amounts, and coverage periods for a merchant. They help MCA brokers and funders understand risk signals like frequency of claims, severity trends, and gaps in coverage that may affect eligibility or pricing.

Manual review takes time because formats vary by carrier, fields are buried in tables, and key dates are scattered across pages. Heron automates parsing for loss runs so every important field becomes clean, structured data that your teams can use right away.

This turns inbox attachments into decision-ready records that support faster underwriting and clearer conversations with brokers.

Heron reads loss run PDFs and emails on arrival, identifies the carrier layout, pulls out standardized fields, and links the results to the correct merchant record.

The platform captures claim counts, total paid, reserves, open or closed status, loss ratio figures when present, policy numbers, and the exact coverage periods. Parsing also powers automated checks for completeness and date ranges, so you know when something is missing before it reaches underwriting.

With clean fields in place, teams move faster, focus on analysis instead of data entry, and make sure the CRM remains a dependable source of truth.

Use Cases

• Normalize carrier formats into one schema: Heron maps diverse loss run layouts into consistent fields like total claims, total incurred, and loss ratio. This gives underwriters comparable data across carriers without manual rekeying.
• Capture coverage periods accurately: The parser extracts policy effective and expiration dates as typed fields. This supports completeness checks and prevents underwriting from working off partial or stale periods.
• Distinguish open and closed claims: Heron identifies claim status, dates of loss, and last transaction dates. Underwriters can prioritize open matters that still carry reserve risk.
• Roll up totals and severities: The system calculates claim counts by year, total paid amounts, and large loss indicators. This highlights severity spikes and supports quick appetite screening.
• Detect gaps and overlaps in coverage: Parsed date ranges reveal missing months or overlapping policies. Operations can send targeted missing-info requests instead of guessing what to ask the broker.
• Extract carrier, policy number, and insured name: Heron pulls out identifiers from headers and footers. Records link correctly to merchants and policies without manual cross-reference.
• Handle multi-policy or multi-year packets: The parser separates sections inside a long PDF and attaches structured results to the right policy period. This avoids confusion when a carrier sends five years in one file.
• Support portfolio analytics: Parsed fields feed dashboards that show loss ratios by carrier, claim trendlines, and average time between losses. Leaders can spot patterns without hand-built spreadsheets.

Operational Impact

Parsing loss runs changes daily execution by replacing manual effort with immediate clarity. Teams reduce cycle time because the heavy lifting happens during intake, not after someone opens the file.

Accuracy improves because fields come directly from the source and follow the same schema every time. Queue health is stronger since incomplete or off-period documents are flagged up front.

Managers gain reliable reporting because totals, ratios, and period boundaries are typed values, not free text. Most importantly, underwriters spend time interpreting risk rather than searching for numbers, which shortens intake-to-decision and raises overall throughput.

Data Model and Field Mapping

A stable field model makes parsed loss run data useful across underwriting and analytics. Heron maps values to a compact but expressive schema.

• Core identification fields: Carrier name, policy number, insured or merchant name, and account identifiers map to text fields. This creates a clear linkage between documents and CRM records.
• Coverage period fields: Policy effective date and expiration date map to date fields. These values drive completeness checks and document freshness logic.
• Claim-level fields: Claim number, date of loss, paid to date, incurred, reserve remaining, and status map to typed columns. Underwriters can filter by severity or open status right away.
• Rollups and ratios: Total claims, total paid, total incurred, and loss ratio map to numeric fields. Annualized rollups allow year-over-year comparisons without spreadsheet work.
• Quality flags: Missing period, unreadable page, or out-of-range totals map to boolean fields. These flags route exceptions to a quick review queue.

Quality Controls and Exceptions

Parsing is paired with controls that protect accuracy and prevent bad data from entering the system of record.

• Low-confidence extraction routing: Items with weak text quality or ambiguous table structures go to a review queue. Reviewers confirm fields quickly, then the record proceeds.
• Numerical sanity checks: Totals and ratios are validated against per-claim sums and known carrier conventions. Outliers get a flag and a short note for underwriter awareness.
• Period boundary verification: Parsed effective and expiration dates must create continuous ranges when multiple periods are present. Gaps open a targeted missing-info request.
• Source anchoring for audit: Each field links to a page and cell location when available. Users can click through to confirm where a number came from in the original PDF.

Collaboration and Broker Experience

Structured fields help teams communicate clearly and ask for the right items once instead of twice.

• Clear requests for missing months: When a period gap appears, the broker receives a concise request naming the exact dates. This removes guesswork and shortens back-and-forth cycles.
• Shareable context in notes: A short summary line with carrier, period, and claim totals writes into the record. Everyone sees the same snapshot without opening the file.
• Faster response to questions: If a merchant asks why more documents are needed, teams reference the parsed period and claim count. The conversation stays specific and productive.
• Consistent naming for attachments: Renamed files match the parsed fields, which makes re-sends and clarifications simple for both sides.

Performance Metrics and Analytics

Once loss runs parse into fields, measurement becomes straightforward and repeatable.

• Turnaround time from intake to review: Time drops because underwriters receive structured results immediately. Managers track the delta across carriers.
• Exception rate by carrier template: Teams see where low-confidence extractions occur most often. Training sets and thresholds are adjusted for those formats.
• Coverage completeness rate: The share of submissions with full requested periods becomes a visible KPI. Missing-info templates improve based on that feedback.
• Severity distribution: Reports show counts of large losses and their time proximity. Appetite rules become easier to apply with consistent severity data.

Implementation Best Practices

A light setup with real examples delivers fast value and a stable base for growth.

• Seed with top carriers first: Start with the few insurers that generate most of your traffic. Early accuracy builds trust and momentum.
• Align field names with CRM: Map parsed fields to the current schema so adoption does not require a system redesign. Add new fields only where they provide clear value.
• Define the minimum viable set: Start with coverage dates, claim status, and total incurred. Expand once the first set is stable.
• Create a review loop: Spot-check low-confidence items weekly, then add examples back into training. Accuracy rises steadily without heavy process overhead.

Risk Signals Made Actionable

Parsed fields give underwriters fast access to the signals that matter for appetite and pricing.

• Frequency pattern clarity: Claims clustered within short windows often correlate with process issues or risk behaviors. Structured dates make clusters obvious.
• Severity spike detection: A small number of large losses can outweigh many minor claims. Rollups and maximum values surface those cases instantly.
• Open claim exposure: Reserves on open matters are captured as fields. Underwriters consider the remaining exposure before advancing a deal.
• Coverage gaps: Missing months suggest stale data or breaks in protection. Gaps feed a standard playbook for follow-up.

Exception Handling and Escalation

Not every document is clean. Heron provides controlled paths that keep the pipeline moving without corrupting data.

• Unreadable scans: Files with heavy artifacts or low resolution route to a quick manual capture. A quality flag records the reason and timestamps the decision.
• Mixed-document packets: Combined PDFs are split, labeled, and parsed section by section. Each output carries its own fields and links.
• Conflicting totals: When a summary table does not match line-level sums, a note is added for the underwriter. The item remains usable but visible as a watch point.
• Duplicate submissions: Identical files are suppressed, and the original handling remains authoritative. Queues stay clear, and audit history remains simple.

Data Governance and Security

Parsing fits into Heron’s security posture and traceability requirements.

• SOC 2 Type II controls: Documents and fields are processed under strong encryption and access policies. Access logging captures who viewed what and when.
• Field-level change history: Updates carry timestamps and user attribution. Analysts can trace how a value changed across versions.
• Redaction on export: Sensitive claim identifiers can be removed when sharing with external parties. Teams make sure only the needed context leaves the system.
• Retention alignment: Parsed artifacts and originals follow your retention policies, which keeps audits straightforward.

Operational Scenarios

These common scenarios show how parsing changes daily work and outcomes.

• Five-year packet from a major carrier: Heron splits the PDF into annual sections, parses each period, and writes totals and ratios into fields. Underwriters start analysis without touching the raw file.
• Loss run missing the current quarter: The system flags the gap and triggers a targeted request naming the exact date range. Brokers respond with the missing pages on the first try.
• One large open claim with reserves: Parsed fields expose the reserve size and the date of last activity. The deal moves to a targeted review path rather than a generic hold.
• Mixed submissions during a spike: Intake stays stable because parsing and exception routing scale automatically. Queues do not grow even when volume doubles.

Benefits of Using Heron for Parsing Loss Runs

• Speed: Important fields appear as structured data seconds after intake, which shortens the time to review.
• Accuracy: Values come from the source and pass sanity checks, which reduces rework.
• Consistency: Every carrier format maps to the same schema, which improves reporting quality.
• Scale: High-volume days do not overwhelm staff, which keeps SLA promises credible.
• Clarity: Underwriters find what they need in the record view, which reduces file opening and context switching.

FAQs About Parse for Loss Runs

How does Heron handle loss runs from unfamiliar carriers?

Heron looks for common insurance phrases, table structures, and header patterns that appear across carriers. When a layout is truly novel, confidence scores guide a quick review so accuracy remains high while the model learns from new examples.

Can the parser separate multiple policy periods inside one PDF?

Yes. Heron splits sections by period markers and policy identifiers, then maps each segment to its own coverage dates. The system writes fields for each period so underwriters can compare year by year without manual work.

What happens if totals in the summary do not match line items?

Heron captures both numbers, adds a discrepancy note, and flags the record for awareness. Underwriters can drill into fields and source locations to confirm which figure is appropriate for the decision at hand.

How does parsing support missing-info outreach to brokers?

Parsed date ranges and policy numbers make requests specific. Heron generates a clear message that lists the exact months or documents required so brokers can respond once with the right files.

Is the parsed data auditable for compliance reviews?

Yes. Every field links back to a page location in the source document when available, and every update carries a timestamp and user attribution. Auditors can move from a CRM value to the document evidence in a few clicks.