Software case studies: systems that had to work on Monday morning.
Stone Age Software's nineteen case studies describe production software that runs real operations, with every client anonymous: carrier integrations, B2B variance reconciliation, warehouse, returns and wave-planning automation, audit and safety controls, label printers and badge readers, and the release and monitoring work that keeps it all running. Each one sits under the practice that did the work.
Seven of them ran at one site whose own tracker timed the work: an estimated $277,986 a year in labour time saved. See the figures
| Practice | Case studies | What they show | Practice page |
|---|---|---|---|
| Enterprise IT Services | 1 | Eight label printers that stopped locking up | Enterprise IT Services |
| Logistics & EDI | 7 | Carrier integrations, B2B reconciliation, returns, damage cases, transfers, screen automation, wave plans | Logistics integration |
| Legacy Rescue & Modernization | 7 | Spreadsheet and clipboard replacements, audit and safety gates, access control, monitoring | Legacy modernization |
| Custom Software | 4 | Built from scratch: the Do-Engine, an approval board, a badge-reader bridge, a deployment pipeline | Custom software |
What seven of these systems save
$277,986 a year, estimated
Seven of the systems below ran at the same site, and its efficiency-savings tracker timed seventeen tasks by hand and again with the software. Each case study shows its own share and the tasks behind it.
| Case study | Tasks timed | Saved a year |
|---|---|---|
| Warehouse audits that can't be quietly passed | 3 | $128,378 |
| Making a badge reader work in a browser that can't see it | 1 | $41,731 |
| Equipment that locks itself out when it fails inspection | 1 | $40,320 |
| The order builds itself from the attachment | 8 | $33,348 |
| Automating a system that has no API | 1 | $29,044 |
| Financial controls on material leaving the building | 2 | $2,782 |
| Inventory variances that only close when they're actually gone | 1 | $2,383 |
| Total | 17 | $277,986 |
Estimated by the site's own efficiency-savings tracker: each task timed by hand and again with the software, the time saved valued at a fully loaded labour rate over a 252-day working year. Labour time only, to the whole dollar.
Enterprise IT Services case studies
The Enterprise IT Services case study fixes eight networked industrial label printers that wedged during bursts until someone power-cycled them. Jobs to each printer were serialized behind a per-printer lock, connections were closed cleanly, and the logo was stored in onboard flash and recalled by name, a logo payload about 150 times smaller.
The practice behind them: Enterprise IT Services
Logistics & EDI case studies
The Logistics & EDI case studies cover warehouses and their trading partners: live carrier integrations in place of tracking by browser tab, a variance register nobody can close by hand, return documents checked against the customer's item master, damage cases that open themselves, emailed transfer requests turned into orders, screen automation for a platform with no API, and wave plans.
Knowing where inbound freight actually is
Inbound shipments were tracked by opening carrier websites one tab at a time. We replaced the tabs with live carrier integrations and a workflow that routes exceptions to the person who can fix them.
Automating a system that has no API
The warehouse platform offered no write interface, so every transaction went in by hand. We automated the screens themselves — carefully enough to trust with live inventory.
Saves an estimated $29,044 a yearThe order builds itself from the attachment
Inventory transfer requests arrived as spreadsheets attached to email, in as many shapes as there were requesters, and were keyed in line by line. Now the attachment becomes a validated, reference-numbered order on its own.
Saves an estimated $33,348 a yearTurning a flat order backlog into a plan the floor can pick
A daily backlog feed said what had been ordered — not what could be built, released or picked. We built the pipeline that turns it into a wave plan, a queued pick order, and a screen that says where each one got to.
Inventory variances that only close when they're actually gone
Two systems held different quantities for the same parts, and the disagreement arrived as a spreadsheet attached to a recurring email. We turned it into a register that remembers — and that nobody is allowed to close by hand.
Saves an estimated $2,383 a yearReturn paperwork the receiving system accepts first time
Returns had to be announced to the warehouse system by hand-filling a hundred-column vendor template. We build the document from the check-in itself, check every line against the customer's item master, and track each upload through to accepted or failed.
Damage and shortage exceptions that open their own case file
A damage or count discrepancy is a claim, and a claim is worth whatever evidence is attached to it. We built the casework — photo capture at the point of discovery, a case that assigns and escalates itself, and a PDF report that goes out with the pictures already in it.
The practice behind them: Logistics integration
Legacy Rescue & Modernization case studies
The Legacy Rescue & Modernization case studies modernized systems that had to keep running: a platform that replaced a decade of spreadsheets, an audit gate that blocks sign-off on a mismatched scan, an equipment kiosk that replaced a clipboard, controls on hand-typed scrap paperwork, roles in place of a boolean access column, stockout projections and platform monitoring.
One application that replaced a decade of spreadsheets
A warehouse ran its floor on shared spreadsheets, emailed reports, and tribal knowledge. We replaced all of it with a single internal platform — and kept it running while people worked.
Warehouse audits that can't be quietly passed
Customer-facing quality audits ran on paper and a survey tool. We built a configurable audit platform with scheduling, escalation, approvals — and a gate that blocks sign-off when the scan doesn't match.
Saves an estimated $128,378 a yearEquipment that locks itself out when it fails inspection
Powered industrial trucks were signed out on a clipboard, and the fall-protection harness that some of them require was a separate honour system. We built a badge kiosk where the truck you pick decides the inspection you must pass — and which refuses to release anything that fails.
Saves an estimated $40,320 a yearFinancial controls on material leaving the building
End-of-life material left the site on paperwork typed by hand. We rebuilt the chain end to end and added the control nobody had: detection of inventory added after the paperwork was already filed.
Saves an estimated $2,782 a yearAdding a permission shouldn't mean altering the user table
Access was a boolean column on the user record, so every new screen was a schema change. We replaced it with roles that map to screens, credential checks that verify a second person without elevating the first, and a suspension path that fails closed.
Knowing you'll be out of stock before you are
Packaging and floor consumables were tracked on a shared spreadsheet, and the first reliable sign of a shortage was an empty shelf. We built a scanned stockroom with a background service that projects each item's stockout date against its lead time — and emails only when something new goes wrong.
Knowing the platform is slow before a person walks over to say so
An internal platform with almost two hundred routes had no way of reporting on itself. We instrumented it from the inside — request timing, worker-thread introspection, user analytics and a live console viewer — without letting the monitoring break the thing it monitors.
The practice behind them: Legacy modernization
Custom Software case studies
The Custom Software case studies show systems built from scratch and run in production: the Do-Engine, the app Stone Age Software runs its own business on; a board where a three-role approval gate moves each request; a local service bridging a badge reader to a browser on kiosks; and a two-slot deployment pipeline that keeps the live version up.
One app that runs the whole company, and keeps score
The Do-Engine is the operations app we built to run our own business: a task board, a client book, a document vault, invoicing, a help desk and a mail client in one page, with a single XP ledger scoring everything that gets finished.
A request queue where the approvals set the status
Internal software requests arrived by email and were approved in conversation. We built an intake form, a board and a three-role approval gate where the votes move the card — and gave requesters a private link so they can follow and edit their own request without an account.
Making a badge reader work in a browser that can't see it
Browsers are not allowed to talk to smartcard hardware, and the kiosk desktops were centrally managed. We built a small local service that bridges the reader to the page — then packaged it so it installs, restarts and heals itself across a fleet.
Saves an estimated $41,731 a yearDeploying to a system that nobody can stop using
A platform the whole site works on can't have a maintenance window. We built a two-slot deployment pipeline that refuses to stop the running version until the new one is proven up — plus an in-app changelog and a request board so users can see what changed and what's coming.
The practice behind them: Custom software
Why these read the way they do
Each case study leads with the problem rather than a number. The stats on every page are properties of the software itself, such as route counts, retry limits and poll intervals. The one figure about a client's operation is what a tool saved, in dollars, from the site's own savings tracker, published without the minutes, rates or headcount behind it.
What stays confidential, and what we can share
Client names, site locations, system names and volumes are covered by confidentiality obligations, and we keep them. Every client here trusted us with the inside of their operation, and that trust is the reason these systems exist at all. The rest of how client information is handled is written down.
What we can share is the reasoning. On a call we'll go considerably deeper on approach, architecture and what we'd do differently next time — all of it inside the same confidentiality line.
The same rule governs the numbers. The figures in each stats band belong to the software. The savings are a narrow exception: yearly dollar totals from the site's efficiency-savings tracker, each task timed before and after, with nothing that says whose site it was.
Can we speak to a client from one of these case studies?
Only with that client's written agreement, because named-reference rights stay opt-in and permission for one use covers that use alone. What is always available is a call with the engineer who built the system, who can go deeper on the approach and the architecture inside the same confidentiality line.
Production, not proof-of-concept
Everything here ran daily, under load, with people depending on it during their shift.
The failure modes are the story
Anyone can describe the happy path. What matters is what the system does at 3am when a dependency is down.
No rip-and-replace
Almost none of this involved replacing a system. It involved making the systems already in place work together.
Recognize your operation in any of these?
A free assessment gives you a clear picture and a prioritized plan — no commitment.
Prefer to talk?
Call 832-598-8234 or email msco@stoneagesoftware.com. Houston, Texas — serving Houston, The Woodlands, Conroe, Sugar Land, Katy, Pearland, and the Greater Houston metro.
What happens next
We read your message, an engineer replies with questions or a straight answer, and if a call would help, we book one. From the first reply on, you're talking to the people who'd do the work.