Email chains, manual handoffs, invoicing chaos. One automated workflow that made it disappear.

The situation

Iver's enterprise customers needed quotes for service upgrades and expansions. The process started with a Key Account Manager (KAM) receiving a request, passing it to a Technical Account Manager (TAM), who then coordinated with engineers to scope the work. Days later, a quote would come back. Once signed, the contract details were manually entered into the invoicing system.

The result: quotes took days to generate, context was lost across handoffs, and invoices frequently didn't match what customers had signed. The manual chain created friction at every step, and customers were frustrated by the lack of transparency and speed.

What I found

I mapped the entire Quote-to-Pay workflow by shadowing KAMs, TAMs, and engineers through multiple customer requests. The pattern was clear: every handoff introduced delay and information loss. Engineers were rebuilding context from scratch. TAMs were translating between business and technical language multiple times. KAMs were chasing status updates instead of managing accounts.

"Every handoff was a game of telephone. By the time the quote reached the customer, it had been reinterpreted three times."

The invoicing mismatch was a structural problem: the signed contract lived in one system, the invoice was generated from another, and there was no automated validation between them. When customers complained, resolving the discrepancy required manual reconciliation that could take weeks.

The approach

We built a self-service quotation workflow directly into the customer portal. Customers could select the services they wanted to upgrade or expand, see pricing in real-time, and generate a quote without waiting for a KAM. For complex requests that still required technical input, the workflow automatically routed to the right engineer with all the context pre-filled.

The contract generation step was integrated with the invoicing system. When a customer signed a quote, the contract details were automatically passed to invoicing with validation rules that flagged any discrepancies before the invoice was sent. This eliminated the manual data entry step that had been the source of most mismatches.

We also added a status tracking feature so customers could see where their quote was in the process. KAMs and TAMs could see the same view, which reduced the number of "where's my quote?" emails by making the workflow transparent to everyone involved.

The rollout was phased. We started with simple upgrade requests that didn't require technical input, validated that the self-service flow worked, then expanded to more complex scenarios. Internal teams were trained on the new workflow, and we monitored adoption closely to catch friction points early.

The outcomes

Quote generation time dropped from days to hours. Customers who used the self-service flow could generate quotes instantly for standard upgrades. Complex requests that still required technical input moved faster because the context was pre-filled and routing was automated.

"The workflow eliminated an entire category of customer complaints."

Invoicing mismatches dropped to near-zero once the automated validation started catching discrepancies before invoices were sent, and when issues did occur, the shared context between contract and invoice made resolution faster. For enterprise onboarding, trust documentation cut the validation cycle from several weeks to under a month, and KAMs spent less time chasing status updates and more time managing accounts.

What this taught me

The invoicing mismatch wasn't a data quality problem. It was a systems design problem: two teams owned two systems with no shared contract between them, so discrepancies were structurally guaranteed. The fix wasn't better data entry or stronger process discipline. It was creating a single source of truth both systems referenced.

Shadowing KAMs, TAMs, and engineers through real quote requests surfaced something a survey wouldn't have: the bottleneck wasn't any individual's inefficiency. It was context loss across role boundaries. Once the workflow carried context automatically, the delays that remained were the ones that genuinely required human judgment, and those became visible for the first time.

Starting with simple upgrade requests before expanding to complex scenarios gave us a working system to iterate from rather than a big-bang rollout to debug. The phased approach wasn't caution: it was how we got usable signal fast enough to act on.