Tip: click @Pulse AI in the post to tag us.
From idea to reality
What we built
The system ingests four files that disagree with each other an HR roster, payroll records, a licensing CSV, and a weekly schedule PDF and produces one trusted picture of Harborview's staff: who works where, whether credentials are current, and whether scheduled hours match what payroll is paying. The data model is two tables: entities and edges. Every real-world thing (Employee, Facility, License, PayrollRecord, ShiftAssignment) is an entity row with a UUID and a JSONB attrs column. Relationships are edges. Adding a new industry's entity types means inserting rows with a different type field. No migration, no new tables. Runs on SQLite; ports to Postgres unchanged. Identity resolution runs in a fixed order. The HR roster is the only source that can create a new Employee. You can't be paid or scheduled without an HR record first. Licenses resolve next on exact license number, corroborated by name. Payroll and schedule come last, resolved against what the first two steps already confirmed. Every match needs two independent signals to agree. A license number that matches but whose name belongs to someone else is a different, more urgent problem than the same person with their name formatted two ways. The system flags which signal broke and shows both values side by side, because collapsing those into one generic ambiguity flag would hide that distinction. Facts that can't resolve are stored in a pending state, not dropped. Ingestion keeps running regardless. The flagging engine has eight named flag types. Each carries a plain-language reason generated at flag time, not a code for a human to look up later. There are two separate approval statuses: SST approval at the employee level (resolved identity, valid license) and Payroll approval at the entry level (is this specific pay period payable?). They're separate because a license lapse midweek doesn't just reject the whole payroll entry. Some of those days were worked under a valid license. That case gets its own flag, partial_period_license_lapse, which routes to a human. The system doesn't decide how that period gets paid. The rule engine is a function call that runs inside the same ingestion step. No Kafka, no scheduled jobs. Gate rules can change an entity's status field; flag rules only write to the flags table. The CLI groups open flags by entity rather than by row, so a reviewer sees one employee's full picture at once. To adapt this for a different industry: change the entity types, edge types, and rule configs. Everything else stays the same.