DEV Community

Cover image for Platform engineering 2026: five challenges and how observability helps meet them
Span Observer
Span Observer

Posted on Originally published at span.observer

Platform engineering 2026: five challenges and how observability helps meet them

Platform engineering in 2026 no longer has to prove its worth: the vast majority of organisations that practise it have an internal developer platform, and many have rolled it out widely. The challenge has changed in nature. It is no longer about building the platform, but about keeping it standing under pressure from new tools, ever more cloud services and, above all, the arrival of AI in pipelines as well as in applications. Here are the concrete platform engineering 2026 challenges, and how observability helps to meet them.

Dynatrace’s State of SRE and Platform Engineering 2026 study puts figures on these frictions: difficult integration, automation gains below expectations, value that is hard to demonstrate and a growing workload from AI governance. Nothing surprising for anyone who runs a platform day to day, but the convergence of the answers is instructive.

This article reviews five concrete challenges and proposes, for each one, an operational answer in which observability acts as the common foundation.

Challenge 1: integrating without multiplying connectors

For 37% of respondents, getting existing tools to work with the platform is the main difficulty, and nearly a third struggle to maintain consistent standards across teams. AI adds another layer: every coding assistant, agent or model-tracking tool requires its own access, tokens and rules.

The answer lies in interoperability standards. OpenTelemetry for telemetry, and now the Model Context Protocol to give assistants structured access to tools and data. Rather than writing one connector per pair of tools, the platform exposes governed MCP servers. Our guide to the Model Context Protocol explains the principle, and the example of Dynatrace in Microsoft Teams via MCP shows what it looks like in practice.

Challenge 2: automation that does not deliver on all its promises

Teams expected AI to bring less repetitive work, more regular releases, lower costs and faster incident resolution. The study shows a consistent gap between expectations and observed results, except on one point: developer productivity, where the gains observed are close to what was hoped for.

The most likely explanation is context. Automation that knows neither the topology, nor a service’s owner, nor its criticality makes fragile decisions. Before extending the autonomy of AI-driven workflows, you need to feed them with correlated telemetry and keep a human in the loop. The topic is developed from the SRE point of view in AI and day-to-day reliability.

Challenge 3: demonstrating the platform’s value

About three organisations in ten say they struggle to justify their platform. A platform treated as a product needs product indicators: adoption, time to onboard a new project, share of deployments that go through the paved road, incidents avoided. These indicators can be measured with the telemetry the platform already produces, provided it is collected consistently.

Challenge 4: compliance that is still too manual

Nearly half of teams carry out at least some compliance checks by hand, and the complexity of security and compliance remains a source of friction. The most effective route is well known: describe everything as code (infrastructure, configuration, observability, policies), version it, and have the pipeline validate it automatically. Along the way, you get a usable audit trail.

Challenge 5: AI governance, an unplanned workload

More than half of platform engineers now spend time monitoring AI tools: data security, performance, accuracy. It is work that nobody had planned for. AI systems drift, behave probabilistically and raise questions of cost and accountability that did not arise for a classic service. The corresponding requirements are detailed in what AI workloads change for SREs.

In practice: making observability the foundation of platform engineering 2026

Step 1 — Standardise the instrumentation layer

A single format (OpenTelemetry), a single collection point per environment, and mandatory context attributes: owning team, criticality, environment. Without these attributes, telemetry remains noise that is hard to use.

Step 2 — Publish a paved road with observability included

The project template provided by the platform includes telemetry, SLOs, security checks and, for AI services, token tracking and evaluations from the outset. A project descriptor might look like this (generic format):

gabarit: service-api-ia
proprietaire: equipe-recommandation
criticite: haute
observabilite:
  traces: otlp
  attributs_obligatoires: [team, criticite, environnement]
  slo:
    - disponibilite: 99.9
    - latence_p95_ms: 800
ia:
  modele_autorise: [modele-interne-v3]
  suivi_tokens: true
  evaluation_continue: echantillon_5_pourcent
securite:
  scan_dependances: bloquant
  secrets: coffre-central
Enter fullscreen mode Exit fullscreen mode

Step 3 — Expose context via MCP

Rather than letting each team connect its assistant to five tools, the platform publishes a small number of MCP servers, with read-only rights by default and logging of calls. Securing these servers is covered in our dedicated article.

Step 4 — Validate every release in the pipeline

The pipeline compares the signals of the new version (errors, latency, consumption, evaluation score for AI) with those of the previous version and blocks it if there is a regression. Compliance becomes an automatic check rather than a checklist.

Step 5 — Measure the platform as a product

A dashboard for the platform itself: number of services created via the paved road, onboarding time, share of compliant deployments, time spent on manual tasks. These are the figures that answer the question of value.

Best practices

  • Treat reliability, security and observability as requirements of every automated workflow, not just of services.
  • Regard model drift as an operational risk, monitored continuously.
  • Favour open protocols (OpenTelemetry, MCP) over ad hoc integrations.
  • Version configuration, policies and observability settings for auditing.
  • Extend automation autonomy in stages, with escalation and explanations.

For the complete view of the AI systems lifecycle, from prototype to production, see our guide to AI observability.

Frequently asked questions

Platform engineering 2026: what are the main challenges?

Tool integration, consistent standards across teams, automation gains below expectations, difficulty demonstrating value, compliance that is still manual and the governance of AI tools.

What is the role of observability in an internal platform?

It provides the common context (telemetry, topology, owners, criticality) on which automation, release validation, governance and measuring the platform’s value all rely.

Is MCP useful for a platform team?

Yes, as a standard for connecting assistants and agents to internal tools in a governed way, rather than multiplying specific integrations. In return, it demands real attention to security and permissions.

Conclusion

Platform engineering in 2026 is a mature discipline facing a new wave of complexity. The teams that succeed standardise their instrumentation, equip their paved roads for AI, automate compliance and measure their platform as a product. For the standards mentioned, the official Model Context Protocol documentation is a good starting point.

Further reading: How to tackle platform engineering’s biggest challenges in 2026 (Dynatrace blog).

span.observer is an independent community blog, not affiliated with Dynatrace LLC or the projects mentioned. Trademarks belong to their respective owners. Tools change quickly: check commands and options in their official documentation.


Originally published on span.observer. French version: https://span.observer/fr/platform-engineering-2026-defis/.

Top comments (0)