Applying the 'Good Enough' Approach in Software Development

Can Quality Be an Impediment? Agile teams promote "building quality in." They strive for high-quality deliverables, continuous integration, and automation to keep defects low. But can chasing quality reduce agility? It sounds absurd. Agile thrives on rapid feedback, delivering value early and often, and avoiding the high costs of low quality. But when teams pursue quality without considering trade-offs, they risk slowing down, creating bottlenecks, and, yes, hindering agility. Quality Bottleneck Over-Engineering: Some teams polish endlessly, refactor excessively, or build robust test automation ahead of requirements. Automation is valuable, but premature over-engineering can delay feedback and decisions. Perfectionism: Some teams won’t ship unless features meets an arbitrary "Definition of Perfect." Requiring 100% test coverage or exhaustive edge case testing means customers wait and real-world feedback is delayed. Agile is about iterative improvement, not initial perfection. "Qualitaucracy": Well-intended quality gates may require unnecessary sign-offs and lengthy reviews, forcing Agile teams into Waterfall processes. If a team has to pass redundant approval layers before releasing, agility suffers. Misalignment: Some teams over-prioritize code coverage or architectural purity and under-emphasize business needs. Friction arises when users need a feature urgently but developers insist on minor refinements. The goal isn’t technical excellence alone; it’s delivering value at a sustainable pace. Balance Quality and Agility Define Good Enough: Not every feature needs high polish. A quick experiment may require minimal quality, while mission-critical functionality demands rigor. Teams should agree on what "good enough" means in each context. Shift Left Without Overcomplicating: Catching defects early via automation, peer reviews, and exploratory testing is valuable, but teams should focus on providing sufficient confidence. Lean testing strategies help teams move fast while maintaining fitness for purpose. Remove Unnecessary Gates: Reasonable governance has value; excessive process is waste. If a quality step doesn’t add value, consider eliminating or streamlining it. Can peer reviews replace formal approvals? Can automated tests replace manual sign-offs? Focus on Outcomes: Test coverage and defect counts don’t mean much if a feature doesn’t solve real problems. The true measure of quality is whether the product delivers value, meets user needs, and fosters learning and adaptation. When to Question Quality Agile embraces built-in quality but also prioritizes speed, feedback, and adaptability. The key is balance - delivering high-quality outcomes without rigid processes that slow teams down. If quality efforts create drag, they should be challenged. The real question isn’t whether quality is an impediment to agility (it's not), but whether your approach to quality aligns with Agile principles. If not, it’s time to rethink your approach.

There's a difficult conversation I often have with clients: when to stop optimising. As software founders, we love the chase. Shaving another 100ms off a load time feels like a victory. But in a world where we're approaching the physical limits of web speed, that victory can come at a staggering cost. The law of diminishing returns is very real. The initial performance gains are usually the low-hanging fruit: compressing images, minifying code, sorting out basic caching. That’s the easy part. But what about the next phase. When your team spends a month re-architecting a service just to gain 50ms, has that truly served the business. Here at Full Metal, we try to be pragmatic. We tie performance directly to business outcomes. If a specific bottleneck is causing a 5% drop-off in the payment basket, then yes, we get cracking and fix it. But if we're arguing over a 1.2s load versus a 1.1s load on a blog post, with no clear data showing it impacts behaviour, that's just an academic exercise. Our resources are finite. That same developer-month could have been spent building a new feature that genuinely delights customers or opens a new revenue stream. Sometimes, the obsession with speed can throw a spanner in the works of real progress. We explore this balancing act in our latest blog: https://lnkd.in/evNdraEi As business leaders, how do you decide when "good enough" is genuinely good enough? #TechLeadership #DigitalStrategy #SoftwareDevelopment

About five years ago, I had a junior engineer on my team who was brilliant but struggled so much he was about to have a low performance review. Let’s call him Anthony He was fresh out of college and eager to prove himself, but his code reviews often came back with extensive feedback. The root of the issue wasn’t his intelligence or effort it was his approach. Anthony had this habit of jumping straight into the deep end. He wanted his code to be optimized, elegant, and perfect from day one. But in that pursuit, he often got stuck either over-engineering a solution or ending up with something too complex to debug. Deadlines were slipping, and his confidence was taking a hit. One day, during a particularly rough code review, I pulled him aside and shared a principle that had profoundly shaped my own career: “Make it work, make it right, make it fast.” I explained it like this: 1. Make it work – First, solve the problem. Forget about how pretty or efficient your code is. Focus on meeting the acceptance criteria. If it doesn’t work, nothing else matters. 2. Make it right – Once it works, step back. Refactor the code, and make it clean, modular, and maintainable. Code is for humans who’ll work with it in the future. 3. Make it fast – Finally, if performance is critical, optimize. But don’t sacrifice clarity or maintainability for marginal speed gains. The next sprint, he followed this approach on a tricky API integration task. When we reviewed his work, the difference was night and day. Not only had he delivered on time, but the code was a joy to read. Even he admitted it was the least stressful sprint he’d had in months. Six months later, Anthony came to me and said, “That principle you shared, it’s changed everything. Thank you for pulling me aside that day.” Today, Anthony is a senior engineer leading his team, mentoring others, and applying the same principle that once helped him. We’re still on good terms though he moved to another org. Sometimes, the most impactful advice is the simplest. As engineers, we often get caught up in trying to do everything perfectly all at once But stepping back and breaking it into manageable steps can make all the difference.

I’ve lost count of how many times I’ve said this myself: “This is good enough for now.” It always sounds reasonable in the moment. Ship first. Clean later. Close enough. And honestly, most of the time it is a rational decision. That’s the trap. Because “good enough” data rarely stays temporary. Here’s the pattern I keep seeing, across companies and years: → We just need this once → Let’s ship and clean it later → The definition is close enough → We’ll document it eventually Fast forward a bit: → Silos multiply → Tech debt quietly piles up → Manual fixes turn into process → Complexity slows everything down And then, much later, the bill shows up: → Inaccurate reporting → High maintenance cost → Slower decisions → Less trust in the numbers What’s uncomfortable is this part: No one made a bad decision. No one was careless. No one ignored quality on purpose. “Good enough” just compounded. This is why so many orgs feel stuck even after big investments in data, analytics, or AI. Not because they did the wrong things. But because small shortcuts quietly became permanent constraints. The fix is rarely “more tooling”. It’s earlier clarity. → Clear definitions before scale → Ownership before dashboards → Fixing the root before adding more use cases Boring work. Unsexy work. Very expensive to skip.

When I first entered the workforce, I assumed there was a fixed amount of work to do each day—just like homework in school. You finish it, and you're done. Then I became more senior. Suddenly, the work was endless. There was always one more thing I could do, one more idea worth exploring, one more email to write, one more document to polish. So how do you stay sane in a world of infinite work? You don’t aim for perfection. You aim for “good enough.” The magic is in figuring out how good is actually needed. Sometimes a two-minute response is all it takes. Sometimes you need a six-pager and a whiteboard session. Learning to consciously lower the quality bar is a competitive advantage. It’s how you stay productive and make room for the few moments that actually require excellence. I dive deeper into this mindset, and how it helped me lead and grow my career at Amazon, in this article:

Early in my career, I joined a small startup that promised to “redefine” the in-dashboard experience. Everyone in the room believed we were building the next big thing. We had big dreams. And we had an even bigger list of features we wanted to cram into the product. And that’s exactly where things went wrong. Every time we came close to shipping, someone would say, “Wait. What if we add this feature?” Or, “The design isn’t quite perfect yet. Let’s tweak it a bit more.” Weeks turned into months. Months turned into years. Five years later, we still hadn’t shipped a single product. That startup doesn’t exist anymore. But the lesson has stayed with me ever since: perfection is BS wrapped as “one more thing”. In engineering, “good enough” often feels like failure. We convince ourselves that the code could be cleaner, the readings more precise, the UI smoother, the architecture more elegant. We fall into the illusion that one more tweak will finally make it perfect. But here’s the truth: that last 0.5% improvement rarely changes the outcome. What changes the outcome is shipping. Apple didn’t wait for the iPhone X before launching the first iPhone. They shipped version 1, learned from it, and built forward. The same principle applies to embedded systems, software, and every ambitious project: ship the simplest thing that works, then make it better. Because if you keep chasing perfection, you’ll never ship at all.

At some point, “good enough” stopped feeling good. We equated it with settling. With being lazy. With not trying hard enough. But here’s the truth most high-performers don’t want to admit: Chasing perfection is often the thing that slows you down. I used to think every detail had to be dialed in. Every task needed to be optimized. Every project pushed to 100%. Until I realized that that mindset was costing me more than it was helping. “Good enough” doesn’t mean sloppy. – It means intentional trade-offs. – It means knowing when to stop. – It means letting clarity lead, not ego. – It means choosing progress over perfection. – It means understanding the process of iterations. So how do you start being okay with “good enough”? You practice it on purpose. 🔹 Set Max Effort Limits Stop letting tasks expand just because you “could make it better.” ↳ Decide in advance: “I’ll spend 60 minutes on this.” ↳ Use a timer to stay accountable. ↳ If it’s not done by the deadline, ship the best version. 🔹 Rate the Task’s Importance Before Starting Not every task deserves A+ energy. ↳ Ask: “Is this mission-critical or just a nice-to-have?” ↳ Assign a score from 1–10 for impact before you begin. ↳ Match your effort to that score. 🔹 Use a “Version 1” Mindset Think in iterations, not masterpieces. ↳ Label the task as “V1” in your notes or files. ↳ Set a reminder to review it later. ↳ Focus on clarity and speed. 🔹 Build Debrief Loops, Not Redo Loops Don’t fix it now. Learn and improve next time. ↳ After shipping, ask:  • “What worked vs what didn’t”  • “What would I do differently?” ↳ Log your lessons in a simple doc. 🔹 Practice Letting Small Things Slide You don’t need to win every battle. ↳ Pick one low-stakes task this week and leave it at 80%. ↳ Let others take the lead, even if it’s not how you’d do it. “Good enough” isn't lowering the bar. It’s knowing exactly where the bar should be. Where do you need to stop overdelivering this week? Let me know in the comments.👇 Helpful?  ♻️Please share to help others. 🔎Follow Michael Shen for more.

I've been thinking about this a lot lately. In RevOps, we're constantly evaluating our tech stack to optimize efficiency and drive revenue. The constant call of "best-in-class" solutions is powerful, promising unparalleled features and peak performance. But after years in the trenches, I've learned a crucial lesson: "best-in-class" doesn't always translate to "best for your business." Here's why: Complexity Can Kill Adoption: A tool overflowing with features might sound great on paper, but if it's too complex for your team to effectively use, you're not getting ROI. Simplicity and ease of adoption often trump an exhaustive feature list. Integration Over Isolation: A single "best-in-class" tool that doesn't play well with the rest of your ecosystem can create data silos and operational headaches. A connected, harmonious tech stack – even if some components aren't individually "best-in-class" – often delivers superior results. Cost vs. Value: The price tag of a "best-in-class" solution can be significant. It's vital to assess if the incremental benefits truly justify the cost, especially when a more affordable, yet highly effective, alternative might exist. Tailored to Your Workflow: Every business has unique processes and nuances. A "best-in-class" tool built for a generic use case might force you to adapt your proven workflows, rather than enhancing them. Look for tools that flex to your way of working. The "Good Enough" Principle: Sometimes, a "good enough" solution that integrates seamlessly, is user-friendly, and meets 80% of your needs is far more valuable than a hyper-advanced tool that only a few power users can leverage. My philosophy as a RevOps leader has evolved: focus on "best-fit" over "best-in-class." This means deeply understanding your business's specific needs, your team's capabilities, and your existing infrastructure before making tooling decisions. What are your thoughts? Have you experienced the pitfalls of pursuing "best-in-class" without considering "best-fit"? Share your insights below! #RevOps #RevenueOperations #TechStack #SaaS #BusinessStrategy #Tooling #Efficiency #ROI

Quick story: During a recent demo of our Always-On tool (when it was still in Beta), one of the components disappeared. Mid-presentation. I'm clicking around looking for a table that should be there but wasn't. I had to explain that we were still in QA and features were being debugged in real time. Most SaaS companies would reschedule the demo until everything's pixel-perfect for release. We take the opposite approach. And it works. We show what we are currently building, even with risks of idea theft. Because we like to collaborate on improving the product before its even launched from real people who are in-market. Our competitors spend months in development cycles. Layers of approval, circle-back meetings, "let's run this by the board" delays. By the time they ship one feature, we've shipped five and gotten real user feedback on all of them. That client on the call understood what they were seeing: Something that would be rock-solid in a couple weeks, not months. They got early access to functionality that was actively being improved based on real usage. Being a small team means we can't hide behind perfect demos. And we have new things we are building that we are eager for people to see. But it also means when a client suggests something, we can build it in days instead of quarters. When we spot issues, we fix them immediately instead of scheduling them for the next sprint. The trade-off works. We'd rather start showing something 80% functional today than 100% polished next quarter; especially when most "perfect" software still breaks in production anyway. Perfect software isn't just slow software. It's software built without customer input.

This might be unpopular, but… I’m not a huge fan of “fail fast, learn fast.” I’ve led enterprise product teams through both smooth and chaotic launches. And here’s what I’ve learned: Fail fast only works if you’ve thought through what can go wrong and set up the recovery plan first. Too often, I see teams rushing a release with the promise that they’ll “just fix it later.” The result? They don’t fail fast. They fail LONGER. And they lose time, trust, and traction in the process. Here’s what usually gets skipped in the name of speed: - End-to-end experience design - Solution architecture that actually holds up - Test coverage with real-world scenarios and the data to back it ip. - Documentation that supports anyone downstream And yet, somehow, the feature gets shipped anyway. The attitude of these type of situations - “Let’s just ship it. We’ll figure it out post-launch” - isn’t agility. It’s running after short term wins and gambling with customer experience. That’s a major red flag. Especially in complex product ecosystems where one small change can ripple across legacy systems, integrations, and operational teams. This mindset won’t hold up long term ⭐️ Shipping smart doesn’t mean shipping slow. ⭐️ It means respecting complexity. ⭐️ It means minimizing recovery cycles before you create them. So how do you know when you’ve spent the right amount of time? Here’s what I’ve done that keeps working: ⚪️ DEFINE “GOOD ENOUGH” EARLY What’s the minimum that still delivers value and meets reliability thresholds? ⚪️ MAP END-TO-END PRODUCT ECOSYSTEM IMPACTS Your feature isn’t the only thing out there. Before you launch, ask “who could be affected and how?” Don’t guess. Go find out. ⚪️ HAVE YOUR MITIGATION PLANS READY TO GO Run the “what if scenarios.” Figure out what you’d do to solve them. This includes a full rollback plan. It reduces panic later. ⚪️ LOOP IN THE FOLKS YOUR LAUNCH MIGHT IMPACT. PMs often underestimate how Ops, CS, or Billing will be impacted. Don’t make it their surprise. ⚪️PROTECT THE USER EXPERIENCE Internal deadlines can move. Broken trust can’t. When this doesn’t happen…I once worked on a platform upgrade that shipped too soon. We hit the internal milestone but then spent 4x the time fixing CX issues with our top clients. It wasn’t worth it. That experience rewired how I think about velocity. The next go around when the team was pushing to ship but I knew we’d repeat the same vicious cycle, I pushed back. I gathered the data, showed the time it took to repair and improve the CX and the associated costs. As a result, we shipped two weeks later but spent 4x less in post-launch defect management mode. Short term pains for long term gains. Taking the time to ship isn’t hesitation. It’s smart. It’s strategy. It’s about putting in the right work, right now for the right customer experience later. So ship smart, not fast. Particularly not for the metric. #productmanagement #productmanager #shipsmart