Stateless vs stateful
A stateless system keeps no trace of what came before: every request starts from scratch. A stateful system remembers (login session, cart, conversation history). The distinction drives five architecture pairs every AI builder ends up having to call: Lambda versus ECS (one-off task triggered on demand versus a service that keeps running), database versus cache (durable storage versus a fast temporary copy), queue versus stream (a list you clear once handled versus an event timeline you can replay), retrieval versus reranking (finding a batch of documents versus pushing the best ones to the top), monitoring versus tracing (knowing something is wrong versus following one request to find where). A few concrete markers make each pair readable. Lambda suits a short task fired by an event, such as processing a file the moment it is uploaded; ECS runs a service that has to stay up, such as an API, and can carry stateless and stateful work alike. A queue works like the order tickets in a kitchen: a cook takes a ticket, prepares it, and the ticket leaves the rail. A stream is closer to a ledger of everything that happened: the event stays, and several systems can each read it on their own without stepping on one another. A cache is a copy of the most requested data held in fast memory, never the original. **It also sets the order in which an app scales.** That order has five steps, not two. Several apps on the same cheap VPS; then the app that has users on its own server, so a neighbour can no longer take it down; then the split, the database on its own machine, front end and back end each on theirs, which finally shows which part is eating the resources; then vertical scaling, a bigger machine for that part, which idles all night; finally horizontal scaling, several copies behind a load balancer. Step three comes before step five for a stateless reason: the moment you duplicate a server, nothing can live on it anymore. Data goes to the database, user uploads to file storage, and sessions to the database or a shared cache, otherwise the user is logged out every time the load balancer sends them to another copy. The order also works the other way: three servers for zero users means paying for an architecture sized for traffic that does not exist.
Strengths
- A single reading axis that orders five architecture decisions instead of handling them one by one
- The stateless-by-default reflex avoids the most common scalability debt
Limitations
- The distinction is binary in theory but blurry in practice: many systems are stateful only in places
Best for
- A dev or tech lead laying the foundations of an AI backend who wants to avoid paying for a naive architecture later