Omegaswift
Industries

Retail & eCommerce

The shop is the easy half. We build the part behind it, where stock, orders and returns have to agree with each other before a customer notices they do not.

How We Help

What the work looks like in Retail & eCommerce.

One Number for Stock

Almost every retail problem we are called in for is two systems disagreeing about how many of something exists. We make one of them the source and everything else a reader of it, then reconcile on a schedule so a drift shows up as an alert rather than as a cancelled order. Where a marketplace or a third party warehouse holds its own count, we build the sync with an explicit rule for who wins, because leaving that undecided is what produces oversells at exactly the moment they cost most.

The Order After Checkout

A paid order still has to reach picking, dispatch, the courier and the accounts package. We build that pipeline as steps that can each fail and be retried, rather than as one long process that leaves an order half placed when a courier API is down. Support gets a screen showing where any order actually is, which removes most of the calls that start with somebody promising to check and ring back.

Peak

Retail traffic is not flat, and testing against an average day tells you nothing about the day that matters. We load test against your own peak, taken from your own history, and fix what falls over before the season rather than during it. The parts that cannot be made fast enough get cached deliberately, with a rule for what a stale price or stock figure is allowed to do, so degradation is a decision you made rather than a surprise.

The Trading Calendar Owns the Roadmap

In most retail businesses a handful of weeks pay for the year, and everything technical gets scheduled around them whether anybody writes that down or not. So we write it down. Work intended to be live for the season is finished and released well before the freeze rather than in the week the traffic arrives, because a change that ships during peak has no safe window to be fixed in. The site still has to move during the freeze, so the things merchandising needs, which are prices, promotions, banners, categories and copy, are built as configuration rather than as code from the start. Anything that genuinely must ship goes behind a switch somebody on duty can turn off without a release. A project starting in October is a project for next year.

Promotions Are Where the Money Quietly Leaves

Discounting gets treated as marketing configuration and behaves like financial software. Two codes that were never meant to combine will be combined within hours of somebody posting them on a deals forum. A percentage applied before a multi-buy gives a different answer to the same percentage applied after it, and rounding at line level against rounding at basket level produces the mismatch your finance team finds at month end. A single-use code with no per-customer limit is not single use. So the rules get written down and tested like any other calculation: the awkward baskets built as cases, the stacking behaviour made explicit rather than emergent, and what a promotion actually cost reported against what it was expected to cost while there is still time to stop it.

Common Challenges

What we are usually called in to fix.

  • Stock shown as available on the site after the last one has left the shelf
  • Orders re-keyed by hand between the store, the warehouse and the accounts package
  • A checkout that slows down on the one weekend of the year that pays for the others
  • Returns and refunds tracked in an inbox rather than against the order
What You Get

What is different once the work is done.

  • One stock figure the site, the shop floor and the warehouse all read from
  • Orders that reach picking and accounts without anyone typing them twice
  • A checkout load tested against your own peak rather than an average day
  • Returns handled against the original order, with the refund state visible to support
What we build

Software we build for retail & ecommerce

  • Storefront and checkout

    The shop itself, built around the checkout rather than the homepage. Most of the difficult work is in what the basket has to know about stock, delivery promise and price at the moment it is asked.

  • One stock service

    A single figure the site, the tills and the warehouse all read from, reconciled on a schedule so drift raises an alert instead of producing a cancelled order and an apology.

  • The order pipeline

    Payment, picking, dispatch, courier and accounts as steps that can each fail and be retried, rather than one long process that leaves an order half placed when a courier API is down.

  • Returns and refunds

    Handled against the original order, with the state visible to support before the customer rings, including the awkward window where a refund is issued and the goods are still in transit.

  • Product data and listings

    One place where a product's description, images, attributes and prices live, so a change reaches the site, the marketplace feed and the shop floor without three people editing three systems.

  • Channel and marketplace integrations

    Listings out, orders in, and stock kept honest across all of them, with the rule for who wins a disagreement decided deliberately rather than discovered in the middle of a sale.

Systems

What we work alongside

  • Ecommerce platforms

    We build against the platform you already have. Replacing it rarely fixes the joins between systems, and the joins are where the actual problem usually turns out to live.

  • Point of sale and store systems

    Tills, click and collect, and store stock. A shop floor that cannot see web orders will sell the same unit twice, and the customer meets that at the counter rather than online.

  • ERP and accounting

    Where orders, invoices and stock valuation end up. Finance will accept a new front end and will not accept a month end that has become harder to close.

  • Warehouses and third party logistics

    A WMS or a 3PL that owns picking and often its own count. The interesting question is always which count wins, and how quickly you find out that it did not.

  • Marketplaces and channel feeds

    Each with its own listing rules, dispatch deadlines and penalties for cancelling an order you could not fulfil. Those penalties are what make shared stock a design decision rather than a setting.

  • Couriers and payment providers

    Labels, tracking, settlement files and refunds. Both sets of integrations fail occasionally and neither should be able to leave an order in a state nobody can see.

Where to start

Where these projects usually begin

  • Reconciling one stock figure

    Take the two systems that disagree, decide which owns the count, and put a scheduled check between them. Small work, and it removes the most visible failure in retail.

  • Taking the retyping out of orders

    Usually between the store, the warehouse and the accounts package. Staff can tell you exactly where it happens, and it is the change they notice first.

  • A peak readiness review in summer

    Load tested against your own history, with the failures fixed while there is still time to fix them properly. Booked in July, not in October.

  • Returns against the order

    Normally triggered by a January nobody wants to repeat, when refunds were tracked in an inbox and support could not say what had been paid back.

FAQ

Questions we get asked

Why does our stock figure keep being wrong?

Almost always because two systems each believe they own it. The fix is making one the source and every other a reader of it, then reconciling on a schedule so drift raises an alert instead of producing a cancelled order. Where a marketplace or third-party warehouse holds its own count, the rule for who wins has to be explicit rather than assumed.

Can you connect our website to the shop tills and the warehouse?

That is the normal shape of this work. The site, the point of sale and the warehouse each need to see the same stock and the same order, and the integration layer belongs in one place so replacing any of the three later is contained. Most of the value shows up in orders that no longer need typing twice.

Will the site cope with a sale weekend?

Only if it is tested against your own peak rather than an average day. We load test from your own history, fix what fails before the season, and decide in advance what is allowed to degrade: a slightly stale stock figure, a queued email, so that behaviour under load is a decision rather than a surprise.

Do we have to replace our platform?

Not usually. Most of what makes an online shop work badly is the joins between systems rather than the shop itself, and replacing the platform without fixing those simply moves the problem. If the platform genuinely is the constraint, that case should be made with evidence from your own data.

When should we start work for peak?

By early summer for anything structural, and that is not a sales line. Load testing is only useful if there is time to act on what it finds, and what it finds is rarely small: a query that is fine at a hundred orders an hour and not at a thousand, a third-party tag adding a second to every page, a stock check that calls an external system on every basket view. Each fix then has to be released, watched and left alone for a few weeks before the traffic arrives. Work that starts in October is limited to configuration, caching and turning things off, which is a legitimate way to survive a season but is not the same as being ready for one.

Can anything be changed during the freeze?

Yes, and deciding what in advance is the entire point of having one. Content, prices, promotions, banners and category changes have to remain possible during trading, because merchandising cannot stop for two months and will find a way round a rule that says it must. Code is different. A release in peak week has no comfortable window to correct itself in, so what ships during a freeze is limited to defects with a real commercial cost, goes out behind a switch that can be turned off without a deployment, and has a named person watching it afterwards. The freeze that fails is the one nobody agreed with the trading team, because they will simply ask a developer directly.

Should our marketplace listings share the same stock pool?

Usually yes, with a buffer, and the size of that buffer is a commercial decision rather than a technical default. Marketplaces punish cancellations harder than your own site does, since a late dispatch or an order you cannot fulfil affects your seller metrics and eventually your visibility, so the last few units are the ones worth protecting. Shared pools also need a sync fast enough to matter, because a stock update that takes twenty minutes during a sale is simply a queue of oversells waiting to happen. Where a marketplace holds its own fulfilment stock, treat that as a separate location with its own count rather than as part of the main pool, and reconcile it on the same schedule as everything else.

How should returns and refunds actually work?

Against the original order, with the customer, support and finance all reading the same record. What goes wrong is the middle rather than either end: the goods are in transit, the refund has been promised, the payment provider has not settled it, support cannot see any of that, and the customer rings twice and gets two different answers. So a return gets its own states, each of them visible, and the refund records what was actually paid back rather than what was expected to be. Decide the policy questions first, including who pays return postage and what happens when an item comes back unfit to resell, because the software cannot make those decisions for you and will expose them either way.

Ready to talk about your IT?

We are happy to answer any questions you have and help you work out which of our services fit your needs.