Jonathon Klem

Technical Leverage

Oct 16, 2024

In launching ManageMemberships, I’ve had my own experience grappling with technical debt. At the start of development, my vision was clear: everything needed to be perfect. I wanted flawless code, 100% test coverage, and pristine adherence to the best practices laid out by Filament and Livewire. Every line was going to be a masterpiece.

The Pursuit of Perfection

Initially, this mindset worked well. When you’re just starting a project, it's easy to focus on building with the perfect architecture and spotless code quality. In those early days, you have time—there are no customers knocking at your door or looming deadlines to meet. It’s the ideal environment to create something exceptional.

I spent countless hours ensuring every feature was developed according to the highest standards. Every interaction was tested, every edge case handled, and I adhered strictly to the best practices set by the tools I was using. Filament and Livewire offer incredibly powerful frameworks, and I was determined to use them in the most efficient and clean way possible.

But as things started progressing, I realized that my relentless pursuit of technical perfection was limiting my ability to move quickly and adapt.

When Reality Hits

Then, the landscape began to shift. Customers started coming on board, and suddenly, there were expectations. While the first few weeks of getting early users on ManageMemberships were exciting, it quickly became clear that customers don’t care if your codebase is perfect—they care about functionality.

I found myself needing to deliver new features and fixes to meet real business demands. Deadlines loomed, and with them came the pressure to ship quickly. Suddenly, I didn’t have the luxury of spending days perfecting code for the sake of perfection itself.

I had to make compromises.

Understanding Technical Debt

This is where I began to truly understand technical debt. Up until that point, I had heard the term thrown around always attributed it to sloppy coding or poor management. When deadlines hit, and you need to deliver features fast, cutting corners becomes inevitable.

But the key is understanding that technical debt isn’t inherently bad. Much like financial debt, it’s a tool you can leverage for growth. You take on debt to get things done faster, knowing that you’ll need to pay it off later. The important part is ensuring that it doesn’t accumulate unchecked.

I found myself making trade-offs. Maybe that new feature didn’t have complete test coverage, or perhaps I implemented a temporary solution to get a quick fix in place for a customer. Those decisions added up, and over time, I had to start managing the debt.

Balancing Perfection with Progress

One of the biggest lessons I’ve learned in the development of ManageMemberships is finding that balance between doing things perfectly and moving fast enough to keep up with customer demands.

Here are a few key strategies I’ve implemented to manage technical debt effectively:

  1. Prioritization: I stopped striving for perfection in every aspect and started focusing on what delivers the most value to the end-user. Do customers need a minor performance tweak, or are they more concerned with a new feature that will enhance their experience? When in doubt, prioritize customer-facing improvements over behind-the-scenes perfection.

  2. Strategic Shortcuts: When taking on technical debt, I make sure it’s intentional. If a feature is rushed, I document it and leave notes for myself or the team to come back to later. This way, no one is caught off-guard, and future refactoring is easier.

  3. Debt Tracking: I've opted for simple TODO: comments that are easily searchable.

  4. Refactoring in Cycles: Rather than dedicating large blocks of time solely to refactoring, I’ve found success in incremental improvements. Each sprint or feature development includes a small percentage of time allocated to paying down technical debt. It’s less overwhelming and more sustainable.

The Business of Technical Leverage

From a business perspective, I’ve come to realize that technical debt can be a competitive advantage. By taking on short-term debt, you can release features faster, gather customer feedback, and iterate more rapidly. This is invaluable in the early stages of product development when gaining traction and building a customer base is more critical than having a perfect codebase.

However, the danger comes when technical debt starts to hinder your ability to innovate and scale. If it piles up without a plan for repayment, it can slow down development and increase maintenance costs. That’s why managing this debt becomes essential.

Lessons Learned

My journey with ManageMemberships has taught me that perfection is not the goal. Delivering value to your customers is. And sometimes, the quickest way to do that is by taking on a little technical debt. But, like any good loan, you need to have a plan to pay it back.

At the end of the day, tech debt is about leveraging short-term gains for long-term success. It's a balancing act, and every developer needs to find the sweet spot between maintaining clean, scalable code and shipping features that keep the business moving forward.

Go Back