July 28, 2022
 min read

Five reasons why an Internal Developer Platform is worth it

The complexity of software development and delivery is constantly increasing. In this blog post, DevOps advocate Enric Forn provides an overview of how an Internal Developer Platform can help to overcome complex challenges and why it is worth it.

All types of companies regardless of their size are creating more software apps every day. Over the past four years, deployed apps per customer have risen for a combined growth of 22%, based on analysis by Okta Inc. Increased software codebase in organizations often means higher complexity of their systems. Add to that the shift to microservice architecture in cloud native setups, which has been underway for many years now. How can you deal with this complexity? How can you develop more software at the same pace or even faster? How do you rationalize your software and infrastructure?

In this post, you will learn how to deal with this complexity and productively scale your ecosystem of tools through an Internal Developer Platform.

What is an Internal Developer Platform (IDP) and why do I need one

An Internal Developer Platform is a set of tools, services and processes that supports and accelerates your software development, while taking care of managing the underlying infrastructure.

Kaspar von Grünberg, Humanitec’s CEO defines an IDP “as a self-service layer that allows developers to interact independently with their organization's delivery setup, enabling them to self-serve environments, deployments, databases, logs and anything else they need to run their applications.”

In their journey to an efficient software development process, teams often struggle with trying to find the right balance between the standardization of infrastructure and applications and giving enough freedom to developers to customize the applications and self-serve the tech they need. An IDP comes with standardization.

Let’s take the example of a developer creating a new application. Usually they would manually have to create a repo in the SCM, assign permissions to all contributors, create a ticket for the infrastructure team to provision resources like databases, file storage or DNS for the application and finally deploy the application. All of this is automated by an IDP, which also eliminates key person dependencies between developers and operations.

Additionally, we could develop a plugin in our preferred IDE or web application that, based on an application name, technology stack and traffic load requirements, automatically registers our new application in our Application Portfolio Catalog.

Win-win for everyone

Some of the advantages listed below are closely interconnected. Let's detail the most important advantages of using or start implementing an IDP:

1. Alignment

Via an IDP you explicitly define what type of infrastructure you can deploy and what types of applications are supported. The offering is robust and well-defined. Everyone knows the expectations of the system. A detailed documentation on how each tool or integration works is crucial, to create transparency on the development process.

2. Compliance and governance

Having your development process implemented throughout an ecosystem of tools allows you to drive software development to satisfy some requirements. For example, from a software development lifecycle perspective, avoid anti patterns implemented by analyzing code statically. Digging a little bit more on this example, you can run an analysis using the sonar scanner of Sonarqube as a step of your build process and use your standard Quality Gate, which automatically decides if the analyzed code has the quality for being built. I used to customize Quality Profile with these custom rules. From an infrastructure perspective, by implementing an IDP, you can automate the provisioning of the resources needed, and assure that the platform is hardened and secured automatically. You can store information regarding your data, applications, and supported infrastructure. All these catalogs are commonly used by architects to manage applications and define evolution roadmaps. 

3. Let dev teams focus on business value

An IDP brings self-service features by automating tasks, which your development teams do not have to worry about any longer. For example, imagine that we implement a feature in our IDP in which you type a name of the application, and define the required components (e.g., a React SPA, an NPM component and a web service implemented in Rust). By introducing this information to the IDP, you can automate the following tasks:

  • Automatically provision a group with some repositories in your SCM.
  • Create three repositories for each component and assign a pipeline to each repo as a webhook.
  • Apply a default template to the project.
  • Allocate resources to the development and production environment to allow the deployment of the application.

The usability of such a toolchain smooths the path of using your ecosystem of tools, and developers spend just minutes to click on the right options to allocate the resources needed.

4. Autonomy

Developers have all the tools they need and are easily accessible to do the required job in the expected timeline. An IDP also enables teams to centralize interactions inside the platform. It liberates team members from dealing with ticketing tools with different workflows and instead interact with other teams. If you need to create a new application or business logic, you simply access the IDP and you are able to self-serve the resources you need.

5. Efficiency

Autonomy in software development increases speed and reduces the cost of interacting with other teams in your organization. Your IDP must integrate a set of tools which allows using this ecosystem really fast. To check if you are on the right way, you should measure the efficiency in delivering software. Lead time, deployment frequency, change failure rate and mean time to recover are great indicators.

Start building your IDP now

The implementation of an IDP needs to be tailored to each organization. Start delivering small changes that benefit development teams in their daily work:

  1. Identify in your software development process actions to automate or integrations between tools developers use daily.
  2. Validate if there's any open source tool that fixes this gap, probably other teams had this problem before. Take a loot at CNCF Cloud Native Interactive Landscape, there's a bunch of useful tools.
  3. Integrate this new product whether it is built or bought as smoothly as possible to the development lifecycle.
  4. Measure the impact in terms of development performance (How to measure your development process), and share results with all stakeholders (Developers, Product Managers, C-Level).
  5. Repeat process.

You can also consider contacting companies experts in this field like Humanitec or Shipa, which have built great SaaS products.

Don't hesitate to contact me if you want more information about how to evolve your development ecosystem.

Thanks for reading!

Interesting Links

Latest articles

Browse all