How Ariel Digital replaced a manufacturer's Excel equipment sizing workbook with a secure, offline-capable internal web app, built spec-first with AI.
Almost every engineering company has one: the spreadsheet. It has been passed down for years, it holds the company’s hard-won know-how, and only one or two people really trust themselves to change it. It works, until someone fat-fingers a cell, emails out an old version, or the one person who understands tab seven goes on vacation.
This case study covers how Ariel Digital turned that kind of spreadsheet into a purpose-built internal web app for an industrial manufacturer in the water and wastewater space. The client is under NDA, so we’ll keep the specifics general, but the problem and the approach apply to any business that runs on a critical spreadsheet.

The Challenge
The client designs and manufactures odor-control systems: large treatment vessels that clean the foul, corrosive air coming off sewer lift stations, pump stations and treatment plants. Before anything gets built or quoted, an engineer has to size the system. That means working out how much air needs treating, how much hydrogen sulfide is likely in it, how long the air has to stay in the media, how big the ducts should be, and what vessel dimensions will actually fit on site.
All of that lived in an Excel workbook. The process was reliable in experienced hands, but it had the usual spreadsheet problems:
- Tribal knowledge. The rules of thumb (what counts as “too fast” or “too tall,” which regions run hotter on H2S) lived in a senior engineer’s head and in scattered cell comments.
- No guardrails. Nothing stopped a newer engineer from entering a number that was technically valid but a bad design idea.
- Version sprawl. Revisions lived in file names like
Final_v3_REVISED.xlsx, with no clean history of what changed and why. - Desk-bound. Engineers often need answers at a job site or a client meeting, where a laptop with a big workbook and spotty Wi-Fi isn’t a great combination.
- Inconsistent output. Every engineer’s printout looked a little different.
The goal wasn’t to reinvent the engineering. It was to keep the math exactly as trusted, and wrap it in a tool that’s faster, safer and easier to hand to the next engineer.
What We Built
We built a secure, browser-based sizing and technology-selection tool used only by the client’s internal engineering team.
A guided sizing wizard that recalculates live
Instead of a grid of cells, engineers move through a clear, step-by-step pipeline:
Project info → structure volume → airflow → H2S and residence time → media volumes → ductwork → vessel dimensions → summary
Every step feeds the next, and every number updates in real time as inputs change. Engineers can describe the structure (rectangular or round, with multiple structures summed automatically) or, when a consulting engineer has already specified the airflow, skip straight to entering it directly. A persistent summary panel keeps the key numbers in view the whole time.
Side-by-side technology comparison
A big part of the job is choosing which treatment approach to recommend. The app sizes two competing configurations next to each other, column by column, so an engineer can see the trade-offs in vessel size, media volume and weight before committing to one.
Smart defaults, clearly marked
The app suggests sensible starting values: airflow rates based on the type of facility, regional H2S defaults based on where the project is located, and suggested stage lengths drawn from the design ranges. Suggested values look visibly different from values an engineer typed in, so it’s always obvious what was assumed and what was decided.

Traffic-light validation, turning experience into guardrails
This is where the senior engineer’s know-how became software. Every critical number is checked against design limits and flagged green, yellow or red: air velocity through the media, duct velocity, vessel height and length, residence time and more. Each flag carries a plain-language message explaining what’s off and why it matters.
Just as important, the limits aren’t hard-coded. An admin screen lets the engineering lead adjust thresholds as the company’s design standards evolve, and changes appear instantly for everyone. When a project is saved, the thresholds in effect at that moment are saved with it, so an old design is always judged by the rules it was built under.
Along the way, we learned from the client’s engineer that most of these limits are guidelines, not hard stops. So the app flags them as warnings that call for a judgment call instead of blocking the engineer. That’s the kind of nuance a spreadsheet can’t express and a good internal tool should.
Project history and revisions
Every project gets a clean revision history. Engineers save new revisions as a design changes, browse back through earlier ones, and pick up where they left off. The dashboard makes it easy to find a project from two years ago, which matters for a business where projects can stretch across several years.
One-click PDF reports
Any revision can be exported as a consistent, branded internal PDF report with the inputs, calculated results, validation status and revision details. Every engineer’s output now looks the same, and every report traces back to an exact saved version.

Works offline, syncs when back online
Because engineers don’t always have a reliable connection in the field, we built the app as a Progressive Web App (PWA). It installs like a native app, autosaves locally as you work, keeps working with no connection at all, and queues changes to sync once you’re back online. A small indicator in the header always shows whether your work is synced, syncing or waiting. If a browser crashes mid-design, the app offers to recover the unsaved draft.
Secure, role-based access
This is internal, confidential engineering data, so access is locked down. Only invited engineers can sign in, admins control who has access and who can change design thresholds, and the database enforces those permissions at the row level, not just in the interface.
How We Built It: Spec First, Then AI-Assisted
The most interesting part of this project, from a process standpoint, is how it was built.
- We started with the engineering, not the code. Before writing any software, we sat down with the client’s senior engineer and turned the spreadsheet into a detailed requirements document: every input, every formula, every lookup table, every rule of thumb and every “it depends.” We also wrote down what was explicitly out of scope for version one, which kept the project from sprawling.
- We broke the build into small, self-contained specs. The requirements became an architecture document and seven tightly scoped feature specs: foundation, authentication, the sizing wizard, project management, validation, PDF reports and offline sync. Each one had clear acceptance criteria.
- We built with AI agents, with guardrails. With specs that precise, we used AI coding agents to do much of the implementation, working one spec at a time inside strict boundaries, with automated scope checks that kept each change in its lane. After the specs were finished, the full first version came together in a matter of days, not months.
- We tested the math like it matters, because it does. Every calculation lives in its own isolated, pure function with its own automated tests, checked against real sizing examples worked by hand in the original spreadsheet. The app now has well over 250 automated tests, which means we can change a formula and know within seconds whether anything broke.
- Then we iterated with the expert. Since the first version, most of the work has been the valuable kind: reviewing real designs with the client’s engineer, capturing the rules that only surface when someone experienced looks at the output, and folding them back in. Things like regional H2S defaults, shop-specific fabrication allowances, media weights, and which limits should warn rather than block.
AI made the build dramatically faster. But the reason the tool is right is the spec work up front and the ongoing feedback loop with the person who knows the engineering best.
Results
- One source of truth. The company’s sizing logic now lives in tested code instead of a fragile workbook, and design standards live in an admin screen instead of someone’s memory.
- Built-in mentorship. Newer engineers get the same warnings a senior engineer would give them, at the moment they enter the number.
- Clean history. Every design has a traceable revision trail, with the rules that applied at the time.
- Consistent output. Every report looks the same and ties back to an exact version.
- Works where the work is. Engineers can size a system at a job site, offline, and sync later.
- Easy to evolve. New capabilities, like additional media products and water and equipment estimates, are being added in small, tested steps instead of bolted onto a spreadsheet.
Tech Stack
| Layer | Technology |
|---|---|
| Application | Next.js (App Router), TypeScript |
| Interface | Tailwind CSS and shadcn/ui, dense and keyboard-friendly |
| Data and auth | Supabase (Postgres, authentication, row-level security) |
| Validation | Zod |
| Reports | React-PDF for client-side PDF generation |
| Offline | IndexedDB and a service worker with background sync |
| Testing | Vitest and Playwright |
| Hosting | Vercel |
Is your business running on a spreadsheet?
If your team depends on a workbook that only a few people understand, the risk isn’t the spreadsheet itself. It’s what happens when that knowledge walks out the door, or when a wrong number goes out in a quote.
Turning that spreadsheet into a focused internal tool is often far more affordable and faster than people expect. Ariel Digital builds custom apps and internal tools spec-first with modern AI-assisted development, so you keep the logic you trust and gain guardrails, history, consistency and the freedom to work from anywhere. Let’s talk about your project →