frimps.

building from ghana, mostly where product questions meet technical execution.

back

Charge Express, UI v2, and a Backend Speed Pass

A quick note on Charge Express, the UI v2 work, and a deeper backend update around service bus flow, meter values, and station-level scaling.

March 13, 2026

14 min read

Lately I have been spending time on Charge Express from two sides at once: reworking the UI into a cleaner v2, and pushing a much deeper backend update underneath it.

Charge Express is an EV charging product built around helping drivers find and use chargers more easily, while giving the team better visibility into stations, chargers, sessions, and the day to day operational side behind them. On the surface, that is the app and the product experience. Underneath it, there is a lot of backend movement around OCPP traffic, station events, session state, commands, and meter values.

That combination has made this stretch interesting. The UI work makes the product easier to move through. The backend work makes the product feel more stable and responsive once real charger activity starts flowing through it. Both matter.

UI v2

The UI work has not been about making things look different just for the sake of it. The point has been to make the product easier to read, easier to move through, and easier to trust when someone is actually trying to get something done.

I have been tightening layouts, reducing visual noise, and rethinking some of the flows so the important parts show up faster. Less hunting around. Less guessing what matters on a screen. Less of that feeling where a product works, but still makes you do too much.

Charge Express sits in a space where clarity matters a lot. If someone is checking charger state, session information, availability, or any part of the operational side, the UI should feel calm and direct. So v2 has mostly been about getting closer to that.

It is still the same product, but the goal is a sharper version of it. Cleaner structure, better hierarchy, and fewer places where the interface gets in the way.

Backend performance work

The backend side has been more than just a small performance tune-up. It has been a proper service update.

Before this pass, some of the pain was already showing up in the product. Station activity was getting heavier than it should, some charger and session updates were taking too long to settle through the system, and meter values were becoming the kind of workload that could quietly turn storage into a drag. On the operational side, that means slower movement, noisier processing, and a harder time reasoning about where pressure is building.

One big part of the fix was bringing in Azure Service Bus so more of the work could move through the system in a cleaner way. That helped take pressure off direct service-to-service handling and made the flow of charger and station events feel less tangled.

Part of the deeper problem was how meter values were being written. There were too many repeated writes landing in MySQL, and that pressure was spiking the database server's compute hard enough to make it hang. Once that happened, the effect was ugly: delayed processing, downtime, and some data getting lost in the middle of the mess.

The service bus helped with the loss side of that because events could be held and processed more safely instead of disappearing when the system got rough. But it did not magically fix the database pressure by itself. The backlog could survive, but the write target was still getting hammered, resources were still spiking, and the whole thing was drifting further away from real time than it should.

So part of the work became reducing how hard we were hitting the database in the first place. I wrote custom Prisma adapters to manage database connections more carefully, which helped cut down waste around connection handling and made the write path less careless with resources.

After that, I moved meter values away from a more repetitive write pattern and toward bulk writes, so we were no longer paying the full cost of every single value like it had to stand alone. That helped bring the write pressure down and made the path more stable, but it also made the final conclusion clearer: this workload simply did not belong in the same SQL shape long term.

Another major part was meter values. That data tends to pile up quickly, and it was becoming the kind of workload that did not really belong where it was. So I have been involved in moving meter values storage from SQL into Azure Cosmos DB, but the interesting bit was not just the database change itself. It was making that switch without turning it into one giant risky migration exercise.

Instead of treating it like a big one-off data move, I worked on changing the storage path around meter values so the system could move toward the new model cleanly. That meant shifting the high-volume meter workload into a store that fit it better, while keeping existing history intact and avoiding the kind of disruptive migration that usually comes with this sort of change.

The shape of it was pretty simple in principle: introduce a cutoff point, write newer meter values to Cosmos DB from that point forward, and leave the older records where they already were instead of forcing a full migration just to say everything lived in one place.

That meant the real work shifted to the read path. Legacy data still had to be available, but I did not want clients needing fresh endpoints or a second way to ask for the same thing. So the backend kept the same contract and handled the storage split internally. If the request touched older records, it could pull from SQL. If it touched newer records, it could pull from Cosmos. If a range crossed both sides of the cutoff, the service stitched the result together and returned it in the same shape as before.

That was important because losing history was not an option, and neither was slowing the system down further just to change database types. The goal was to change the storage model without creating a second problem in the process. So the win was not only moving from SQL to NoSQL, but doing it in a way that kept the product steady while the backend model changed underneath it.

I have also been splitting the service bus flow per station, which has been one of the more important structural changes in the backend work. Instead of having everything feel too shared and too crowded, station-level separation makes the event flow easier to reason about, easier to isolate, and easier to scale without one noisy station making life harder for the rest.

That part matters more than it sounds. When too much station traffic shares the same path, you start feeling it everywhere else. Updates lag, debugging gets messier, and one busy station can create noise that has nothing to do with the others. Splitting service bus handling per station makes the backend feel more intentional and gives each station more breathing room.

I also spent time making the system much easier to watch. Part of that was adding more serious logging around the flow of charger, station, and service events. Instead of leaving those logs stuck close to the producing service, I had them written onto the bus and picked up by another service that pushes them into NoSQL. That made the logging path more useful without loading the core service with one more responsibility.

That helped in two ways. First, it made it easier to trace what actually happened around a charger, a station, or a session when something looked off. Second, it created a better base for alerts. Once the signals were landing in a cleaner way, I could add alerts around failures, stalled flows, and the sort of conditions that should show up early instead of only after someone feels the problem from the product side.

So the backend update has really been a mix of four things working together:

  • bringing in service bus support more properly
  • reducing MySQL pressure with better connection handling and bulk writes
  • switching high-volume meter values from SQL to NoSQL without a risky bulk migration
  • splitting service bus handling per station to make processing cleaner
  • adding stronger logging and alerts through a bus-to-consumer flow into NoSQL

That kind of work is not always flashy, but it changes the feel of the whole system. It reduces drag where the product is busiest, and it gives the platform more room to handle charger activity without everything feeling heavier than it should.

The useful part

I think this is the bit I keep coming back to: performance work and interface work are not separate in practice.

You can make the UI cleaner, but if the data arrives late, the product still feels rough. You can make the service faster, but if the screen is noisy, the product still feels harder than it should. So this stretch on Charge Express has been about improving both at the same time.

That has meant thinking less in terms of isolated tasks and more in terms of overall experience. What does the user need to see first? What can wait? What is slowing the path down? What is adding noise without adding value?

Those are the questions that have shaped most of the work.

Where it is heading

Right now, the direction feels good.

UI v2 is making the product cleaner and easier to move through, while the backend work is making the system stronger underneath it. There is still more to refine, but the shape of the next version is clearer now than it was before.

This has been one of those stretches where the changes are spread across a lot of small decisions, but together they push the product forward in a real way.

More on it once the next round settles.