IDP Trends: Where Do We Go From Here

We’ve shared a lot about Internal Developer Platforms (IDPs), what they can provide, and how we should build them. As they exist today, simple IDPs focus on improving dev workflows to make our development teams more efficient.

But what should we expect in the future? Will further developments and patterns in IDPs provide even more efficiencies? Will new opportunities open up to integrate additional tools that simplify product development?

In short, yes!

The more organizations start building and using IDPs to enhance workflows, the more development teams will expect IDPs to automate the toil, and the more benefits we’ll gain.

In order for you to stay on top of trends and continue to provide your developers with a competitive advantage, creating effective IDPs will become more critical than ever.

In this post, we’ll explore how IDPs will shape the future of software development by looking at existing trends and envisioning what else IDPs can bring to our teams.

To kick it off, let’s look at some of the biggest trends in software development today.

What Existing Software Trends Will Continue?

To determine what will happen with IDPs, we must first consider the environment our developers work in. By following development trends, we can shape how IDPs need to expand to meet future needs.

⚙️ Increased Complexity in Distributed Systems

First, we can expect software development to continue to grow in complexity. Distributed systems will continue to grow and become even more distributed.

Why is that?

To start, organizations will continue to utilize microservices and serverless systems as they attempt to compartmentalize their products’ complexities within well-defined boundaries. Even monolithic tech stacks don’t provide much value within a vacuum and require other systems and services to function.

With more services to manage and integrate, dev teams face more and more complexity in developing, testing, debugging, and understanding their systems. To simplify that complexity through automation, IDPs will continue to streamline their day-to-day activities.

🤖Reliance on AI

Next, let’s talk about our growing dependence and reliance on AI. We should consider this reliance to be a positive trend, and not one that takes the purity of software development away from our developers. Organizations increasingly leverage AI to enhance their software products, from automating repetitive tasks to optimizing performance. IDPs can harness the power of AI to augment the developer experience significantly.

Using AI as part of software development is the next step in taking tedious or basic tasks and simplifying software development. Similar to when developers all moved to IDEs, organizations are embracing tools to keep their development orgs efficient and productive.

Tools like Copilot, Tabnine, and CodeWhisperer will grow in functionality, and new competitors will join the market. New tools like release.ai will take those capabilities a step further, allowing development teams to interact with not just their code but also their infrastructure in a smooth and natural fashion. Teams already use tools like ChatGPT to automate the writing of documentation. Forward-thinking orgs will integrate these functionalities throughout the developer workflows through the IDP. Handwritten wikis and instructions will be replaced by AI-driven tools that provide the latest information with considerably less searching.

🚧 Establishment of Platform Teams

Finally, more organizations recognize the importance of dedicated platform teams responsible for delivering IDPs and integrating the various components.

These internal product teams build, test, market, and sell your IDP to your development organization. They play a vital role in providing developers with the tools they need to excel in their work.

The trend of building these platform teams will continue as their work leads to more efficient and productive development workflows.

‍

What IDP Trends Will We See?

Keeping in mind the development trends mentioned above, where should we expect IDPs to grow next?

🦾 More AI Integrations

As we already hinted, incorporating AI within IDPs will become more pervasive, improving the developer experience in several ways. Let’s take a look at a few of those:

:: AI-Written Documentation

AI will generate comprehensive documentation for internal services, development practices, and standards. This documentation will always be up to date, ensuring developers can access the latest information without hours of searching wikis, docs, and internal organization sites.

These docs, integrated throughout the developer workflow, will give our development teams the context they need when they need it.

Eventually, this AI-written documentation will extend to externally facing docs. At first, individuals will still review these docs, ensuring that the information is appropriate for external audiences. But eventually, with the right prompts and guardrails, you won’t need to spend human time and resources on documentation at all.

:: Automated Code Reviews

We already have some automated code checking through our IDEs and code linters. But is that it? Can we expect more?

Of course we can! AI-driven code review tools will further our capabilities, using context and `information about the entire system to point out potential flaws or to improve readability.

This will also help identify bugs faster and suggest potential fixes.

🌎 Improved Environments

Next, let’s talk about environments. The future of IDPs will drive improvements in developer and production environments, making development more efficient and responsive to real-world scenarios.

:: Emulating External Dependencies

Due to our growing complexities, our systems depend more on other tools, data stores, and APIs.

Right now, developers who require complex external dependencies to validate changes experience significant setup and toil to mock those dependencies. Whether mocking interactions between microservices or mocking APIs to infrastructure tools like storage and queues, it’s time consuming and difficult to create realistic test and developer environments that have all the working interactions that you’d expect of production.

In the future, IDPs will improve our environments to make them efficient and reliable. We’ll evolve beyond basic emulation of our dependencies and instead seamlessly mock external dependencies with minimal configuration.

There won’t be a question of whether something will work in production, because when it works on my machine, you’ll know it’ll also work in production.

:: Scalability and Provisioning

Though we don’t like to admit it, many organizations still manually scale environments to accommodate changes in load—either the upcoming expected load around a new feature launch or surprise loads coming from unexpected use or nefarious attacks.

Future IDPs will fully automate this process, integrating cloud tools, load forecasts, and real-time monitoring.

For example, in the future, we can expect IDPs to use predictive algorithms to anticipate increased (or decreased) load and scale environments accordingly. As another example, ephemeral environments can start up with the right amount of resourcing needed for their use. Environments used for simple testing will have minimal resources, while load test environments will have enough oomph to replicate what we’d see on a node in production.

Do you want to tie this into expected cost calculators and better reporting? Sure, why not! Teams will be able to track their infrastructure spend and receive alerts when trends indicate that they’ll exceed their budgeted amounts. Did your team forget to scale down environments after some load testing? No problem. They’ll soon get an email or a Slack message to their team channel so they can make changes as needed.

Ultimately, anything we’re still thinking through as engineers can be automated with the right context and expectations.

:: Production Bug Replication

Production bugs can be difficult to fix. Sometimes it’s hard to understand what’s really going on in our distributed systems. Also, replicating the bug locally can be close to impossible if we don’t fully know why it’s occurring.

With the right IDP integrations, we won’t just have tools like Sentry or BugSnag notifying teams of production exceptions. We’ll integrate AI components to provide context and potential fixes.

And if that doesn’t do it, the IDP can stand up an environment emulating that particular defect. In fact, if you’re using Release in production and can use that data to seed other environments, you could do this today.

To make it even smoother for the development team, they’ll have that environment hooked up to their IDE, so they can quickly debug and test potential fixes, all with little overhead.

‍

:: Performance Optimization

Next, let’s talk about performance.

We’re still in a distributed environment where fully understanding performance bottlenecks and constraints can be difficult.

In the future, IDPs can integrate components that provide performance analysis throughout the dev workflow. We’ll be able to empower developers with tools to optimize performance during development and before we get to production.

Using ephemeral environments, you’ll be able to quickly generate production-like traffic and use cases, enabling rapid testing and validation of functionality.

Imagine a scenario where an IDP not only measures code performance but also simulates realistic user interactions and data loads. Developers can proactively identify and address performance bottlenecks early in the development process.

🤝 Increased Collaboration Between Disciplines

One difficulty in almost any organization involves creating highly coupled collaboration between disciplines. A lot of this comes from different workflows, ways of working, and tools.

In the future, IDPs will bridge the gap between disciplines, fostering seamless collaboration by integrating more than just developer tools. IDPs will enable communication across the organization of the right data at the right time, similar to our body’s complex nervous system.

:: Integration with UX

To improve collaboration with UX, IDPs will soon integrate with UX tools like Figma and Miro, providing developers with easy access to validate workflows and UX for their work without hunting for flows and images.

Once deployed, UX can receive automated notifications and links to ephemeral environments to validate the customer experience.

:: Integration With Product Management

IDPs will integrate more closely with product management tools as well, providing real-time status updates that encompass not only pull requests but also projections on work completion. This integration will enable better estimations based on historical data.

Product managers can make more informed decisions based on real-time data.

:: Data Science and Data Warehouse Integration

Right now, whenever production schemas are updated, there’s often a separate task for either developers or data engineers to sync up the schemas between production and the data warehouse.

If this isn’t automated in any way within the workflow, we end up with missing data in our data warehouse, and our models fall out of sync.

Future IDPs will automate data engineering and data warehouse tasks by efficiently funneling changes from developers to the data warehouse. They’ll completely automate some tasks while also signaling for help when automation isn’t enough.

This automation will reduce the manual effort required to update schemas in response to code changes.

‍

Where Do We Go From Here?

For developers, complexity will continue to increase in our environments. At the same time, developers will need to expand the knowledge they need to work with that complexity.

IDPs that follow the current trends will continue to simplify development workflows either through AI capabilities or through adding spokes on the IDP wheel of components. These IDPs will develop into an all-encompassing and ever-changing platform based on development needs.

What does that mean for us?

If your organization already has a robust internal developer platform in place, you can begin expanding into future trends by experimenting with the ideas above.

On the other hand, if your organization is just beginning its IDP journey, it’s not too late. In fact, it’s a great time to get started. In order to capitalize on the changes headed our way, we need to begin building a solid base of automation today.

Either way, our priority should direct our efforts toward improving our IDPs to solve our most pressing problems today while leaving room for future integrations.

‍This post was written by Sylvia Fronczak. Sylvia is a software developer who has worked in various industries with various software methodologies. She’s currently focused on design practices that the whole team can own, understand, and evolve over time.