Vendor data, reconciled and surfaced internally — without opening a hole in a locked-down network.

The situation

A UK-wide enterprise distribution group needed vendor data — pricing, stock, product data, arriving from multiple external vendors on their own schedules — ingested, reconciled against an internal data warehouse, and made usable to internal teams through a portal. Nate led the engineering squad delivering it, as Technical Lead. The catch, and the thing that made this an interesting engineering problem rather than a plumbing exercise: none of it could involve opening the locked-down corporate network to the outside world.

Constraints

• Zero-trust corporate network. The estate is VNet-secured, nothing public-facing. Any integration pattern that assumes an open inbound endpoint is a non-starter before the first line of code.
• Vendor data on vendors' schedules. External vendor feeds don't arrive on a schedule the client controls, and they don't arrive in one format. The integration layer is the product here — there's no clean, uniform input to build against.
• Enterprise change-control cadence. This runs inside a large organization's release process, not a startup's ship-whenever rhythm. Every architectural choice has to hold up to a slower, more scrutinized delivery cadence.

Architecture decisions — and why

The integration was built event-driven, not batch. Vendor feeds are inherently asynchronous — they show up when they show up, in whatever shape the vendor's system produces that day. An event-driven model gives you retry and replay semantics for free; a batch job that fails partway through a vendor's file is a manual cleanup problem, while an event-driven pipeline can dead-letter the failure, retry it, and replay it once the fix ships — without a human babysitting a cron job.

Within Azure, the division of labor was deliberate: Service Bus for work, Event Grid for facts. Service Bus queues carry the units of work that need guaranteed, ordered processing — a vendor file that needs to be ingested, transformed, and reconciled, once, correctly. Event Grid carries the facts that other parts of the system might care about — "a new reconciliation run completed," "a mismatch was found" — the kind of signal that can fan out to multiple interested subscribers without the publisher needing to know who's listening. Using one queueing tool to do both jobs is a common shortcut that works fine until the system needs to scale in either dimension; splitting them early avoided that ceiling entirely.

Snowflake sat as the reconciliation ground truth — the single place where "does the vendor's data match our data" gets answered authoritatively, rather than that logic getting duplicated across services that each hold a partial view.

And the decision that shaped everything else: VNet integration and a zero-trust posture were treated as a first-class architectural requirement, not a hardening pass applied afterward. That ordering matters more than it sounds like it should. Security bolted on at the end constrains you to whatever the existing architecture happens to allow; security designed in from the first diagram means the system's shape is already compatible with the constraint, and nothing has to be re-plumbed to satisfy a security review six weeks before go-live.

Stack

What shipped

A cloud-native, event-driven integration platform, plus a secure internal portal surfacing the reconciled vendor data to internal teams — running live in production, handling ongoing reconciliation as new vendor feeds arrive.

Measured outcomes

In enterprise integration, the architecture is the security story.

Lessons

Event-driven design buys you operability — dead-letter queues, replay, independent scaling of producers and consumers — not just the decoupling it's usually sold on. On an integration surface where the inputs are genuinely unpredictable, operability is the property that actually matters day to day, long after the initial build is done.

And leading a squad from design through to a live production system was, in a real sense, the deliverable itself — as much as any individual service or pipeline. The lasting value of an engagement like this isn't just the code that ships; it's a team that now understands why the system is shaped the way it is, and can extend it correctly without Nate in the room.