Ask a group of developers whether a new product needs Redis, a message queue, Elasticsearch, Kubernetes or a separate analytics database, and you will get a lively debate. Ask a founder why their monthly cloud bill is high and their small team spends half its time on infrastructure, and the answer is often that they added all of those things before they had users.
Modern tutorials and reference architectures make it easy to copy the stack of a company with millions of users. The problem is that every new component brings setup, monitoring, upgrades, security patches, failure modes and cost. For an early-stage startup, the most valuable infrastructure decision is often the decision not to add something yet.
This guide offers a practical framework for right-sizing startup infrastructure: what a lean default looks like, which signals tell you it is time to add Redis, queues, search or Kubernetes, and how to make those changes without a painful rewrite.
Adding a component is rarely just a line in a configuration file. Each one typically introduces:
For a team of two to five engineers, these costs compete directly with building features customers will pay for.
For many new web and mobile products, a sensible starting point looks like this:
Postgres in particular covers far more than most teams expect. It can handle full-text search, JSON documents, simple job queues using row locking, scheduled tasks through extensions, and vector similarity search through pgvector. Using one well-understood database for several jobs is often the fastest path to product-market fit. We explore the structural side of this choice in our guide to monolith versus microservices for startup architecture.
Consider an illustrative scenario. A small B2B marketplace launches with a microservice layout copied from a conference talk: an API gateway, separate services for users, listings and orders, Redis for caching, a message broker, Elasticsearch for search and a Kubernetes cluster to run it all. The product has a few hundred active buyers.
The two developers spend much of each sprint on deployments, broken service discovery and search index drift. Pages load slowly anyway, because requests hop between several services. A review reveals that the database is nearly idle, the cache hit rate is low because data changes constantly, and search queries could be served by Postgres full-text search with proper indexes.
The team consolidates into a single application, moves search and background jobs into Postgres, and deploys to a managed platform. The architecture diagram shrinks from a wall poster to a single slide. Feature delivery speeds up, and the cloud bill could plausibly drop by a meaningful share, because idle clusters and minimum-size managed services disappear. When traffic genuinely grows, they will add components again, this time based on measurements.
Set up basic application performance monitoring and database query insights. Know your slowest endpoints, your heaviest queries, your peak request rate and your database CPU and memory usage. Most "we need Redis" conversations end quickly when the data shows one missing index is the real problem.
Before adding a new system, try the low-cost fixes: add indexes, remove N+1 queries, paginate large lists, compress responses, serve static assets from a CDN and cache full pages at the edge where content is public. These often deliver dramatic improvements without new infrastructure.
Good reasons to introduce Redis or a similar in-memory store include:
"Everyone uses it" is not on the list. When you do add caching, design invalidation carefully, as explained in our guide to web app caching across CDN, Redis and browser layers.
A Postgres-backed job queue works well for emails, report generation and webhooks at modest volume. Consider a dedicated queue or workflow engine when you need very high throughput, complex retries across many steps, strict ordering, or long-running workflows that must survive deployments.
Postgres full-text search handles basic keyword search well. A dedicated search engine starts to earn its place when users need typo tolerance, faceted filtering across large catalogues, multilingual relevance tuning or search-as-you-type at scale, and when search quality directly affects revenue.
Managed platforms and serverless hosting suit most early products. Kubernetes tends to pay off when you run many services with different scaling needs, require fine control over networking or compliance, or have the in-house skills to operate it. Until then, a managed platform usually gives you most of the benefit for a fraction of the effort.
The fear behind early over-engineering is usually "we will have to rewrite everything later". Avoid that by keeping clear module boundaries in your code: wrap caching, job dispatch and search behind small internal interfaces. When you swap Postgres search for a dedicated engine, only one module changes.
Every time you add a component, record why, what metric justified it, what it costs and who owns it. Revisit these records twice a year and remove anything that no longer earns its keep.
Infrastructure should be a response to evidence, not a forecast of success. Build for the traffic you have, design for the traffic you expect, and measure your way between them.
Across the 37+ products Mavani has delivered, a recurring lesson is that early simplicity rarely blocks later growth, while early complexity often slows a team down before growth arrives. When we architect new SaaS platforms, we start with a lean, well-structured core and leave clear seams where caching, queues and search can be added once real usage justifies them.
Redis, message queues, search engines and Kubernetes are excellent tools. They are just not free, and for an early-stage startup, their operational cost is paid in the scarcest currency you have: engineering focus. Start with a lean stack built around a managed Postgres database, measure carefully, fix the cheap problems first, and add components only when a specific metric tells you to.
The right question is not "do we need Redis?" It is "what evidence would tell us we need Redis, and are we seeing it yet?" Teams that ask it that way tend to ship faster, spend less and scale more calmly when growth finally arrives.