Insights Accessibility
When a leading automotive retailer needed a new invoice automation flow, their internal IT team couldn’t deliver it — not because the work was too complex, but because they lacked the bandwidth and the right tooling. ENIT stepped in, and using ENIT Flowbuilder alongside OpenText Exstream, went from brief to go-live in under two months. Here’s what that looked like in practice.
The Problem: A Gap Between Need and Delivery
The retailer operates an e-commerce platform where customers purchase vehicle accessories and extras around the clock. Every purchase trigger an invoice — one that must be issued, signed, and reported to the national tax authority, all in a compliant and auditable way.
Customer had already an OpenText Exstream doing invoicing from SAP and other legacy systems. When a new invoice flow was required to handle the invoices from the e-commerce platform, the project landed on the desk of the central IT team. They assessed it and concluded they couldn’t take it on — a shortage of available resource and familiarity with the integration layer meant the timeline would stretch well beyond what the business needed.
ENIT was already engaged on the account. The brief came across in early discussions and the ENIT team indicated they could turn it around quickly. Development, testing, and delivery happened less than two months.
How ENIT Flowbuilder Shortened the Development Cycle
The speed came from the architecture. Rather than writing integration code from scratch, the team assembled the flow visually using ENIT Flowbuilder — ENIT’s own low-code integration platform built for exactly this kind of process orchestration.
The flow handles the full end-to-end process:
- Polls the retailer’s e-commerce platform API on a schedule, paginating through new invoices and credit notes
- Fetches each document as JSON and converts it to XML for downstream processing
- Deduplicates against a processed archive, so no invoice is issued twice
- Sends the XML to government tax authorities — and returns a cryptographic signature to the invoice data
- Embeds a QR code on each invoice that consumers can scan to verify the document’s validity against the tax authority’s own portal
- Passes the signed document to OpenText Exstream, which renders the final PDF and distributes it — primarily by email
The flow also tracks every transaction in a database — pull timestamps, invoice counts, batch IDs — and handles failures gracefully: if an SFTP push doesn’t go through, the file moves to a retry folder and is resent on the next cycle.
This is not a hello-world integration. It handles multiple document types, pagination, error recovery, deduplication, regulatory signing, and audit logging. The fact that it was built and delivered in six weeks says more about the tooling than the simplicity of the task.
Why tax signature Compliance Didn’t Slow Things Down
For many integration projects, compliance requirements add scope and uncertainty. In this case, the signature step — which adds a government-mandated cryptographic signature to every invoice before it can be legally issued — was treated as just another node in the flow.
Because ENIT Flowbuilder separates the integration logic from the output layer, adding a regulatory processing step doesn’t mean re-architecting the pipeline. The data passes through, gets signed, and continues to Exstream. Each stage is visible, auditable, and independently testable.
This pattern translates directly to other compliance mandates: ZUGFeRD in Germany, PEPPOL for cross-border B2B transactions, or Swefaktura for the Swedish public sector. The underlying principle is the same — a defined transformation step, not a new project.
What This Means for Process and Product Owners
The outcome here wasn’t just a faster delivery. It was a different model for how integration work gets done.
Traditional development cycles — define, procure, develop, test, deploy — make sense for large platform builds. They’re disproportionate for integration work, where the logic is well understood but the execution is constrained by available resource and tool flexibility. ENIT Flowbuilder was built to close that gap: flows are assembled visually, changes are auditable, and business logic lives in the flow itself rather than buried in application code.
For a process owner, that means you can read what the system does. For a product owner, it means change requests don’t require a development sprint. For a solution architect, it means the integration layer is maintainable without tribal knowledge.
Thinking About a Similar Problem?
If you’re dealing with an invoice process that depends on legacy integrations, a compliance deadline that IT says they can’t meet in time, or a delivery backlog that keeps growing — we’re happy to walk you through what this could look like for your environment.
Contact ENIT to start the conversation, or read more about ENIT Flowbuilder at enit.se.
