Stateful vs Stateless Applications


Stateless apps do not store application state or data to persistent storage, which makes stateless applications highly scalable. However, stateful applications require persistent storage for data for use by clients, servers, and other applications.

For instance, the REPL calculator is a stateless application. It has no memory. Every new command line works independently and doesn’t remember the results for the previous command line. On the other hand, a weather app on a mobile phone always remembers which city you live in.

Below, we’ll highlight the basics stateless and stateful apps. 

Difference Between Stateless and Stateful Applications

Stateful applications use a database (DB) to store data or state from client requests and use this information for further requests. The session information is stored on the server. When a user initiates a self-contained login request, it enables login to be true. Upon the second request, the user directly lands at the dashboard. It’s because the second request doesn’t call DB because the session information is stored on the server, making it faster.

On the other hand, stateless applications store all state or data on DB that features persistent storage. Upon a user request for login, any server generates an auth token, stores it in DB and returns token to the client. The next request is sent along with the token that is matched with the info in DB. Accordingly, the app grants login to the user. So, every request is independent.

Stateful architectures were very popular in the past. However, with the advent of microservices, containers, CDNs, and cloud-native applications, stateless architectures have become quite common. 

Containerization: Stateful or Stateless

The application state refers to data required by application components to perform a task. All applications, including microservices applications, have state. Typically, the state is stored in a cache, a database, or some other form of storage.

A container is a standalone, self-contained package for an application, along with its hardware requirements and software dependencies. Containers were first introduced to be an entirely stateless way to package various services. It would perform its task and disappear, without leaving any record behind.

But, as the concept of microservices and containerization has evolved to its modern state, statefulness has now become a major part of containerization. Today, stateful applications can also be containerized, giving users speed and flexibility of using containers with storage and context of statefulness.

Because of this, stateful applications may look like stateless and vice versa.

Benefits of Stateful Containers

High Portability: You can migrate a stateful app in Docker container to any other cluster or host that supports Docker.

Easy Deployment: Containers offer turnkey deployment of apps, stateless, or stateful.

Environment Consistency: A consistent deployment environment is beneficial, regardless of the underlying architecture, and docker containers facilitate a consistent environment.

Deploying Stateless and Stateful Applications

Web applications can be deployed using various containerization and orchestration tools such as Kubernetes, Amazon ECS, and Docker Swarm.

Here, we will learn the deployment of stateless and stateful applications using Google Kubernetes Engine (GKE). First, let’s define some Kubernetes terms:

  • Pods

A Pod is the smallest and simplest execution unit of a Kubernetes application. It represents processes running on your container or cluster. Pods can run a single container or multiple containers are intended to work together.

Source: Kubernetes

  • StatefulSets

Kubernetes StatefulSet is intended for the management of stateful applications.

Using this workload API object, each pod is guaranteed the same disk and network identity across restarts, even on different physical machines.

When it comes to storage volumes, StatefulSet provides persistence for workloads. Persistent Pod identifiers match existing volumes to the new Pods that replace failed Pods.

  • DaemonSets

With DaemonSets, you can ensure that all nodes run a copy of the pod. It adds a node to the cluster every time you add a pod to it. In this way, a database can run on a particular set of machines.

DaemonSets utilizes Kubernetes’ declarative infrastructure but forgoes the flexibility of StatefulSets that can dynamically schedule pods.

Deploying Stateless Applications

Coming to the point, Kubernetes deploys stateless applications as uniform Pods using the Deployment controller. It helps manage the desired state of the application that is changeable dynamically through updates to the specific Pod.

Before starting the deployment, the following must be taken (same applies to stateful applications):

  • Enable the Google Kubernetes Engine API.
  • Install the Cloud SDK.
  • Set up default gcloud settings using gcloud init or gcloud config.
  • Containerized applications must reside in an image registry.

Use any of the following methods to deploy stateless applications using Kubernetes:

  • For a simple deployment from a container image, use the Deploy feature in the workloads menu of Google Cloud Console. The container image exists in the Container Registry.
  • Alternatively, code a Deployment manifest and run the kubectl apply command for resource creation.

Once the deployment is created, a user can scale it, update it, or even delete it, later.

Deploying Stateful Applications

Kubernetes uses StatefulSet features to deploy stateful applications. Here, Pods are not interchangeable, and each has a unique identifier.

Once you are prepared for the deployment, do the following:

  • Request persistent storage in StatefulSet

The volumeClaimTemplates array in each StatefulSets automatically generates its own PersistentVolumeClaim object.

  • Create a StatefulSet

Run the kubectl apply to create StatefulSet. This command uses manifest files to create, delete, and update cluster resources. It keeps all writes to live objects without rolling the updates into the object configuration files.

Once created, a user can inspect, update, scale, and/or delete the StatefulSet.

Why are stateless applications becoming popular

Historically, most of the web applications delegated a large number of their responsibilities, including identity and authorization claims, to databases. Most applications would use the following CRUD (Create, read, update, and delete), model:

Source: Petabridge

It separates applications from data, allowing users to have more servers under load balancers that support more traffic. Also, users can easily update applications multiple times without worrying about data.

But the CRUD has two major limitations:

First, it does not support modern applications that demand real-time performance.

Second, it does not support arbitrarily large workloads that come as a result of highly trafficked internet sites.

Thus, DevOps need a new way to store and process data in order to support massive workloads while maintaining fast response times.

To overcome these challenges, developers and architects are now developing stateful web applications. Some of the major benefits of stateful applications are:

  • Low Latency

For stateful apps, you can batch user actions in memory and make one network request per batch. It reduces latency up to a great extent, keeping it below 5ms. Users can manage potential durability issues using local persistence.

  • Higher Consistency

Client requests can be routed to the same server that served previous requests, which improved the consistency of the distributed system. If it fits well with the application, it also makes the architecture straightforward.

  • Real-time and Fast Response Rate

Users can use data grid architecture to keep compute data together. Some folks were able to run Java jobs in an in-memory data grid cluster. The data grid works in real-time, giving useful and insightful responses to users’ queries.

At the same time, it is important to know the challenges of stateful application workloads.

  • Storage

Stateful applications demand greater flexibility and full control for the storage array to support traditional and cloud-native apps. The array must offer storage services, including cloning, snapshot, encryption, compression at the container volume level of granularity.

Also, the storage array must be able to support seamless and rapid recovery quickly and efficiently. This requires regular backup on/off-premises.

  • Isolation Of Resource

Many available containers come with several best approaches for resource allocation, making them suitable for the stateless workload.

But, they can jeopardize the performance of stateful applications because of unreliable performance and data loss and unreliable performance.

  • Security

Each pod in Kubernetes requires an IP. It can reside on any node within the container. This model violates the conventional security model where resources are static.

In today’s continuously evolving technological environment, high visibility into the communication approach of Kubernetes pods is critical to stay secure.

  • Lack of Education

Continuous and rapid developments in web programming create challenges in the adoption of stateful applications. Developers may fail to keep pace with the fastest-evolving technologies.

Also, there is a lack of education within the application about how it works. Developers shall work with application vendors to get training on the technology.

Using DC/OS to Simplify Challenges

DC/OS stands for the Distributed Cloud Operating System. This open-source, program runs on the Apache Mesos kernel.

When it comes to stateless or stateful applications, DC/OS offers many benefits. It configures storage resourcefully, handles networking, and enables cluster availability. Besides, DC/OS also provides high privacy and security levels and a data-integrated platform solution for companies.

Mesosphere DC/OS provides local persistent storage that resides in the internal disks that can be partitioned for particular services. It provides excellent performance and data isolation.

It enables a lot of capabilities, choices, and options for bringing stateful services to the containerized data center. It eliminates all gaps between stateless containers and data services backends required by most applications.


The choice of whether to develop a stateless or stateful application largely depends on what the app is required to do. Stateless architecture is a good option for developers that need to store information temporarily. But, if the developer needs to store session information, stateful seems like an ideal option. 

Scroll to Top