The problem wasn't the bugs — it was the architecture

A few years into my career, I worked on a mobile banking app that was struggling with a steady stream of production bugs. The instinct in that situation is usually to patch fast: fix the crash, ship the hotfix, move to the next ticket. We did that for a while. It didn't work.

The real issue wasn't any individual bug. It was that view controllers owned too much — UI logic, business logic, and networking code were all tangled together in the same files. Every fix risked breaking something unrelated, because nothing had a clearly defined responsibility. Bugs kept reappearing in slightly different forms because we were treating symptoms, not the underlying cause.

Choosing MVVM and Clean Architecture

Instead of continuing to patch individual crashes, I led a migration to MVVM combined with Clean Architecture principles. The goal was simple to state and harder to execute: separate concerns so that each layer had exactly one job.

• Views stayed dumb — rendering state, forwarding user actions.
• View models owned presentation logic and state, with no knowledge of UIKit.
• Use cases / business logic lived independently of both, testable in isolation.
• Data layer (networking, persistence) was abstracted behind protocols, so it could be mocked in tests and swapped without touching business logic.

This wasn't a rewrite done in one sweep. Given it was a live banking app, we migrated incrementally, module by module, prioritizing the highest-risk flows first — authentication and transactions — where a bug has the highest cost.

Testing as a forcing function

One underrated benefit of this migration: once business logic was decoupled from UIKit, it became genuinely easy to write unit tests for it. That wasn't just a nice-to-have — it changed how confidently the team could ship. Test coverage on the highest-risk flows meant a change to the transaction logic would immediately surface a broken assumption, instead of silently shipping to production and surfacing as a support ticket weeks later.

The result

The architecture migration reduced production bugs by 75%. But the number, on its own, understates the real change: bugs became far easier to isolate and fix going forward, because each layer had a single, well-defined responsibility. A crash no longer meant searching through a 2,000-line view controller — it meant checking the one layer responsible for that behavior.

The lesson

When bugs keep reappearing despite constant fixing, it's worth asking whether you're fixing symptoms or the actual cause. Sometimes the fastest way to stop firefighting isn't to fix faster — it's to fix the structure that keeps causing fires in the first place.