Request access

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

How to improve your Software Delivery Lifecycle

Samir Brizini
Samir Brizini
Chief Product Officer
Rely.io
Samir Brizini
June 5, 2024
7
 min read
How to improve your Software Delivery Lifecycle

Understanding and optimizing each phase of the SDLC can lead to faster delivery times, higher-quality products, and more satisfied customers.

The Software Delivery Tightrope: Why Some Companies Waltz Across While Others Stumble

The software industry has undergone a remarkable metamorphosis. Remember back in the day, when software development felt like a niche pursuit for academics and hobbyists tinkering in basements? 

Fast forward a few decades, and the scene has transformed completely. 

Software has become the invisible engine driving almost every aspect of our lives, from the apps on our phones to the complex systems powering global corporations.

The global software market alone is expected to reach a staggering $1.8 trillion by 2032, with a compound annual growth rate (CAGR) exceeding 10%. This explosive growth underscores the critical role software plays in today's world.

Gone are the days of waterfall methodologies and glacial release cycles. Today's software landscape is a fast-paced dance, a constant push and pull between innovation, agility, and rock-solid stability. 

Companies are under relentless pressure to deliver high-quality software at breakneck speed, all while navigating a minefield of ever-evolving technologies and an ongoing war for top developer talent.

It's a bit like walking a tightrope. Some companies seem to glide across effortlessly, consistently churning out reliable features and updates. Others, however, teeter precariously, struggling to maintain stability while progress inches forward. The million-dollar question is: why? What separates the software ninjas from the stumblers?

This is the question that continues to plague leaders in the trenches of software development. In this article, we'll delve into the secrets behind efficient software delivery, uncovering the hidden forces that influence a company's ability to innovate and adapt. 

We'll explore the role of industry best practices, the impact of developer experience (and the tools that support it, like Internal Developer Portals), and the critical importance of fostering a culture of ownership within development teams. 

Along the way, we might even stumble upon some valuable insights to help your development team move from stumbles to smooth sailing.

The Software Delivery Maze: Lost Without a Compass

Imagine you're a CEO leading a company at the forefront of the software revolution. You're under constant pressure to deliver innovative features at breakneck speed, all while ensuring rock-solid reliability and security. 

One day, during a leadership meeting, you ask a seemingly simple question: "How are we doing?" But the answer proves elusive.

Engineering leaders scramble to gather data, delegating the task to their teams. The response? A flurry of disjointed metrics, each team measuring success in its own way. 

Team A boasts about their five major releases last month, while Team B proudly reports zero critical security incidents. Team C, meanwhile, celebrates keeping database lock contention at a minimum.

The problem? These disparate indicators paint an incomplete picture. 

Leaders struggle to create a consistent report that reflects the true state of software delivery performance. In a valiant attempt to bring order to the chaos, a "solution" emerges: performance squads, review committees, and a dedicated project manager. 

Their mission: to define standardized metrics, guide implementation across teams, and encourage engineers to instrument their code for data collection. Tools and libraries are explored, and persistent efforts are made to motivate teams to prioritize this initiative.

Six months later, however, the progress is disheartening. Metrics remain "somewhat" defined, instrumentation crawls at a snail's pace, and data dashboards built by eager interns display… well, not much actual data. 

The manual approach to performance evaluation has proven to be a time-consuming labyrinth, leading to inaccurate insights and delayed decision-making.

There are, of course, some teams that skillfully managed to overcome (or sometimes even lucked into it) the initial hurdles of instrumentation and reporting. 

They now face a new challenge: deciphering the data itself. How should they interpret these metrics? What constitutes a "good" value or a healthy threshold for these curves? 

If their metrics are green internally but pale in comparison to industry benchmarks, are they fooling themselves?

The most experienced teams, the ones who've mastered interpreting the green and red zones, now face the toughest battle: driving those metrics in the right direction. How do they turn red metrics green? How can they keep green metrics even greener?

Some leaders fall back on a simple (and ultimately ineffective) approach: they ask their engineering teams to "do better" then cross their fingers. At this level of analysis, metrics are necessarily aggregated. 

This is the only way to abstract some of the complexity that comes with a granular case-by-case analysis of every team, service, resource, incident, process, etc. However, translating these aggregated metrics into actionable pieces that individual engineers can own and improve upon is a whole different beast.

Consider a well-known metric like Mean Time to Resolve (MTTR). How can an individual contributor infer what specific actions they should take to improve it? It's a daunting task, encompassing numerous processes and decisions beyond their immediate control (code instrumentation practices, observability practices, alerting and on-call strategies, escalation policies, etc.).

This is the frustrating reality for many software leaders and their teams. Without a clear compass, navigating the complexities of software delivery becomes a guessing game. 

But there's a better way. In the next section, we'll unveil how fast-shipping companies select and leverage their key performance indicators (KPIs) that matter. 

We'll explore how they're translating data into actionable insights that illuminate the true performance of their development teams.

Escaping the Maze: Navigate with Proven Strategies

Imagine yourself standing at the entrance of a vast, labyrinthine maze. Reaching the other side represents the efficient delivery of high-quality software. But instead of clear paths, you're confronted with a tangle of dead ends and confusing forks in the road. 

This is the reality for many software leaders struggling to optimize their Software Delivery Lifecycle (SDLC).

The good news? You don't have to wander aimlessly. Just like explorers rely on maps and compasses, there are proven strategies to navigate the complexities of software delivery. 

Here's a powerful approach that leverages the collective wisdom of successful teams:

1. Leverage the Collective Wisdom:

Resist the urge to reinvent the wheel. Resources like the DevOps Handbook, the Phoenix Project, and Site Reliability Engineering: How Google Runs Production Systems offer valuable insights and best practices honed by industry leaders.

Consider adopting established tools which embed these frameworks. Internal Developer Portals (IDPs) are built around a Software Catalog that can help visualize the entire software delivery pipeline, identify bottlenecks, and prioritize areas for improvement.

While almost self-evident, many companies fall prey to the "special and unique" syndrome. They believe their case is so different that established best practices do not apply. The reality? Look at the near-universal adoption of similar developer tools across industries. 

A simple yet powerful indicator of this is the transvertical representation of the DevTools in the Software editing market. By and large, we all use the same tools for the same purposes. Very few industries diverge from this fact (for instance, Perforce instead of Git in the Gaming Industry is an exception, not the rule).

Another, more dangerous aspect of the "reinvention of the wheel" is the cost of opportunity. While iterating over a custom framework, teams are not delivering value, attacking tech debt, or improving their SDLC through established methods. 

Experience has proven that an "okay" process you can start implementing immediately is far better than attempting to build your own flavor of indicators and frameworks.

2. Start Broad, Focus Deep:

Don't get overwhelmed by a sea of potential metrics. Instead, take a step back and identify the areas currently causing the most pain:

  • Are slow deployment times hindering innovation? 
  • Are frequent incidents frustrating customers? 

Resist the temptation to create an exhaustive list of everything wrong. If only one thing, Gregory House demonstrated that if your diagnostic tool in medicine is a full body scan, you'll always find something wrong and get lost in analyzing and solving meaningless issues. 

Focus on one critical area at a time. Plan for it, get it into motion with predictable confidence, and only then move to the next.

If you're looking for inspiration on how to successfully drive change, this blog from Pedro Alves is a great read. Zalando embarked on the SLO journey and after over a year, they only mainly covered Availability SLOs before moving to Latency. But they did it right.

3. Establish Meaningful Benchmarks:

Now equipped with a newly found confidence that Incident Management or innovation speed are where you're losing the battle, you can pick a framework that fits your needs (e.g., DORA for engineering performance). 

These off-the-shelf options don't preclude you from stacking on top of them meaningful indicators that are insightful in your situation. However, this has to be done right. Metrics are powerful tools, but only if interpreted correctly. 

Raw numbers often lack context. For instance, is 25 incidents a month a good or bad thing? It depends! For a team of one engineer and a single static webpage, that's quite a bit. For an entire engineering organization of 2000 engineers and millions of code lines? Twenty-five incidents are far less than you’d expect.

Consider ratios that provide a clearer picture. For example, "Incident / Code Contributor" ratio can reveal trends in incident management efficiency as your team grows. This is one trick to solve the red or green conundrum: if the ratio diverges up, the company is unequivocally less and less efficient at handling growth and adding developers is adding fuel to the fire. On the other hand, if the ratio converges down towards zero, then your growth is healthy (from that standpoint at least).

4. Automate for Reliability:

Forget the days of unreliable, manual data collection. Embrace automation! And embrace it at every level:

  • The obvious one: KPIs are reported as part of automated processes (think webhooks, CI/CD pipelines, cron scripts, etc.) or regular and well-established ceremonies (e.g. Sprint Retros).
  • The almost always forgotten one: Automated tracking of which teams are reporting which KPIs and whether said reporting has been automated. 
  • The expected but often overlooked one: Reporting on these KPIs and their adoption should also be automated.

IDPs offer a streamlined approach to data gathering and visualization. These platforms go beyond simple data aggregation by providing pre-built dashboards and scorecards tailored to specific challenges. This saves valuable time and eliminates the uncertainty of manual reporting. 

Imagine an IDP like Rely, providing you with readily available data and clear insights, allowing you to focus on what truly matters – optimizing your delivery process.

5. Align Incentives, Drive Improvement:

Metrics are only valuable if they translate to action. Here's how to move beyond static analysis:

  • Implement processes that encourage or even enforce adherence to key metrics. Studies show that manual production rollouts significantly hinder delivery speed. This means metrics like DORA can be heavily and negatively impacted. Consider automating deployments while empowering developers to focus on high-impact tasks.
  • Break down your aggregated KPIs into more granular metrics that individual engineers can understand and translate into actionable changes. Micro-wins are key to sustained motivation.
  • Break down targets on these metrics into a more achievable sequence of milestones with clearly defined recognition along the path of improvement. Gamification can be a powerful tool here. Modern tools like IDPs embed these notions natively. For example, the Rank system (No Rank, Bronze, Silver, and Gold) in Rely's Scorecards allows you to define increasingly demanding milestones, each made of discreet requirements. This translates improvement into small and easily understood changes, the succession of which will drive the desired metrics into the green.

Here's the trap to avoid: If a team is deploying once every two months, asking them to deploy twice a week (like top performing teams) will only create frustration and chaos. The transformative effort required within their organization, architecture, and development processes is simply too vast. 

 This "big bang" approach often leads to weeks or months of planning that gets derailed by the realities of daily operations. Instead, set incremental targets. Even individual contributors can unknowingly contribute greatly by making small changes (e.g., reviewing code faster, increasing test coverage).

6. Rinse and Repeat with Patience:

This is an ongoing journey, not a one-time fix. Embrace the concept of continuous improvement. Use your metrics to identify areas for improvement, implement changes, and monitor the impact. Tools like Reports in IDPs can help visualize the workflow, track the progress of adoptions, and identify areas for further optimization.

You will not get your metrics right from the start. Their collection and reporting will not be properly automated on the first attempt. Keep your eyes on your incremental progress and keep nudging your teams. Now backed with data-driven reporting, demonstrate how small and incremental progress at a small scale ends up making a significant impact and driving positive results

The Path to Efficiency Awaits:

By following these principles, you've built a solid foundation for a more realistic and efficient way of conducting change. In the follow-up article, we will delve deeper into specific frameworks that can supercharge your efforts specific to improving the SDLC. 

We'll explore how metrics like DORA and frameworks like SPACE can be effectively applied within the funnel approach described above. We'll also showcase how IDPs like Rely empower leaders with readily available, actionable data through features like Scorecards. 

By combining these strategies, you can transform your software delivery from a frustrating maze into a well-oiled machine of innovation.

Samir Brizini
Samir Brizini
Chief Product Officer
Rely.io
Samir Brizini
On this page
Contributors
Previous post
There is no previous post
Back to all posts
Next post
There is no next post
Back to all posts
Our blog
See related articles
What are Day 1 and Day 2 Operations for Platform Engineers
What are Day 1 and Day 2 Operations for Platform Engineers
For technical leaders, platform and DevOps engineers, mastering both day 1 and day 2 operations is crucial for ensuring smooth operations.
John Demian
John Demian
July 12, 2024
9
 min
How to Implement Developer Self-Service Successfully
How to Implement Developer Self-Service Successfully
Developer self-service empowers developers to build and manage their services and resources independently from DevOps, accelerating development cycles without any compromises on quality or standards.
John Demian
John Demian
June 21, 2024
9
 min
The ultimage guide to Dora metrics
The ultimate guide to DORA metrics
As platform engineers, DevOps engineers, and technical leaders, embracing DORA metrics can propel your teams towards operational excellence and streamlined processes.
John Demian
John Demian
June 14, 2024
7
 min