Real-Time Inventory Visibility for a Multi-Location Specialty Retailer

TL;DR

A growing specialty retailer running multiple locations was losing sales and tying up capital to a problem that looked operational but was architectural: a POS system built to track inventory one store at a time. Each location kept its own stock count, and nothing reconciled them. The result was a network that couldn't see itself — items oversold at one site while sitting idle at another, stock moved between locations by hand, and reorder decisions made on numbers that were already stale. Kynera was brought in not to replace the POS, but to build the layer it never had: an event-driven data architecture that standardizes every inventory movement into a common record, maintains one running total per item across all locations, and pushes the updated picture out the moment anything changes. The result was a single, network-wide view of stock in real time — replacing per-store blind spots with a shared source of truth, cutting localized stockouts and overselling, freeing capital previously trapped in dead inventory, and eliminating roughly eight hours a week of manual cross-location reconciliation.

‍

‍

The network couldn't see itself

A specialty retailer operating across a multiple locations network was running each store on a Square POS setup that did exactly what it was built to do — track inventory for one location — and nothing more. Every site maintained its own stock count in isolation. Sales, manual counts, and transfers registered locally, and there was no layer above them holding a combined picture. On paper the company had one inventory. In practice it had as many separate inventories as it had storefronts, none of them aware of the others.

At a single location, that architecture is invisible. Across a network of this size, it's the source of nearly every inventory problem the business has. A customer asks for an item shown as out of stock; two stores over, the same item is sitting on a shelf. The system can't say so, because no system holds both facts at once. The retailer had grown past the point its tooling was designed for — each new location made the blind spot wider, not just longer.

‍

The ask

The request that reached Kynera was framed operationally, not architecturally: stop the overselling, stop the manual stock chases between locations, and give the team one place to see what's actually in stock across the network. The company understood the symptoms precisely. What it hadn't named was the cause — that these weren't separate problems to be patched individually, but a single missing layer expressing itself in several places at once.

‍

What was actually behind it

The overselling, the blind transfers, the trapped capital — none of these were POS failures. Square was accurate about the one thing it was designed to know: the stock in front of it, at one location. The failure was that nothing sat above the individual stores to reconcile those separate truths into a shared one.
‍

That distinction mattered for the solution. The instinct in this situation is to replace the POS — assume the tool is wrong and rip it out. But the POS wasn't wrong; it was scoped for a single location and being asked to behave like a network. Replacing it would have meant a disruptive, costly migration for a business of this size, to solve a problem that didn't require touching the system of record at all. The actual gap was a layer that didn't exist yet: something to sit above the existing systems, consume what they already emit, and maintain the one number none of them could hold alone — a running total per item across every location. The right move wasn't to rebuild the foundation. It was to build the layer the foundation was missing.

‍

‍

Our approach: standardize the event, centralize the truth

Kynera designed the system around a single principle: every inventory movement, anywhere in the network, becomes one standardized record — and every one of those records updates a shared total the instant it happens.

‍

‍

Event ingestion and standardization.

Inventory doesn't change in one way; it changes through sales, manual stock counts, and inter-location transfers, each arriving in a different shape from Square POS and the overflow locations. The system consolidates all of them into a single common record — item, location, quantity, timestamp — the moment each event occurs. A sale at one storefront, a count adjustment at another, a transfer out of overflow stock: different events, normalized into the same structure in milliseconds, so that everything downstream reads from one consistent format rather than reconciling several.

‍

Unified Data Layer

Those standardized events feed a centralized layer that maintains one running total per item across all locations. This is the number the business never had — not the stock at store one plus a manual guess at the others, but a single authoritative figure that accounts for every location and every unit of overflow at once. It doesn't replace the Square systems underneath it; it sits above them, consuming what they already produce and holding the combined picture none of them was built to see.

‍

Event-driven synchronization

The layer updates by push, not by schedule. The moment an event registers anywhere in the network, the shared view reflects it — no overnight batch, no periodic refresh window during which the numbers drift out of true. This is the difference between a report and a live picture: a nightly sync tells you what was true yesterday, which is exactly the staleness that produces overselling. Push-based sync means the total a manager reads is the total as it stands right now.

‍

Operational interface

On top of the layer sits a live dashboard built for the decisions the network actually makes: real-time stock by location, so staff can see instantly where an item is available; automated low-stock threshold alerts, so a shortage surfaces before it becomes a stockout rather than after; and cross-location sales trends, so the picture informs what to reorder and where. The infrastructure is invisible to the people using it — what they see is a single screen that finally answers the question the old architecture never could.
‍

‍

Built to extend, not just to fix

The architecture solves today's problem, but the reason to build it this way rather than patch the symptoms is what it makes possible next. Once every inventory event across the network is captured in one standardized, reliable structure, the harder work — the data foundation — is already done. That same event history is exactly what predictive reordering runs on: localized demand patterns, per-location velocity, the raw material for forecasting and automated replenishment. The system was built so that the next step isn't a second project starting from scratch, but a capability layered onto a foundation that's already in place.

‍
‍

Results

‍

Visibility

The network gained a single, shared stock picture in real time — replacing per-location blind spots with one authoritative view. The core cause of localized stockouts and overselling was removed: the system can no longer show an item as unavailable at one site while it sits in stock at another, because both facts now live in the same total.

‍

Capital

Proactive low-stock monitoring surfaces shortages early enough to act on deliberately, which cut the emergency inter-location transfers the old blind spots forced. The same visibility exposed the capital trapped in dead stock — inventory sitting unsold at one location that the network couldn't see to redistribute — and freed it to be managed rather than stranded.

‍

Reconciliation

Roughly eight hours a week previously spent manually cross-referencing stock across locations disappeared, because the reconciliation now happens continuously and automatically at the data layer. Reorder decisions moved off spreadsheet guesswork and onto a verifiable, current picture — from estimating what each store probably holds to reading what the network actually holds.

‍

‍

The takeaway

The retailer's inventory problem was never really about inventory. It was about architecture — a set of systems each telling the truth about its own corner, and no layer above them to make those truths agree. Overselling, manual transfers, and trapped capital weren't separate issues to be solved separately; they were the same missing layer, surfacing in three places. Build the layer, and the symptoms resolve together.