Developers Should Use the Software They Write

At JBS Dev, we believe software should work seamlessly for its users. One of the most effective ways to ensure this is for developers to actually use the software they write. When developers deeply understand the end-user experience, it transforms how they code, test, and refine their work. Simply put, a developer who regularly interacts with their own software builds more intuitive, responsive, and robust solutions. Here’s why it makes all the difference.

Understanding the Business, Not Just the Code

A great developer isn’t just a coder; they’re a problem-solver with a strong grasp of the business’s needs. They don’t need to rely on a business analyst to convert requirements into rigid rules—they understand the intent behind the requirements. By interacting directly with the software, they develop a deep understanding of what the business wants and make real-time decisions that align with those goals.

A good example of this comes from a project where a developer was tasked with building a product detail page. The spec detailed a scenario where a user could customize a product before adding it to the cart, with specific instructions on what should happen if the user clicked the back button or navigated away mid-customization. But there was one problem: the existing design had no navigation option on the page—no way for the user to actually leave the page without closing the browser. Rather than simply following the spec as written, the developer reached out to the designer and pointed out, “Hey, we need a way for users to close this window. The business clearly wants users to be able to leave mid-customization; that’s why these steps are included in the spec.”

Pride of Ownership Leads to Better Regulation

When developers use the software they write, they take ownership of its performance and usability. They’re not just ticking boxes; they care about the experience. This pride shows up in cleaner, more adaptable code that can evolve as needs change. A developer invested in their own product builds software they themselves would want to use—software that’s intuitive, logical, and efficient.

On the other hand, when developers don’t use their own software, it can lead to a frustrating and poor user experience. The software may feel clunky, not intuitive, or difficult to navigate. As we often say, if it requires training to use, it’s not great software. Good software should be so intuitive that users can start using it without extensive instruction, and developers who use their own software naturally create a more seamless experience.

Real-World Testing

When developers engage with their own software, they’re more likely to catch issues before they ever reach the user. They experience firsthand what users experience, which gives them a unique perspective on areas that need improvement. Slow load times? Bugs? Frustrating navigation? Instead of just tolerating these issues, they’ll be motivated to fix them immediately.

Imagine a developer working on a requirement who notices a lag when switching between screens. Instead of ignoring it, they can improve it right then and there without waiting for it to become a reported issue. This proactive approach leads to faster and smoother software and better user experience.