This is the first article in our Platform engineering survival: Solving the core challenges series.
The journey to building a robust, efficient platform engineering function is often fraught with internal hurdles. One of the biggest challenges, and a major bottleneck for developer velocity, is the twin problem of tooling fragmentation and a lack of an integrated product roadmap.
Here, Ayoze Hernandez, a lead software developer at Thoughtworks, shares his experiences and a recommended path forward.
The burden of tool overload: Simplifying complexity for modern developers
Growing enterprises often accumulate a huge number of development and operational tools in their ecosystem. And all too often we’ve seen these tools being used to enforce mandatory production gateways — applied to every product — without taking into consideration risk level and service maturity.
The sheer number of tools can also create a significant usability challenge for the development team. It can create huge amounts of additional work if documentation is outdated, or guidelines from other teams on how to integrate and get value from them are missing,
This has an immediate and detrimental impact on the project. Rather than focusing on delivering business value, development teams must first create an integration process from resources that are difficult to navigate and based on many dependencies. As a result, setting up the basic environment, connecting infrastructure to tools for logging and availability, and integrating deployment actions with other tools can take weeks.
Missing the integrated path: Bridging silos in the platform era
This complexity of disparate, outdated and contradictory information is a familiar scenario for many evolving platform teams. And while the initial focus is often on delivering a powerful set of individual tools, if they aren't woven into a cohesive developer experience, valuable insights, resources and documentation remain siloed within teams.
This can lead to a reliance on "tribal knowledge," where developers must seek out colleagues or reverse-engineer old code examples to understand how to integrate a new feature.
It’s a classic symptom of a platform still transitioning its focus from pure technical delivery to a product-centric mindset — one that views internal developers as its primary customers. When this gap between the tools and the developer experience exists, it often surfaces as understandable friction points:
Conflicting information: Teams may encounter data discrepancies, such as a security tool reporting a different status than the central developer portal. This can lead to confusion around compliance and wasted effort.
The platform as a "tollbooth": When the platform feels like a hurdle rather than a highway, adoption can naturally slow. This can delay the platform's ROI and even motivate teams to find workarounds.
Repetitive support load: Support channels can become overwhelmed with the same basic questions about tool usage and integration, stretching the platform team's capacity as they answer solvable problems.
Duplicated effort: Without clear, discoverable pathways, teams often "reinvent the wheel." This repetition undermines the very economies of speed that a successful platform is designed to create.
A steep onboarding curve: The initial setup for a new product can be a significant challenge. We often see that after a team has navigated this process and created its own internal documentation, subsequent environment promotions become dramatically faster. This simply highlights the immense value locked inside a clear, well-documented, and integrated pathway.
The communication breakdown: Impact on developer experience
Beyond clear knowledge sharing, another critical area for platform maturity is proactive change management. As the platform evolves, changes to underlying tools or infrastructure — such as updates to configuration standards or networking protocols — are essential.
However, when these updates are implemented without clear, timely and targeted communication, they can inadvertently lead to unexpected friction and instability for dependent product teams.
This dynamic is highly disruptive: it often requires product developers to immediately pivot from their value-adding feature development to urgent stability troubleshooting. This necessary diversion of effort significantly impacts the overall developer experience and slows down the delivery of business value.
When stability challenges become a recurring pattern, the environment can shift away from pure technical collaboration toward necessary internal navigation, hindering the momentum required to realize the platform’s intended return on investment.
The path forward: Embracing product thinking for platform growth
Our experience highlights a fundamental truth in platform engineering: a collection of tools does not equal a platform. A platform is a curated, integrated experience and success is defined by the ease with which developers can use it.
Often, platform teams are overloaded with support requests and fire-fighting — work that shouldn't be needed if the platform were treated as a product. By improving the experience, they would not only unblock product teams but also free up time to focus on strategic platform capabilities.
It’s clear that a lack of end-to-end integration, even with strong tools, has a negative impact on developer collaboration. Resolving this will lead to fast releases, better code quality, team alignment — and significant productivity gains for the business through shorter development cycles and lower operational costs.
The solution lies in a clear shift towards product thinking:
Create a mindset shift: The focus must shift from merely having tools to integrating them seamlessly. Providing a forum for experience exchange (incorporating customer documentation) can accelerate a clear, step-by-step path for developers that shows how all tools work together.
A maintained starter kit: That includes all required tools configured within its repository context. This will have the added benefit of enabling the platform team to consume their own services — an approach we have successfully implemented at a number of clients.
Measure developer experience: To help identify friction and bottlenecks — and inform where to make investments that will improve speed, quality and impact.
Invest in centralized, high-quality documentation and direct feedback loops: Documentation must be treated as a first-class product artifact. This is crucial to prevent the creation of shadow documentation by product teams — documentation that quickly becomes outdated and only adds to the confusion.
Prioritize communication: Establish transparent change notification and stability processes, including advance notice, clear impact assessments and a reliable communication channel for platform changes.
Leverage AI for support: As a forward-thinking solution, Ayoze suggests that using AI-powered chatbots or tools trained on the platform's official documentation could offload repetitive support questions, allowing the platform team to focus on deeper engineering tasks.
The essential next step to accelerate innovation and maintain business agility is to shift from a list of steps that need to be done to an end-to-end platform experience that makes the right thing the easiest thing for developers.
This transformation involves not only evaluating suitable tools but also ensuring their frictionless integration and providing a clear, automated and well-documented platform that is seamlessly integrated into the developer workflow.
In the next article, we explore overcoming the challenges of an inadequate or absent platform operating model.
Disclaimer: The statements and opinions expressed in this article are those of the author(s) and do not necessarily reflect the positions of Thoughtworks.