We’ve all been there. You leave a high-growth environment where the tech stack was a marvel of modern engineering, and suddenly you’re standing in front of a fresh index.html feeling like you need a riot shield to swat a fly.
When I left my last company, I carried its enterprise habits with me. I looked at a simple side project, a Next.js app, and immediately thought: “I need a Terraform config for this.”
I spent days debugging deployments before giving up and moving to Vercel. The time went into getting the machinery to work, before the project had much to show for it.
The habits you bring from a bigger system
The last project I touched used Terraform to provision Google Cloud resources for databases, Redis instances, load balancers, and IAM roles across a Next.js, Rails, and Express stack. That experience shaped what I reached for next, even though the new project had very different needs.
I found myself:
- Dockerizing components that did not need a custom container setup.
- Debugging deployment configuration and environment variables.
- Provisioning cloud resources before I had something useful for people to visit.
I was treating a familiar architecture as a starting requirement. Learning infrastructure can be worthwhile, but a learning project and a product you need to ship have different goals. I had confused the two.
A blog needs somewhere to run, somewhere to store its content, and a way to publish. A managed platform can often handle most of that. It is easy to turn those small requirements into modules, remote state, deployment roles, and a pipeline to coordinate them.
Each decision can sound sensible in isolation. Together, they can leave you maintaining a system that is more demanding than the website it supports. The useful question is whether the problem in front of you needs what Terraform provides.
Start with the job the system needs to do
For a small blog, the requirements might be a custom domain, a content editor, reliable hosting, backups, and a straightforward publishing process. Those are real requirements. A reusable infrastructure framework is a possible implementation choice.
If your hosting and content providers already manage the underlying services, adding another management layer can duplicate work. You still need to understand the providers, but now you also need to understand the code and workflow that control them.
Start by writing down what must work and what failure would cost. A personal publication and a business-critical publishing platform may deserve very different designs, even if both are called blogs.
How overengineering creates problems
Overengineering usually begins with good intentions. We want consistency, flexibility, and fewer manual steps. The trouble starts when the cost of providing those qualities exceeds their value for the actual project.
Where the extra complexity shows up
More to maintain
Configuration, dependencies, permissions, and automation all need attention. The infrastructure becomes a second product with its own upkeep.
More to understand
A small change may require someone to follow several layers before they can predict its effect. Onboarding becomes slower and ownership narrows.
More to diagnose
A failed deployment can involve the application, a provider, credentials, state, or the pipeline. Each boundary adds another place to investigate.
Less time to deliver
Time spent perfecting a hypothetical future platform is time unavailable for content, accessibility, performance, and the features people need now.
The problem compounds. A complicated setup encourages more documentation, more automation, and more abstractions to make it manageable. Those additions may help, but they also become things someone must maintain.
A small change should stay small
Consider a hypothetical blog that needs a new preview environment. On a managed platform, the existing preview feature might satisfy the requirement with a few settings.
An elaborate setup might instead require a new module input, a change to shared configuration, additional credentials, and several pipeline stages. Before publishing anything, the author is now waiting for someone who understands the infrastructure.
That extra process can be justified when the environment has strict isolation or repeatability requirements. Without those requirements, it is friction that the project has chosen to create.
Abstractions can hide the knowledge you still need
A module can remove repetition without removing the underlying concepts. When something fails, someone still needs to understand what was created, who can change it, and how it connects to the application.
A generic module built for many imaginary use cases often accumulates switches and exceptions. Its users must learn both the platform and the module's interpretation of the platform.
Prefer an abstraction after you have seen a stable pattern repeat. Until then, a small amount of explicit configuration can be easier to read, change, and remove.
Terraform still has a useful job
Terraform can be a good fit when you need to describe and review infrastructure changes, reproduce environments, or coordinate resources across services. The point is to match that capability to a concrete need.
The case becomes stronger when:
- Multiple environments need the same infrastructure with controlled differences.
- Several people need a shared, reviewable process for changing resources.
- Recreating infrastructure reliably matters to your recovery requirements.
- Manual setup has become repetitive or has already caused configuration mistakes.
A small site can have those needs. A large site can also use managed services effectively. Traffic and company size alone do not decide the answer.
Choose the smallest system you can operate well
Simplicity does not mean skipping the basics. Someone still needs to own the domain, protect access, understand backups, and know how to recover when a deployment goes wrong.
A sensible starting point is:
- Define the publishing, availability, and recovery requirements.
- Use the managed capabilities that already meet them.
- Document ownership, configuration, and the recovery process.
- Automate repeated work when its frequency or risk justifies the effort.
- Add infrastructure tooling when a specific limitation makes the benefit clear.
Before adding another layer, ask
What does it solve now?
Name the repeated task, failure, or requirement. A vague possibility that you might need it later is a weak reason to maintain it today.
Who will operate it?
Identify who can change it, debug it, and recover it. Include their time in the cost, alongside the hosting bill.
If you have already overbuilt it
Avoid turning simplification into another large rewrite. First identify the parts that repeatedly slow you down or cause incidents.
- Map which resources and workflows the site actually uses.
- Remove unused options and environments after checking dependencies.
- Replace custom workflows with managed features where they meet your needs.
- Simplify one boundary at a time, preserving backups and a rollback path.
If Terraform currently manages live resources, do not simply delete configuration and apply the result. Removing management and deleting infrastructure are different operations; plan that handover carefully before changing ownership.
Build for the work you actually have
Good engineering includes choosing which problems to leave unsolved until they exist. An architecture should help the people responsible for the system make changes safely and understand failures quickly.
For your blog, that may mean a managed host, a CMS, a domain, and clear recovery instructions. When the requirements grow, you can reassess with evidence.
The goal is a system whose complexity is proportional to the job. If maintaining the machinery keeps you from publishing, the machinery deserves another look.