When your software vendor tells you they are shutting down in four months, you have two choices: panic or pivot.
Klarity Car Wash was facing a nightmare. Their entire operational backbone: the system that controlled the wash bays, took payments, and managed fleet accounts: was going dark. Competitors swooped in with quotes exceeding $300,000, demanding a total rip-and-replace of perfectly functional hardware.
Our experts at GiantByte saw a third option. Why throw away $200,000 worth of working infrastructure? We decided to build a custom bridge between modern software and legacy industrial hardware.
This white paper breaks down the technical architecture our team used to replace a mission-critical POS system without a single minute of business downtime.
The Strategy: Modern Brains, Original Brawn
The core philosophy of this project was preservation. The pumps, the sprayers, and the relay boards weren’t the problem: the software was.
We designed a hybrid architecture that split the workload. We needed a system that was fast enough to handle real-time industrial controls at the wash bay but flexible enough to provide global reporting and fleet management from a web browser.
Our developers chose a stack that prioritized reliability over “flavor-of-the-week” trends:
- Local POS Terminals: C# and Windows Presentation Foundation (WPF)
- Central Backend: Django (Python) and PostgreSQL
- Management Dashboard: React
- Industrial Communication: TCP MODBUS
By separating the “heavy lifting” of hardware control from the “heavy thinking” of data management, our team ensured that even if the internet flickered, the car wash kept running.
Hardware Integration: The MODBUS Puzzle
How do you talk to a machine that doesn’t have an API? You go back to basics.
The existing car wash infrastructure relied on relay boards. These boards are the gatekeepers; they flip the switches that turn on the water, the soap, and the brushes. To control them, we utilized TCP MODBUS protocols.
The challenge? There was no manual. The original vendor had proprietary mappings that weren’t documented. Our experts had to reverse-engineer the relay mappings and coil assignments from scratch.
We spent hours mapping which specific signal triggered which specific service. Does Coil 001 turn on the high-pressure rinse or the triple-foam wax? We found out through iterative testing and signal sniffing.
Calibration and Timing
Industrial hardware isn’t instant. If you fire a relay too fast, you risk “chatter”: a rapid-fire clicking that can burn out hardware. If you fire it too slow, your customer is sitting in a dry bay wondering where their money went.
Our developers built custom service duration timers and delay logic within the C# POS application. This ensured that the hardware transition was smooth, protecting the client’s $200,000 investment in physical infrastructure.
The Local Frontend: Why We Chose WPF and C#
For the fifteen unattended kiosks and the automated wash terminals, we needed a “thick client.” A standard web app wouldn’t cut it.
Why? Because the POS needs to talk to USB peripherals: like Monex payment terminals and RFID card readers: with zero latency.
By using Windows Presentation Foundation (WPF), our team built a high-performance, touchscreen-optimized interface. This allowed us to:
- Interact directly with hardware: We integrated Monex terminals via USB serial communication for real-time credit and debit processing.
- Ensure Offline Resilience: The kiosks can handle a transaction and trigger a wash even if the central server has a momentary hiccup.
- Support Legacy OS: Many industrial environments run older versions of Windows; WPF gave us the compatibility we needed.
The Central Nervous System: Django and PostgreSQL
While the kiosks handle the “here and now,” the Django and PostgreSQL backend handles the “what happened?”
We needed a centralized repository for:
- Fleet Billing: Managing hundreds of corporate accounts that pay monthly.
- Global Reporting: Aggregating sales data from fifteen kiosks and the automated bay.
- Account Management: Syncing gift cards, wash cards, and loyalty programs across the entire site.
PostgreSQL was the obvious choice for data integrity. When you’re dealing with thousands of transactions and complex fleet billing rules, you can’t afford a single lost row. Django’s robust ORM allowed our experts to build complex business logic for fleet discounts and membership tiers without sacrificing development speed.
Real-World Engineering: Overcoming Integration Friction
No project of this scale is without its hurdles. During development, we hit a major roadblock: the payment vendor’s integration was less stable than advertised.
In a high-volume environment like a car wash, a “timed out” payment terminal can lead to a line of angry drivers. Our developers didn’t just accept the vendor’s API at face value. We built a custom transaction reliability handler.
If a payment terminal stalls, our software detects the hang, resets the serial connection, and recovers the transaction state. To the customer, it looks like a 2-second delay. Behind the scenes, our code is performing a minor miracle to save the sale.
The Deployment Strategy: Zero Downtime
You can’t close a car wash for a week to “try out” new software. Every hour the gates are closed is lost revenue.
The GiantByte team implemented a phased soft-launch strategy:
- Isolated Bay Testing: We installed the new POS on a single manual bay, leaving the rest of the site on the old system.
- Partial Live Deployment: We expanded to several bays, limiting payment types to test the MODBUS stability under load.
- Full Rollout: Once we were 100% confident, we flipped the switch on the automated drive-through and the employee terminals.
Because of this meticulous approach, the final transition happened overnight. Customers who washed their car on Monday used the old system; on Tuesday, they used ours. They didn’t see the complexity: they just saw a faster, cleaner interface.
Business Impact by the Numbers
This wasn’t just a win for the engineering team; it was a massive win for the client’s bottom line.
- $200,000+ Savings: By not replacing the physical hardware, the client avoided a massive capital expenditure.
- 6-Week Acceleration: When the original vendor moved the shutdown date up, our experts condensed a five-month timeline to meet the new deadline.
- 15+ Kiosks Managed: A single, unified platform now controls the entire site, from unattended kiosks to the automated tunnel.
Is Your Legacy System Holding You Hostage?
You don’t have to throw away your hardware just because the software is outdated. Whether you are dealing with industrial controls, custom billing systems, or complex manufacturing software, we specialize in finding the “bridge” that others miss.
We love the “impossible” projects. We love the “spaghetti code” and the undocumented hardware. Why? Because that’s where the real value is created.
Check out our Klarity Car Wash Case Study Overview
Are you ready to stop fighting your software and start scaling your business? Let’s have a conversation. The GiantByte team is ready to listen.