From Managed Cloud Services to My Own VPS: A Different Way to Think About Infrastructure
- Get link
- X
- Other Apps
From Managed Cloud Services to My Own VPS: A Different Way to Think About Infrastructure
For years, managed cloud services have been the obvious choice for building and deploying web applications.
You write code, push it to a repository, and your application is deployed. You need a database? There are plenty of managed PostgreSQL providers. Need a domain, HTTPS, or traffic protection? There are services that handle those things for you.
It is convenient, reliable, and often the right decision.
But recently, I decided to take a different approach: move my application and database onto a VPS that I manage myself.
It wasn't because managed services had failed me. In fact, they had worked remarkably well. The decision came from a much simpler question:
At what point does paying someone else to manage everything make more sense than managing some of it myself?
Convenience Has a Price
Managed services solve real problems.
They save time, reduce operational responsibilities, and let developers concentrate on building products. For a small team or an individual developer, that convenience can be worth every dollar.
However, convenience also creates a certain dependency.
Your application runs on one platform, your database lives on another, and other parts of your infrastructure depend on yet more services. Each provider has its own pricing model, configuration, limitations, and operational assumptions.
Individually, these services may seem inexpensive. Together, they become another recurring expense that needs to be justified.
For a growing side project, that matters.
Not every project has meaningful revenue from day one. Sometimes the infrastructure costs are real long before the business becomes sustainable.
I started asking myself whether I really needed to outsource every part of the infrastructure.
The answer, at least for the current stage of my projects, was no.
Taking Back the Infrastructure
I chose to consolidate the core components onto a VPS.
Instead of relying on a managed application hosting platform, I now run the application directly on my own Linux server.
Instead of using multiple managed database instances, I installed PostgreSQL and brought the databases together into a single environment.
I configured a reverse proxy, HTTPS, system services, and the necessary network access. The application runs as a background service, and the database is managed directly on the server.
The architecture is not particularly complicated:
Users access the application through a traffic management layer. Requests are forwarded to the VPS, where the application runs and communicates with PostgreSQL locally.
There is something satisfying about understanding every major component in that path.
When something goes wrong, I have somewhere to look. I can inspect the process, read the logs, examine database activity, review network configuration, and make changes without waiting for a platform to expose the particular feature I need.
I am no longer just deploying an application to someone else's infrastructure. I am operating the infrastructure too.
That distinction is more significant than it might initially appear.
The Unexpected Benefit: Learning by Owning
One of the most interesting parts of this migration was how much I learned outside the application code itself.
I spent time understanding Linux services, PostgreSQL configuration, storage volumes, reverse proxies, TLS certificates, firewall rules, DNS, and network routing.
These are not necessarily things that a typical application developer needs to think about every day when using managed platforms.
But they are still fundamental parts of how software systems work.
For example, installing PostgreSQL is relatively straightforward. Moving data from several existing databases into one database is a different challenge.
It requires understanding schemas, tables, sequences, constraints, indexes, relationships, and data consistency. A successful migration is not simply a command that finishes without errors. The destination must contain the right data, preserve the important relationships, and behave correctly when the application starts using it.
The same is true of deployment.
Starting an application manually in a terminal might work during development, but a production service needs to survive terminal sessions, process failures, and server restarts.
These details are easy to overlook when a managed platform takes care of them.
Owning the infrastructure forces you to understand them.
Cheap Infrastructure Does Not Mean Free Operations
There is one thing I don't want to romanticize: running your own server is not free of responsibility.
A VPS may have a very attractive price, but the operational work does not disappear.
Someone still needs to maintain the operating system, apply security updates, monitor resource usage, manage database backups, test recovery procedures, and make sure the application can be deployed safely.
If the server goes down, there is no managed platform automatically taking responsibility for the entire stack.
And when the application and database share one machine, a server failure can affect both at the same time.
This is the trade-off.
Managed services charge money to reduce operational work. Self-hosting reduces some of those recurring costs, but transfers more responsibility to the person operating the system.
For a developer who enjoys understanding how things work, that can be an interesting trade.
For someone who simply wants to build a product and spend as little time as possible maintaining servers, managed services may be a much better choice.
Neither approach is universally superior.
Don't Build for a Problem You Don't Have
Another lesson from this migration is the importance of resisting unnecessary complexity.
Once you have a VPS, it is tempting to install everything.
Redis, message queues, background workers, container orchestration, monitoring stacks, and all kinds of infrastructure components are readily available.
But having the capacity to run something does not mean you need it.
A relatively simple application can handle a surprising amount of traffic when its database queries are efficient, its indexes are appropriate, and its resource usage is understood.
Before adding another service, I would rather measure the actual bottleneck.
Is the database struggling with writes? Are requests waiting on external services? Is CPU utilization consistently high? Are there connection pool problems?
Those questions should determine the architecture, not the popularity of a particular technology.
A small and understandable system is often easier to operate than a sophisticated system with unnecessary moving parts.
The goal is not to build the most impressive infrastructure diagram. The goal is to run the application reliably with an appropriate amount of complexity.
I May Go Back to Managed Services
Interestingly, moving to my own VPS has made me appreciate managed services even more.
I now have a better understanding of what those providers are actually doing behind the scenes and why their services cost money.
Backups, availability, security, maintenance, and operational support are not just marketing terms. They represent real work.
If a project grows to the point where operational overhead becomes more expensive than the managed service itself, paying for that service becomes a sensible business decision.
I would have no hesitation about moving back.
In fact, I think that is a healthier way to approach infrastructure decisions: choose based on the needs of the project today, but keep the architecture and business flexible enough to change tomorrow.
There is no prize for keeping everything self-hosted forever.
Likewise, there is no reason to pay for infrastructure capacity that a project does not yet need.
Final Thoughts
This migration reminded me that being a software developer is not only about writing application code.
It is also about understanding the systems that make the code useful: operating systems, databases, networks, deployment processes, and the infrastructure connecting everything together.
Managed platforms are excellent tools, and I will continue to use them when they make sense.
But sometimes, taking a step back and managing the underlying infrastructure yourself is worthwhile.
Not necessarily because it is cheaper in every situation. Not because self-hosting is fashionable. And certainly not because managing servers is always more convenient.
It is worthwhile because understanding the whole system gives you more choices.
For now, I am happy to have more control over my infrastructure, a better understanding of how everything fits together, and fewer recurring services to pay for.
And when the time comes to hand those responsibilities back to managed platforms, I will have a much better understanding of what I am paying for.
Good engineering is not about choosing managed services or self-hosting. It is about knowing when each one makes sense.
❤️ Support This Blog
If this post helped you, you can support my writing with a small donation. Thank you for reading.
- Get link
- X
- Other Apps

Comments
Post a Comment