Serverless vs Containers vs a VPS: Choose the Architecture Your Team Can Actually Run

A web application does not become well architected because it runs on the most fashionable infrastructure. It becomes well architected when the system meets its needs at a cost, complexity and operational burden the team can sustain.

That sounds obvious until a straightforward product acquires several deployment platforms, a collection of functions and a queue nobody is confident restarting.

Serverless, containers and a virtual private server can all be sensible choices. The useful question is not which one wins in general. It is which responsibilities you want to retain, which you can delegate and what happens when the application fails.

Start with the workload, not the hosting account

Describe the application before choosing its infrastructure. Is traffic steady or bursty? Does work finish quickly or run for minutes? Are persistent connections required? How much state exists, and where does it live?

Then describe the team. Who handles patching, recovery and deployment? What coverage exists outside working hours? Can another engineer operate the system when its original author is unavailable?

Those questions usually produce a better shortlist than comparing headline request prices.

Serverless buys managed execution, not freedom from operations

Managed functions can suit short-lived requests, event handling and workloads with substantial idle time. They can reduce the need to provision and maintain application servers, although exact scaling and billing behaviour varies by provider.

The trade-off is a different set of constraints. Execution limits, deployment packaging, service permissions and distributed failure handling become part of the design. Splitting one workflow across several functions can also make diagnosis harder.

Evaluate the complete request path. A cheap function may depend on paid database operations, network transfer, logging and third-party APIs. Test latency and recovery using the actual runtime and data location rather than assuming a label guarantees either.

Containers package consistency, not an operating model

Containers are useful when the application needs a controlled runtime, native dependencies or a deployment unit that behaves consistently across environments. They can support conventional web servers, workers and longer-running processes.

But a container image does not answer who patches its base, manages secrets, monitors capacity or restores the database. A managed container service may absorb some responsibilities. A self-managed cluster may add considerably more.

Choose the simplest orchestration that meets the requirement. One application needing repeatable deployment is not, by itself, a reason to build a platform team.

A VPS can be entirely professional

A small virtual server can provide understandable costs and a straightforward operating model for a modest website or application. There is nothing inherently amateur about a well-maintained server running a reverse proxy and an application process.

The qualification is "well-maintained". Patching, access control, backups, monitoring and recovery belong to you. A low monthly bill can hide expensive manual work or a serious dependency on one person.

Before choosing this route, demonstrate a clean rebuild, a tested restore and a deployment someone else can perform. If recovery depends on remembering commands from last summer, the architecture is carrying unpriced risk.

Compare total operating cost

Estimate a normal month, a busy month and a bad month. Include engineering time, support expectations, database costs, observability and the cost of an outage. Avoid false precision, but expose the assumptions.

A higher managed-service bill may be economical if it removes work the team cannot support safely. Conversely, a complex consumption-based design may be unnecessary for a predictable workload that fits comfortably on simple infrastructure.

The cheapest infrastructure is not always the lowest-cost service. The most managed service is not automatically the safest either.

Keep the design reversible where it matters

Portability is not an all-or-nothing property. Standard application protocols, explicit data ownership and clean boundaries can preserve options without wrapping every provider API in speculative abstraction.

Document the genuinely difficult exit points: stateful services, proprietary workflow semantics, authentication and data movement. Accept a provider-specific feature when its benefit is real, but name the migration consequence.

Likewise, do not split an application into services purely because infrastructure makes it easy. Boundaries should reflect ownership and operational needs, not the number of deployment buttons available.

Write a decision that can be reviewed

A useful architecture decision records the workload, expected growth, team constraints, chosen approach, rejected alternatives and conditions that would trigger reassessment. "We might scale" is not a trigger. Repeated capacity limits, unacceptable recovery time or sustained operational toil are.

For a small web product, the best first architecture may be deliberately ordinary: one deployable application, managed data where justified, clear monitoring and tested recovery. Growth can fund additional complexity when evidence supports it.

Whether you are building from Dundee or running a global platform, choose infrastructure for the service you need to operate, not the engineering identity you want to project. Boring, understood and recoverable is a strong architectural position.

Further reading: Martin Fowler's Monolith First explores the case for discovering service boundaries before distributing an application. It is an argument to evaluate, not a universal hosting rule.

Comments

Popular posts from this blog

The Concept of True North in Lean Methodology: A Toyota Perspective

The Archetypes of Staff Engineers: How to Excel and When Your Business Needs One

Serverless Architectures: Simplifying Backend Development for Scalable Apps in 2025