Software That Matters:
Building for Value, Not Code
Focus on Value, Not Technology
The most important thing in software development is delivering real value. Programming languages, platforms, algorithms? Just tools. Interchangeable. Flexible. Irrelevant to the end user. This doesn’t mean the technical foundation doesn’t matter—or that you shouldn’t master your tools. It just means implementation is not the goal. The same outcome can be achieved in many ways. And yet, I still see technology taking center stage—even in testing.
Working Components Aren’t Success—Working Software Is
A single component functioning correctly is not success. Not in the bigger picture. It’s a basic requirement. Success is when many pieces come together into a finished product. Yet too often, the smallest unit gets all the attention. Unit tests with artificial data that never occurs in reality, just to prove “their part” works. For me, the interaction between components has the highest priority. Because only the sum of all parts creates usable software.
Acceptance Tests Are Essential—Everything Else Is Secondary
Acceptance tests are indispensable to me. More important than most other tests. They verify whether user requirements are truly met—and that’s the only thing that counts. With high code coverage, they provide a solid foundation for a reliable product. I don’t skip unit tests, but I prioritize high-value or high-risk use cases and supplement them with targeted technical tests. For component interactions (like web services), contract tests are a lightweight alternative to heavy integration tests.
Logging & Tracing: Only What’s Useful Matters
Structured logs and tracing are crucial—but only if they’re actually used. Either to show users an error state or to quickly diagnose issues. It’s not about maximum data—it’s about efficiency. Acceptance tests can even verify whether critical traces are captured correctly. This keeps the system transparent without over-engineering.
Pragmatism Over Perfectionism
I develop from the start with real use cases and deliberately avoid exhausting every technical possibility. Every line of code should be used, every function should provide direct value—covered by acceptance tests. This creates freedom in implementation because the focus stays on the what, not the how. No unused libraries, no isolated logic islands.
Shift in Mindset: From Code to Impact
It’s about seeing the bigger picture. What use cases does my code serve? What benefit does the user get? Developers who understand this write better code. Code that isn’t written today won’t need maintenance tomorrow.
Bottom Line: Value First
Start with the user, not the tech. A real use case, an acceptance test, clear logging—that’s how you build software that actually delivers. And stays maintainable.