Own the software that runs your shop. Keep the factory running.
Custom manufacturing software — quoting, pricing, order entry, shop floor, the books — one connecting tool at a time, or end to end. First pieces live in weeks, each measured against a KPI — one business number we commit to moving — and owned by you.
You're renting software that was never built for your factory.
Generic enterprise platforms were built for a business that isn't yours. The workflows don't fit, so integrators bend them. The data model doesn't fit, so your people live in spreadsheets on the side. Little of it moves a number you care about. And the moment something breaks, the person who understood it is three vendors ago.
Meanwhile the software that actually runs many shops is a desktop app from another era, wired to a database nobody wants to touch — one bad day away from stopping production.
It didn't use to be possible to fix this without a seven-figure rewrite. Custom systems took years. The math has changed: a small senior team can now rebuild a piece of the pipeline — or all of it — faithfully, verifiably, in weeks to months.
We don't rip anything out on day one. We find the place your business is losing the most, fix that, measure it, and move to the next one. — How every Rivlet engagement actually starts.
One custom pipeline, from quote to cash.
Not a platform you rent. Every piece below can ship on its own as a small connecting tool — or grow, piece by piece, into the whole pipeline — shaped to how your shop actually works.
And where this points: shops that can trade documents and work with each other directly, without paying a middleman network to pass the files (the old EDI/VAN setup) — and, once the software is lined up, smart physical tools on the floor. That's the direction; what's below is what we deliver today.
Quote & Order
Order entry that speaks your product's language — options, sizes, materials, customer-specific catalogs — up to built-in 3D design (CAD): draw the product in 3D right in the order form.
Pricing Engine
Your real pricing rules — every upcharge, every exception — reconstructed from wherever they live today, then checked by automated tests.
Production & MES
Live, station-by-station tracking of every job on the floor (an MES, or manufacturing execution system), wired to scanners, stations, and machines — plus cut lists, schedules, even 3D-print (STL) files, generated straight from orders. No re-keying.
Customer Comms
Confirmations, approvals, and status emails sent from the system — branded, logged, automatic.
Books & Back Office
Clean handoffs to QuickBooks and your accountant. Invoices built from the orders, so they match.
Audit & Trust
Every write logged, every price traceable to a rule, every change reviewable. Built in from day one.
AI in your workflow
Where AI belongs is in the product: AI assistants built into your team's daily work, computer vision on the floor — reading tags, spotting parts, flagging what's stuck — and smarter tracking that learns your shop's rhythm. What matters is the end product; AI is one more tool we build into it, where it earns its keep.
Three ways in.
Small, focused tools that bridge what you already run — a QuickBooks integration, a label-printer bridge, a modern order screen on a legacy database, barcode tracking bolted onto the floor, machine-vision and AI integrations that optimize what's already there. Each one stands alone, solves a real business problem in a sprint or two, and is scoped to pay for itself.
When a piece of the old stack is failing — pricing, the order desk, floor tracking — we replace that piece and run it alongside everything else. The old system comes out one piece at a time, never all at once, so the factory keeps shipping.
We can build the entire pipeline from scratch — we're doing it now. For most shops it's the expensive answer, and we'll say so on the first call. If an off-the-shelf system fits your business, we'll tell you to buy it.
Flexible by design. We build the pieces your shop needs, in whatever order pays fastest. The only fixed structure is the one below: discovery, a plan, then two-week cycles that each aim at a KPI.
Modern stack, zero lock-in, security built in. Web-based, works on the shop computer and the phone in the truck — with passkey login (no passwords to steal), access set by role, and every change logged. You own the code, the data, and the deployment. If we disappear tomorrow, a competent engineer can pick it up.
A custom manufacturer. A failing system. Months, not years.
A decades-old make-to-order manufacturer was running its entire business on a legacy desktop application and a Microsoft Access database — and it was failing in production.
The starting point
The business ran on a 2012 SQL Server database — which Microsoft no longer supports — with a Microsoft Access front-end installed machine-by-machine on each workstation. A previous rewrite attempt had stalled at “90 percent” and never shipped. The original developer was gone, there was zero documentation, and the first database backup we found was corrupt: every byte zero. When the system started failing, there was no vendor to call.
The data archaeology
Before writing a line of the new system, we recovered the truth. The team restored a years-old database backup in a sealed-off test environment, took apart the stalled rewrite's code to recover its logic, and rebuilt the complete pricing model as explicit, versioned rules — then replayed 268,861 historical product builds through the new engine and compared the results against the numbers the shop floor actually cut. That replay caught a formula error that even the owner's own corrected worksheet had wrong. The evidence of 400,000+ real records settled it.
The rebuild
In parallel, the team built a modern web application: keyboard-fast order entry shaped like their product, the reconstructed pricing engine — editable by the shop, not hardcoded — a real-time 3D product designer, production boards with barcode tracking across 11 departments, customer analytics, QuickBooks integration, passkey login, and an audit trail on every single write. Roughly 64,000 lines of code, 51 database tables, and 95 automated test files — where the legacy system had none.
Where it stands
The new system is in parallel testing against the live one, with 43,679 historical orders and ~2,600 customers migrated in and every step reviewed against dated before/after evidence. The shop still runs on its Access system, and no customer email goes out from the new one until go-live, which is targeted for November 2026, and it happens when the new system has earned it, because the first rule of a rescue is that the factory never stops shipping.
A small team that ships like a big one.
We ship far more than our size suggests — that's why this takes months instead of years — and every line is reviewed by someone with three decades of ERP experience. Here's the loop:
Excavate
We take your legacy stack apart — old databases, backups, exports, even the program files — and recover the rules your business actually runs on. Nothing is assumed; everything is evidence.
Reconstruct
The recovered logic becomes an explicit rules engine with tests.
Where the legacy code and the accepted business numbers disagree,
the numbers your customers actually paid win.
Rebuild
We build the new system in small, complete working pieces, in whatever order pays fastest for your shop — each slice deployed to a live URL your team can click the same week.
Prove
Dated before/after screenshots, automated test suites, audit logs on every write, and side-by-side reconciliation against the legacy system. You don't have to take our word for it.
Go live — then keep going
The legacy system stays up until the new one has earned trust. After go-live, the same team keeps evolving the system in sprints priced one at a time — no per-seat licenses, no forever-fees.
Evidence you can check at any moment.
Every sprint ends deployed. You judge progress by clicking the app — not by reading a status deck.
Every visible change is captured as dated screenshots you can scroll back through — a running record of what changed, when.
Tickets, work logs, and sprint status in one place. What's in flight, what shipped, and what it cost — visible at all times.
Every write in the delivered system is logged and reviewable — enforced by automated tests, not by promises.
New pricing and production engines are replayed against your real historical records before go-live. Discrepancies get surfaced, not smoothed over.
MES station tracking shows every order's real position on the floor. The transparency you get from us during the build is the same transparency your team gets from the system every day.
A structure with no surprises.
Flat, fixed costs — known before each step begins. No contracts beyond an NDA (a confidentiality agreement), and you can stop after any step with everything you've paid for in hand. The one exception is a full rebuild: $20k a month, six-month minimum.
Tell us what you're running. We'll tell you straight whether a rebuild makes sense — and what we'd tackle first.
A flat-fee discovery deep-dive across your systems and data, ending in a detailed, actionable plan for what you can do better. Written to be useful no matter who does the work, even if you never hire us.
Two-week sprints, each quoted before it starts at a known price. Each one commits to a KPI up front and aims at a real business problem, in deployed software you can click, not a status report. If the number doesn't move, we say so in writing. You judge us by what ships and by what moved.
Each quarter of engagement closes with a retrospective sprint: a written follow-up of what shipped, what the KPIs actually did, what we learned, and the updated plan for the next quarter. The discovery deliverable, kept alive — and like the original, yours to keep.
Why sprints, not one big bid. Every fixed price carries a cushion for the unknowns, and a year-long bid carries a year of them — paid up front whether they happen or not. Two weeks of unknowns is a small cushion. What one sprint teaches gets priced into the next instead of guessed a year early. And you can stop after any sprint with everything you've paid for in hand (a full rebuild carries a six-month minimum). The math.
RFPs (formal requests for proposal): we'll answer one. Expect the same work to cost more as a single bid than it does two weeks at a time — that's the price of pricing a year of unknowns, and we'd rather say so than bury it.
For the right companies, we'll also structure royalty or performance-based partnerships — deals where we get paid when the numbers you care about move.
We've been on both sides of the panel.
Rivlet is led by Dan Gray — thirty years building ERP systems (the software that runs orders, inventory, and the books) for real businesses, with time spent working in machine shops, not just writing software about them.
That combination — ERP depth, shop-floor literacy, and modern engineering — is the whole point. The team makes the work fast. Experience makes it correct.
-
3 DECADES
ERP, end to end
Order management, pricing, inventory, scheduling, accounting integrations — designed, built, and lived with in production.
-
THE FLOOR
Machine-shop experience
We know what a traveler is, why the router table lies, and what happens to software that ignores how parts actually move.
-
NOW
Built for volume
A delivery team built to ship the volume of a much larger firm — with a senior engineer accountable for every line that ships.
Need software that fits your shop and moves your numbers?
Tell us what you're running — the system you're renting, the desktop app nobody wants to touch, the spreadsheet holding it together — and we'll come back with what we'd fix first, how fast, and the KPI we'd commit to moving.
Prefer direct? dan@rivlet.io · 1 (510) 900-0374