Kubernetes Update Improves Scaling for Stateful Workloads Significantly

Cloud systems did not become complex overnight. It happened gradually. Applications that earlier lived on a single machine now run across clusters and multiple environments. As things scaled, managing resources also became less straightforward.

One area where this shows up clearly is with stateful workloads. Applications like databases or long-running services behave differently from stateless ones. They cannot be restarted casually. 

Even a small interruption can affect performance or ongoing processes. Because of that, scaling them has always needed extra care.

Why vertical scaling was difficult earlier

Kubernetes handles scaling well when it comes to adding more pods. If traffic increases, new instances can be created. That part is reliable.

The difficulty comes when a single pod needs more resources. Increasing CPU or memory usually meant restarting it. That restart is not always harmless. For stateless services, it might go unnoticed. For stateful systems, it can interrupt work that is already in progress.

This is where teams often had to compromise. Either keep things running as they are or accept a restart to adjust resources.

How pod resizing works without restarts

Recent Kubernetes updates, including changes seen in newer versions like 1.35, are starting to address this gap. There is now support for in-place pod resizing. Kubernetes can now change resource limits on a running pod without having to stop and recreate it. The application continues without being interrupted.

The Vertical Pod Autoscaler also works more smoothly with this. It can adjust resource usage without triggering a full restart each time something changes.

How these changes improve day-to-day operations

The impact is quite noticeable. Earlier, scaling vertically always came with some level of disruption. Now that is not always the case. A running container can receive updated CPU or memory without going through a restart cycle. This makes routine operations a lot smoother. In some situations, it still uses the earlier approach, but not as often as before.

Why it matters more for stateful systems

For systems that hold data or maintain ongoing processes, avoiding restarts makes a real difference. Databases and streaming systems usually keep running without breaks. Restarting them can slow things down or briefly make them unavailable. Even if recovery is quick, it still adds unnecessary overhead.

Being able to adjust resources without interrupting them keeps things steady. It also reduces the need for constant monitoring during scaling changes.

Resource usage becomes easier to manage

Another benefit is how resources are handled over time. The Vertical Pod Autoscaler looks at how much CPU and memory an application actually uses.

With in-place resizing, these adjustments feel less intrusive. Resources can go up when needed and come down when things are quieter. There is no need to over-allocate just to stay safe.

Not a replacement but an improvement

This does not replace horizontal scaling. Adding more pods is still useful and will continue to be part of how Kubernetes handles load. What changes is that vertical scaling becomes more practical. It is no longer something teams avoid because of restarts. Now, both approaches can be used together more effectively.

Conclusion

Scaling is a core part of Kubernetes, though stateful workloads have usually been more difficult to manage. In-place pod resizing, along with improvements in Vertical Pod Autoscaler, is helping reduce that gap. Adjusting resources no longer always means restarting applications.

Over time, this makes systems easier to manage. There is less disruption, fewer workarounds, and more confidence when scaling things that need to stay running. For teams running stateful workloads, this change removes one of the most common operational challenges and makes scaling far more reliable than before. What earlier required careful planning and trade-offs can now be handled with much less risk.