Building Sustainable Software in a Changing Landscape

TL;DR

Building sustainable software requires strategic decision-making to balance immediate needs with long-term maintainability. By understanding trade-offs, managing scaling costs, and applying principles like Hyrum’s Law, developers and leaders can create resilient systems—even in dynamic environments such as startups or early proof-of-concept features and products.

"Nothing is built on stone; all is built on sand, but we must build as if the sand were stone."

— Jorge Luis Borges

In the ever-evolving world of software engineering, sustainability and the management of scaling costs are paramount. Whether you're leading a development team or steering a startup, making informed, strategic decisions can significantly impact your organization, product, and development processes.

Sustainability and Strategic Trade-offs

As software engineers and leaders, our primary goal(hope) is to create systems that are not only functional but also sustainable in the long run. This involves carefully evaluating trade-offs and making rational decisions about where to invest our efforts. Sometimes, this means postponing maintenance tasks or adopting temporary solutions with the understanding that these choices will need to be revisited in the future. Clear and explicit communication about these deferred costs is crucial to ensure that all stakeholders are aware of the implications.

The Reality of Short-lived Code

In many industries, especially in early-stage startups, code often has a short lifespan. Frequent rewrites and a focus on immediate goals are common as companies strive to adapt quickly to market demands. Developers in these environments may have extensive experience in rapid development but limited exposure to maintaining long-term projects. This dynamic can lead to challenges in sustaining software quality and infrastructure over time and create a huge technical debt.

Insights from Hyrum’s Law

A key principle to consider is Hyrum’s Law: “With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody.” This highlights the importance of maintainability over merely having a system that "works." When maintaining projects used by other engineers, it's essential to design APIs and systems that minimize unintended dependencies and ensure long-term usability(or atleast try as hard as possible).

Building as if the Sand Were Stone

To achieve sustainability, it's important to balance flexibility with stability. Adopting best practices such as modular design, thorough documentation, and regular code reviews can help create robust systems capable of adapting to change without accumulating excessive technical debt. Additionally, anticipating future needs and scaling challenges during the initial development phases can set the foundation for resilient software architecture.

How to calculate the Uncertainty of a Project

Building sustainable software is a balancing act between immediate needs and long-term viability. From startups to corporate projects, time pressures often lead to quick fixes, yet ignoring maintainability can create hefty technical debt. Hyrum’s Law reminds us that all observable behaviors eventually become dependencies, underscoring the need for proactive and clear engineering decisions from the outset.

In dynamic environments, especially when codebases may be short-lived or rapidly changing, it’s crucial to measure your project’s uncertainty before committing to deadlines. Assessing and reducing unknowns—whether they relate to customer value, usability, feasibility, or business viability—can determine whether you should start coding right away or conduct discovery first. By thinking of “sand” as if it were “stone,” you can avoid costly rewrites later. For a more comprehensive look at the trade-offs, uncertainty rubric, and techniques like assumption mapping, refer to the full article.

Conclusion

Building sustainable software requires:

-Proactive management of technical trade-offs

-Awareness of short-lived code realities (common in startup pivots)

-Designing with maintainability in mind (Hyrum’s Law)

-Planning as if the “sand” is “stone” (robust architecture despite changes)

-Measuring and reducing uncertainty before fully committing to timelines or large builds

By combining strong engineering practices with a simple framework for gauging uncertainty, you’ll be better equipped to navigate the balancing act between immediate needs and long-term resilience. Whether you’re in a mature corporate environment or a scrappy startup, learning how to handle uncertainty is key to creating software that stands the test of time and truly benefits both customers and the business.

😊 This is my first article—thank you for reading! Feel free to connect with me on LinkedIn. 😊

Sources:

[1]: Winters, T., Wright Hyrum and Manshreck, T. (2020). Software Engineering at Google : lessons learned from programming over time. Beijing ; Boston ; Farnham ; Sebastopol, Ca ; Tokyo O’reilly March.

[2]: Erik Wilde (2021). Hyrum’s Law: Hyrum Wright on Programming over Time. [online] YouTube. Available at: https://www.youtube.com/watch?v=5Wdgjw6IGDM.

[3]: Kleppmann, M. (2018). Designing data-intensive applications : the big ideas behind reliable, scalable, and maintainable systems. Sebastopol, Ca: O’reilly Media.

[4]:‌ Krehl, P. (2019). Product Discovery or Product Delivery: How do you Decide? [online] Mind the Product. Available at: https://www.mindtheproduct.com/product-discovery-or-product-delivery-how-do-you-decide/.