Implentio

Implentio's product audits 3PL invoices in two domains. Freight audit catches overcharges, accessorial errors, and duplicate charges and reconciles them at the order level. Fulfillment audit catches mispicks, wrong quantities, packaging mistakes, and SLA failures. Both run on a rules engine that maps fee sheet logic onto raw invoice data.

When I joined, the technical depth was real. The business surface wasn't there yet. The design system wasn't buildable, the labeling taxonomy that powers the rules engine needed structure, and onboarding was a two-month human pipeline.

Three months, embedded with the CPO and CTO. The founders bring deep expertise in 3PL, fulfillment, consumer businesses, CPG, and clothing, and we worked closely throughout the engagement with multiple meetings per week. I led three workstreams.

When I arrived, there was no token layer, no semantic naming, and no layout patterns an engineer could reference without opening a Figma file and interpreting what they saw. Every feature required a conversation about what a component meant before anyone could write a line of code.

I rebuilt the library. The frontend team was the first customer. Components mirror how they compose in code. Tokens are intent-based (surface-primary, text-muted, spacing-section). Components, variants, and states use the same vocabulary in Figma and the codebase. Reusable layout patterns cover data tables, detail panels, form flows, and dashboard compositions. The goal was 1:1 fidelity between Figma and code.

Implentio's core bet is mapping fee sheet rules onto raw invoice data with precision. 3PL billing is sprawling: hundreds of fee categories, carrier-specific surcharge logic, agreement-level exceptions, volume-based tiers, accessorial charges that vary by carrier, service level, and geography, and on the fulfillment side, pick/pack fees, kitting adjustments, storage tiers, and SLA penalties. The first 90% of automated auditing is where manual audits already sit. The last 10% is where the recoveries live, worth thousands per month per customer.

I co-designed the labeling schema and taxonomy with the CPO and CTO. It was the hardest part. Every label feeds the ML models that power automated auditing, so a mislabeled surcharge category doesn't just produce a wrong number on one invoice. It degrades model accuracy across every future invoice that shares the pattern. The categorization structure shapes everything downstream of it, so the work had to be designed against both layers at once: the user-facing labels and the model that consumed them.

One labeling decision crystallized why this work had to be designed against both the UI and the model behind it. 'Duplicate charges' looks like a binary tag. It isn't. A duplicate that's a literal re-bill of the same SKU on the same order is straightforward and auto-recoverable. A duplicate that's a charge for an item already counted in a kit-line on the same order is harder, because the right answer depends on the customer's bill of materials. A duplicate that's a re-charge for a return-to-stock item billed at outbound is harder still, because it depends on the inventory ledger and the carrier's settlement window.

Each subclass has a different recovery posture, so the labeling schema had to distinguish them as their own categories rather than collapse them into one tag. That distinction lived at the intersection of the customer-facing UI (where a 3PL operator was triaging the queue) and the rules engine (where the recovery action got dispatched). I worked the call from both sides.

The original onboarding was a human pipeline. An account manager scheduled a kickoff call, the customer sent fee sheets and sample invoices over email, a technical account manager wrote custom scripts to parse PDFs and CSVs, data was manually labeled, multiple validation calls confirmed accuracy, and the platform was configured with customer-specific rules. Every step required coordination between multiple people, and delays compounded. Two months was the norm.

I redesigned the flow to flip the ratio from 90% human and 10% software to 20% human and 80% software. Customers now upload fee sheets and invoices directly through structured upload flows that validate inputs in real time. The system parses documents and applies the rules engine taxonomy to pre-categorize fees. Ambiguous items get flagged for human review; everything else auto-categorizes. Early audit results appear as data is ingested. The 20% that stayed human was the high-judgment work: validating edge-case categorizations, confirming agreement-specific exceptions, and reviewing the first batch of results with the customer.

The frontend team shipped faster with 1:1 Figma-to-code fidelity. Onboarding fell to two weeks. The rules engine taxonomy was structured for precision at the last-10% margin where recoveries live. Months later, Implentio closed a significant funding round, and the platform now serves True Classic, Magic Spoon, Seed Health, and Nood with a guaranteed $60K per year minimum recovery for qualifying customers.