Today developers are often spending more time on managing Kubernetes than focusing on developing applications running on Kubernetes. This situation is exacerbated by the shortage of Kubernetes skills and by the complexity of developing and delivering well-tuned applications in Kubernetes environments.
Developers of cloud native applications are often struggling to keep up with faster and faster release rates, while also delivering the highest level of quality to end-users, at the lowest possible cost.
Companies are facing multiple negative consequences, including the inability to effectively support their digital innovation at the required business speed, which in turn may also heavily impact their bottom line, and to retain software engineering talent that is already so hard to find.
In this context, software engineering is evolving to better support developers, architects, platform engineers, DevOps and SRE teams. In this article, we briefly describe the innovation provided by Self-Service Developer Portals and AI-Augmented Software Engineering tools and how Mia-Platform and Akamas are combining the capabilities of their respective solutions to empower companies to take a more stable path in their digital innovation journey.
Why developers spend more time on Kubernetes than on code
Kubernetes skills are scarce, and delivering a well-tuned application on Kubernetes is genuinely hard. At the same time, cloud-native teams face rising release rates, a quality bar set by end users, and pressure to hold cost down. All three at once.
Three consequences follow for the business:
- Innovation slows. Digital initiatives miss the speed the business asked for.
- Margins take the hit. Slower delivery and wasted infrastructure both land on the bottom line.
- Engineers leave. Software talent is hard to find, and harder to keep when the work is platform toil.
Software engineering is adapting to this. Two categories have emerged to help developers, architects, platform engineers, DevOps and SRE teams: self-service developer portals and AI-augmented software engineering tools. Mia-Platform and Akamas combine one of each.
What a self-service developer portal actually does
A self-service developer portal is an internal product that lets developers deploy services without operating the platform. The category emerged to raise product-team productivity while keeping governance, security, compliance, quality and cost efficiency intact.
Gartner forecast in February 2022 that 75% of organizations with platform teams would offer self-service developer portals by 2025, to improve developer experience and accelerate product innovation. (Gartner, Innovation Insight for Internal Developer Portals, February 2022.)
What these tools do, concretely:
- Streamline the development, deployment and lifecycle management of software artifacts
- Integrate with software delivery platforms so CD and automation tools abstract the infrastructure away
- Cut friction across the whole software delivery lifecycle
A note on terminology. The same category goes by several names. Self-service developer portal, internal developer portal and IDP are used interchangeably. Internal developer platform is a related but distinct idea: the platform is the underlying capability, the portal is the interface developers actually touch. Backstage, Port and Mia-Platform are three of the products in this space.
Inside Mia-Platform: an internal developer portal built for Kubernetes
Mia-Platform is built for developing modern cloud-native applications on Kubernetes. It helps companies industrialize and simplify the software lifecycle: APIs, microservices and real-time data, event-driven architectures, and DevOps operations. Mia-Platform absorbs the cloud complexity so developers can build business products instead of setting up the platform.
Three tools do the work:
- Mia-Platform Console — the internal developer portal itself. Governs every project in one place and industrializes DevOps.
- Mia-Platform Fast Data — plug-and-play microservices for building a digital integration hub tailored to an industry.
- The Marketplace — a service catalog of ready-to-use components that speeds up development and promotes code reuse.
Recent Console releases let teams manage how cloud-native applications and their Kubernetes runtime environments evolve, so developers can stay on business logic.
Developers use the Console to create and configure every parameter for their microservices. This is exactly where Akamas complements it.
The gap portals leave open: Kubernetes and runtime configuration
A portal decides how a service gets deployed. It does not decide how much CPU and memory that service should get, or how its runtime should be configured. Those numbers still have to come from somewhere.
Getting them right is hard even for experienced performance engineers. Two data points:
- 33% of customers report that performance and resilience of Kubernetes applications is still an unmet challenge, across several Akamas polls.
- Tuning a single microservice can take up to two months, according to a provider of critical SaaS services. A real-world application has hundreds of microservices.
The difficulty comes from the interaction between two layers. Kubernetes has its own resource management mechanisms. The application runtime, the JVM or Go for example, has its own memory and threading model. Mismatch them and you pay twice: in wasted cost, and in poor end-to-end performance and resilience. Our JVM on Kubernetes optimization page covers this interaction in depth, and Akamas CTO Stefano Doni walks through it in this interview.
AI-augmented software engineering: closing the configuration gap
Over the last few years, vendors brought AI-driven solutions to market to help performance engineers find optimal configurations autonomously. The engineer stays in the loop to review and approve what is recommended.
Gartner names the category AI-Augmented Software Engineering (AIASE). In its August 2022 Hype Cycle for Software Engineering, Gartner observed that emerging AI tools can discover the best configuration for a set of operational goals, and that engineers using them are more productive, happier, and more likely to stay in their jobs.
Akamas supports developers, performance engineers and SRE teams in keeping complex real-world applications optimized. That covers cloud-native Kubernetes microservices running live, and what-if scenarios evaluated before they ship.
Akamas applies patented AI techniques driven by custom-defined goals and constraints (SLOs). The approach has been proven to deliver 65% cost reduction while improving application performance and resilience.
Akamas inside the Mia-Platform Console: how the integration works
Akamas live optimization integrates with Mia-Platform. Recommendations on how to tune Kubernetes requests and limits, plus any other application parameter, appear directly in the Mia-Platform Console. Developers never leave the portal.
The two halves divide cleanly:
| Concern | Self-service developer portal | Portal + AI optimization |
|---|---|---|
| Service scaffolding and templates | Yes | Yes |
| Deployment and lifecycle management | Yes | Yes |
| Governance, security, compliance | Yes | Yes |
| Choosing CPU and memory requests | Developer guesses, or copies another service | Recommended from observed behaviour |
| Choosing CPU and memory limits | Developer guesses | Recommended, SLO-constrained |
| Runtime settings (JVM, Go) | Out of scope | Tuned together with the pod |
| Keeping settings correct as load changes | Manual review | Continuous |
Mia-Platform users keep shipping well-tuned Kubernetes applications against their own cost-efficiency and performance goals and SLO constraints. Product teams deliver high-quality software and get more productive doing it, which is what the digital innovation programme was asking for in the first place.
The two companies formalised this as a technology and commercial partnership in November 2022.
What this means for platform teams
If you run a platform team, the portal and the optimizer answer different questions. The portal answers “how does a developer ship this safely without learning Kubernetes.” The optimizer answers “what should the numbers be.” Buying one and assuming it covers the other is the common mistake.
To go deeper on the optimization half:
- Akamas Insights applies this continuously across pods, runtimes and nodes
- Kubernetes Workloads covers pod resources and HPA scaling settings
- Balancing Kubernetes cost optimization and SLOs works a full example end to end
- The Kubernetes waste calculator gives you a number for your own cluster in a couple of minutes
FAQs
What is a self-service developer portal?
A self-service developer portal is an internal product that lets developers build, deploy and run services without operating the underlying platform. It exposes templates, golden paths and a service catalog through one interface. Backstage, Port and Mia-Platform are examples. The terms internal developer portal and IDP mean the same thing.
What is the difference between an internal developer portal and an internal developer platform?
The platform is the underlying capability: pipelines, environments, infrastructure automation. The portal is the interface developers interact with. Most organizations build the platform first, then add the portal so developers can use it without filing tickets.
Do developer portals set Kubernetes resource requests and limits?
No. Portals template and deploy workloads; they do not decide how much CPU and memory a workload needs. That number usually comes from a developer’s estimate or a copy of another service, which is why over-provisioning is so widespread. Setting it from observed behaviour requires an optimization layer.
What is AI-augmented software engineering (AIASE)?
AIASE is Gartner’s term for AI tools that assist software engineering work, including discovering the configuration that best meets a set of operational goals. Gartner covered it in its August 2022 Hype Cycle for Software Engineering, noting that engineers using these tools are more productive and stay in their roles longer.
How does Akamas integrate with a self-service developer portal?
Akamas analyses how a workload actually behaves and produces recommended Kubernetes requests, limits and runtime settings. In the Mia-Platform integration those recommendations surface inside the Mia-Platform Console, so a developer applies them in the same screen where they configure the microservice.
