How Platform Engineering Tackles a New Software Crisis

Are We Facing a New Software Crisis?

Yes, we are facing a new software crisis! Or at least I think we are. The growing complexity of software systems, combined with rising development costs and missed deadlines, resembles the original software crisis of the late 1960s.

In this post, I’ll explore why history is repeating itself and how modern solutions like Platform Engineering can help solve the challenges of today. But first, let’s take a quick look back at the original software crisis to understand the parallels.

The Original Software Crisis 

In 1968, a Software Engineering Conference took place in Germany. Attendees were surprised they shared the same struggles: software projects running over budget, missing deadlines, or failing to meet expectations. In 1972, Edsger W. Dijkstra, a participant in that conference, coined the term “Software Crisis” to describe the issues in software development.

One reason for this crisis was inexperience in software projects. Design patterns and polished frameworks did not exist. Additionally, early software projects seemed successful, leading people to believe software development was easy. However, the reality was quite different. Many projects faced unmanageable complexity, resulting in bugs, technical debt, and delays.

Challenges contributing to the new Software Crisis

In today’s world, software plays a far more critical role than it did in the 1960s. Yet, we continue to see projects fail with similar characteristics: budget overruns and missed deadlines while failing to meet expectations. A prime example is the launch of HealthCare.gov. Launched in 2013, the initial rollout of the U.S. government’s health insurance website was a disaster. The site was filled with bugs, crashed frequently, and missed multiple deadlines. The project faced massive budget overruns and ultimately required a complete overhaul to function as intended.

Could history be repeating itself, or are we witnessing a new crisis? Let’s go over the four areas contributing to the latest software crisis.

1. The rise of new technologies

Looking at the current rise of new technologies, tools, and ways of working, you would think we are trying to prevent a new software crisis. Take, for example, DevOps, which seeks to streamline development and operations. But by doing so, developers are slowed down by the complexity of managing pipelines, automation, tests, and infrastructure. But DevOps is just one of many examples. Here’s a broader list of challenges developers face:

1. Microservices and its inherent complexity
2. Containerisation and Kubernetes
3. Cloud Native software development
4. Security, Compliance, and Governance
5. (Cloud) Infrastructure

All these new technologies and tools are increasing the cognitive load of software development teams and slowing down their ability to deliver value.

2. Increased codebases

Software projects are becoming increasingly complex. For example, in the early 2000s, the software for a commercial jet might have involved around 6 million lines of code. In contrast, today, a modern car can contain over 100 million lines of code, incorporating numerous advanced features like autonomous driving and infotainment systems.

3. Dependencies

Modern software systems increasingly rely on various external services, APIs, cloud infrastructures, and third-party tools, creating complex dependencies. While these integrations are essential for enhancing functionality, they can also introduce significant challenges.

4. Inefficient IT organisations

Autonomous software development teams designed for innovation often reinvent the wheel by selecting different tools, frameworks, and approaches. This fragmentation slows the teams and impacts the organisation’s ability to scale efficiently. According to the latest Atlassian Developer Experience report, 69% of developers lose over eight hours weekly to inefficiencies. This translates to nearly ten weeks of lost productivity per year.

Convinced yet that we are indeed in a new software crisis? Let me introduce you to a potential solution: Platform Engineering. It could be the key to resolving many of our current challenges.

How Platform Engineering Tackles the Software Crisis

The core idea behind Platform Engineering is simple: instead of every team building its own environments, pipelines, and toolchains from scratch, a centralised (internal developer) platform provides reusable components. These platforms allow developers to innovate without getting slowed down in the repetitive tasks of infrastructure management, observability, pipelines, and security. It’s about creating a system that allows software teams to focus on delivering value while the platform handles the complexity behind the scenes.

Interactions between software development teams and these platforms are critical. We don’t want another bottleneck or handover. We want developers to stay in the flow. This means that this platform should be able to deliver through a self-service portal and X-as-a-Service. Are you in Need of a specific infrastructure component? Request it through a self-service portal without any human interaction.

The Developer-First Approach

At its heart, Platform Engineering is about making life easier for developers. By abstracting away the complexity, we reduce the cognitive load so that developers can focus on what they do best: building software. This “developer-first” mentality ensures that teams have the tools and resources to be productive and innovate without unnecessary friction.

In a world where software is becoming increasingly complex, Platform Engineering offers a lifeline, helping organisations manage chaos and build scalable, reliable, and efficient systems.

Do you want to know more about Platform Engineering or how to adopt it successfully? Download the following whitepaper, or contact me through Linkedin: 

• Whitepaper: https://pages.xebia.com/whitepaper-successful-internal-platform-adoption 
• LinkedIn: https://www.linkedin.com/in/jelmerdejong-xebia/

Conclusion

The first Software Crisis taught us that unmanaged complexity and inefficiency can slow down software development. Unfortunately, many of these challenges remain today, only amplified by the rise of modern technologies and the expanding scope of software projects. However, we are not without solutions.

Platform Engineering offers a path forward by streamlining development, reducing cognitive load, and improving developer productivity and experience through automation and standardisation. It represents a proactive approach to preventing history from repeating itself.

While the software crisis may never (entirely) disappear, adopting practices that simplify complexity and enable developers to work smarter, not harder, is crucial. The sooner we invest in these solutions, the sooner we can overcome the challenges of Software Crisis 2.0.