We build custom manufacturing software — quoting, pricing, order entry, shop floor, and the books — one connecting tool at a time, or end to end. Built by a small team with 30 years of ERP experience and real time on the machines. Owned by you. Priced like a project, not a subscription.
Generic enterprise platforms charge you every month, forever, to run a business they've never seen. The workflows don't fit, so you pay integrators to bend them. The data model doesn't fit, so your people live in spreadsheets on the side. 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 dares touch — one bad day away from stopping production.
It didn't used to be possible to just replace all of this. Custom systems took years and seven figures. AI changed the math: a small senior team can now rebuild the entire pipeline — faithfully, verifiably — in months.
“The first thing he wants to do is rip out Salesforce, Oracle and SAP, for which they're paying a combined $1M per month.” — A YC partner, describing a founder buying factories. We build for that founder.
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 — no VAN, no EDI shop — 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.
Order entry that speaks your product's language — options, sizes, materials, customer-specific catalogs — up to integrated web-based CAD: design the product in 3D right in the order form.
Your real pricing rules — every upcharge, every exception — reconstructed from wherever they live today, then made testable.
Station-by-station MES tracking with hardware integration on the floor — scanners, stations, machines — plus cut lists, schedules, even STL files, generated straight from orders. No re-keying.
Confirmations, approvals, and status emails sent from the system — branded, logged, automatic.
Clean handoffs to QuickBooks and your accountant. Invoices that match the orders, always.
Every write logged, every price traceable to a rule, every change reviewable. Built in from day one.
Where AI belongs is in the product: agent tools built into your team's daily workflow, 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.
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 pays 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 ERP comes out one organ at a time, never big-bang, and the factory never stops shipping.
We can build the entire pipeline from scratch — we've done it. But for most shops that'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 deliver on a KPI.
Modern stack, zero lock-in, best-in-class security. Web-based, works on the shop computer and the phone in the truck — with passkey login, role-based access, and every write audit-logged. You own the code, the data, and the deployment. If we disappear tomorrow, any competent engineer can pick it up.
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 business ran on a SQL Server from 2012 — past end-of-life — 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.
Before writing a line of the new system, we recovered the truth. The team restored a years-old database backup in Docker, decompiled the stalled rewrite for its logic, and reconstructed the complete pricing model as an explicit, versioned rules engine — then replayed 268,861 historical product builds through the new engine and diffed the results against the numbers the shop floor actually cut. That replay caught a real formula discrepancy the owner's own corrected worksheet had wrong — resolved by the evidence of 400,000+ real records.
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.
A live, client-accessible deployment existed under 8 weeks from kickoff — reviewed against dated before/after evidence at every step, with 43,679 historical orders and ~2,600 customers migrated in. The legacy system stays up until the new one has earned cutover, because the first rule of an ERP rescue is that the factory never stops shipping.
Our team ships the volume of a much larger firm — that's why this takes months instead of years — and every line is reviewed and verified under three decades of ERP discipline. Here's the loop:
We take your legacy stack apart — old databases, backups, exports, even the application binaries — and recover the rules your business actually runs on. Nothing is assumed; everything is evidence.
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.
We build the new system in vertical slices, in whatever order pays fastest for your shop — each slice deployed to a live URL your team can click the same week.
Dated before/after screenshots, automated test suites, audit logs on every write, and side-by-side reconciliation against the legacy system. You never take our word for it.
The legacy system stays up until the new one has earned trust. After cutover, the same team keeps evolving the system in fixed-price sprints — no per-seat licenses, no forever-fees.
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 cutover. 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.
Flat, fixed costs — known before each step begins. No contracts beyond an NDA, and you can stop after any step with everything you've paid for in hand.
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. Built to be a great plan no matter who executes it, even if you never hire us.
Sprint cycles on a two-week cadence at a fixed, known cost. Each cycle commits to a KPI up front and delivers on it — a real business problem solved, in deployed software you can click, not a status report. 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.
If you're planning a year-long software project, you're doing it wrong. A huge proposal or RFP makes everything more expensive — you pay for pages of speculation about a future that won't happen as written. What you think you need will change the moment working software starts solving your problems, and your business will change mid-build too. That's not a risk to plan away; it's the reason we work in two-week cycles that deliver value now and re-aim, every cycle, at what matters next.
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.
Rivlet is led by Daniel Gray — thirty years building ERP systems for real businesses, with time spent working in machine shops, not just writing software about them. Before founding Rivlet, his last full-time role was automating chip-design pipelines — where "the software must be exactly right" isn't a slogan, it's tape-out.
That combination — ERP depth, shop-floor literacy, and modern engineering — is the whole point. The team makes the work fast. Experience makes it correct.
Order management, pricing, inventory, scheduling, accounting integrations — designed, built, and lived with in production.
We know what a traveler is, why the router table lies, and what happens to software that ignores how parts actually move.
Dan's most recent full-time role before founding Rivlet: automating semiconductor design flows — the most unforgiving pipeline discipline there is.
A delivery team built to ship the volume of a much larger firm — with a senior engineer accountable for every line that ships.
Tell us what you're running — the ERP you're renting, the desktop app you're afraid of, the spreadsheet holding it together — and we'll come back with what a replacement looks like.
Prefer direct? dan@rivlet.io · 1 (510) 900-0374