Claims Management Tools That Actually Work
Most people in the insurance adjusting world don't talk enough about the software layer beneath the actual adjuster work. They talk about soft skills, negotiation tactics, the big closures. But the daily grind lives in whatever tool you're using to track files, route them, calculate reserves, and spit out documentation. There's one particular system that quietly handles this better than most of the bloated enterprise platforms everyone keeps pushing, and I want to walk through how to actually get it running and what it's good at versus where it breaks. First, let me be clear about what this is. It's a claims management workflow platform that started as an internal tool for a mid-size regional carrier in the Pacific Northwest, got open-sourced in parts around 2022, and quietly became a go-to for smaller independent agencies and third-party administrators who couldn't justify the licensing fees on Guidewire or Duck Creek. It's not flashy. The UI looks like it was designed by someone who genuinely didn't care about aesthetics. That's kind of the point. The core architecture revolves around a document-centric claims model. Every file is built around a document graph, meaning relationships between claim documents, adjuster notes, correspondence, and reserve entries are tracked explicitly rather than buried in free-text fields. This matters more than it sounds. When you're doing first-party property claims at scale and you need to pull every photo, every inspector report, every adjuster memo related to a specific occurrence date, the difference between a flat text field search and a graph-based query is the difference between fifteen minutes and forty-five.
Setting It Up
You can download the open-source core from their GitHub repository. The Docker Compose setup is straightforward if you've done this before. If you haven't, plan for a half-day just on dependency issues. The PostgreSQL schema has some non-standard conventions that trip up people who are used to commercial product installers doing all the heavy lifting. My recommendation: spin up a staging environment first. Don't point production at day one. The installation itself involves running the migration scripts against a fresh database, configuring the Redis queue backend, and then setting up the API gateway layer. The API gateway documentation is... adequate. It exists. It covers the standard CRUD operations for claims, parties, payments, and reserves. What it doesn't cover well is the custom webhook system, which is where the real power lives. Once the base instance is running, you'll want to configure at minimum the document ingestion pipeline. This is how claims get their photos, reports, and PDFs into the system. The default connector supports S3-compatible object storage. If your org uses Azure Blob or GCS, there are community-maintained connectors. I've used the Azure one and it works fine after you patch the authentication flow, which isn't quite right out of the box.
What It Does Well
The reserve calculation engine is genuinely solid. It's rule-based but flexible enough that you can define custom calculation chains. For auto physical damage claims, you can set up lookup tables tied to your local repair shop rates and the system will auto-populate reserve ranges based on damage patterns, location, and vehicle year. It cut our estimating time on standard fender-benders from about twenty minutes per file to roughly four. That's not hyperbole. We ran a side-by-side audit over three months before we fully migrated our low-severity auto line. The audit trail is another area where this thing quietly outperforms commercial options. Every action on a claim — reserve changes, status updates, document additions, note entries — gets a timestamped entry with the actor's ID, IP address, and the previous state of any modified fields. This is critical for compliance reviews and fraud investigation. I've pulled these audit reports for two separate regulatory examinations without needing to involve IT. That alone justifies the setup effort for most small to mid-size operations. Third, the reporting module. It's basic but functional. You can build custom reports using a visual query builder that generates SQL behind the scenes. The output goes to CSV, Excel, or PDF. It doesn't have dashboards in the modern sense — no real-time widgets or drill-down charts. But for a weekly reserve coverage analysis or a monthly closure rate report by adjuster, it gets the job done in about three minutes of setup time.
Get the Full Details
Where It Falls Apart
Let me be direct about the limitations. The mobile experience is essentially nonexistent. There's no native app. The web interface is responsive at a basic level, but anything beyond reading a claim file and adding a note is painful on a phone. If your field adjusters need full functionality on mobile, this isn't going to work for you. You'd be better off with a commercial solution that has an actual mobile product. Integration with legacy policy administration systems is another weak spot. There are APIs for pulling policy data, but the authentication and data mapping requires custom development work. We spent about three weeks building a connector between this system and our existing policy admin platform. It works now, but that's three weeks of developer time you won't find in any quick-start guide. The search functionality is adequate for structured fields but weak on full-text document search. If you need to search the contents of uploaded PDFs — say, searching for a specific clause in an inspection report — you're going to need to integrate a separate search engine like Elasticsearch. The system supports this integration, but it's not turnkey. We set up Elasticsearch on a separate container and pointed the claims search at it. That added another day of work and some ongoing maintenance responsibility.
A Real-World Problem I Hit
Here's a specific edge case that nearly cost us a compliance issue. About six months after we went live, we had a claim where the reserve was adjusted three times in rapid succession — $8,000, then $12,500, then back down to $9,000 — all within a two-hour window on a Friday afternoon. The audit trail showed the adjustments, but it didn't flag why the third adjustment reversed the second one. The system records that the change happened, but it doesn't enforce any kind of change-reason requirement on reserve modifications. The workaround was straightforward but required a bit of configuration. I set up a custom validation rule through the webhook system that fires before any reserve change gets committed. If the delta between the old and new reserve exceeds a threshold we define — we set it at 20% — the system requires a mandatory comment field in the adjustment form. If the comment is blank, the change is rejected. This pushed the responsible adjuster to document the reasoning at the point of entry rather than leaving it to memory. We haven't had an unclear reserve adjustment since we implemented this, and it took maybe two hours of configuration work. There's also a known issue with bulk claim imports when the source data contains null values in certain date fields. The migration script will silently skip those records rather than erroring out, which means you can import five hundred claims and not realize that twelve of them were dropped because of a formatting inconsistency in the original spreadsheet. Always run a count verification after any bulk import. Compare the source record count against what actually landed in the database. We learned this the hard way during our initial data migration and lost a day re-importing a batch that should have been verified on import.
Who Should Actually Use This
This isn't for everyone. If you're a large national carrier with dedicated IT staff and millions in technology budgets, stick with Guidewire. The enterprise support, the integration ecosystem, the vendor relationships — it's a different tier. This tool fills a gap between spreadsheets and enterprise platforms. It's for teams of roughly ten to fifty adjusters who need proper workflow management without the six-figure licensing footprint. It's also worth noting that the community support model works only if you're comfortable reading code and contributing fixes. The official support channels are slow. The Discord server has maybe two hundred active members at any given time. But the people who hang out there are usually the ones who've actually deployed this in production, so the advice tends to be practical rather than theoretical. One more thing nobody mentions in the documentation: the backup strategy matters more than you'd think. The default configuration backs up the database daily, but document storage backups aren't configured out of the box. You need to set up a separate cron job or scheduled task to sync your object storage bucket. We had a minor server failure last year that took the primary instance down for eight hours. The database came back from backup without data loss. But two days' worth of uploaded claim photos were gone because nobody had configured the document replication. That was a costly lesson in what "it's open source, I handle my own infrastructure" actually means.
