Cloud & Infrastructure

Managed Cloud vs Self-Hosted What Should Your Roadmap Fund

A product manager cannot scope “cloud infrastructure” as a single deliverable. A managed runtime and an internal platform produce different work, different release risks, and different demands on the team after launch. My default is to buy the runtime and build only the application-specific pieces. I would reverse that choice only when a committed product requirement demonstrably cannot fit the managed service.

A managed runtime wins when the product needs a release, not a platform

Compare two concrete approaches: run services on Amazon ECS with AWS Fargate, or build an internal platform around Kubernetes on Amazon EC2. ECS on Fargate wins when the product needs predictable deployment and scaling without a dedicated platform team, because AWS operates the underlying compute and the team can concentrate on service configuration. Kubernetes on EC2 wins when a committed requirement needs cluster-level control that ECS cannot provide, because the team can own node configuration, networking, and workload scheduling. That control costs engineering time before launch and operational time afterward.

For the managed option, scope the first release around a container image in Amazon ECR, a service definition, an Application Load Balancer health check, secrets in AWS Secrets Manager, and a production deployment through GitHub Actions. If the service needs a relational database, add Amazon RDS for PostgreSQL and a restore test. These are deliverables with acceptance criteria, rather than a promise that “the cloud is ready.”

Ask engineering to demonstrate that a failed health check stops a deployment, that a previous task definition can be redeployed, and that an authorized engineer can retrieve logs during an incident. OpenTelemetry traces and Prometheus-format metrics can make those tests observable, but instrumentation is in scope only where it answers a release or support question. A dashboard full of graphs is not evidence that anyone can identify a failing request.

Treat the executive question (Should a CTO Build or Buy Cloud Infrastructure?) as an input to the scope decision, rather than its output. The PM’s decision is narrower: which work must be complete for this product to ship safely? I would not schedule a Kubernetes platform as a parallel “future-proofing” project, because an unvalidated future requirement cannot justify delaying the requirements that already have a release date.

Write down what the managed option does not buy. The team still owns application vulnerabilities, IAM permissions, schema changes, alert routing, and restore procedures. Fargate removes node administration from this plan; it does not remove the need to decide who responds when the service fails.

An internal platform wins only when a managed constraint blocks committed work

“We may need flexibility” is too weak to fund a platform. A stronger case identifies a committed workload, the managed-service constraint it hits, and the cost of a feasible workaround. For example, if a release depends on a node-level agent that must inspect traffic before it reaches application containers, test whether ECS task networking and supported integrations can meet that requirement. If they cannot, Kubernetes on EC2 may earn its cost because the requirement is both specific and on the release path.

The platform estimate must start before the first application deployment. It includes cluster provisioning with Terraform or OpenTofu, node updates, an Ingress implementation, certificate handling, image access, autoscaling, and a method for replacing unhealthy nodes. If the team selects Helm for releases, its charts and values become maintained deployment code. If it selects Argo CD, someone must define which Git repository is authoritative and what happens when an emergency change creates drift.

Scope a platform as a product with an initial consumer, not as a collection of tools. Its first acceptance test should deploy the committed workload from a clean environment, recover from a failed rollout, and give an on-call engineer enough evidence to diagnose a failing pod. Record the Kubernetes version and the versions of critical controllers in the delivery brief, because an upgrade path cannot be estimated while its components are unnamed.

Use a capacity check before approving the work. As a planning example rather than a staffing benchmark, reserving 2 engineers for 6 weeks is roughly 12 engineer-weeks unavailable to product features. Ask which feature dates move, who reviews the platform’s security settings, and who maintains it after those engineers return to other work. If those answers are absent, the platform has not been scoped; its implementation has merely been assigned.

There is also a middle path, but it should not be disguised as a platform decision. A small proof of constraint can test the troublesome workload on both ECS and Kubernetes, then stop. Time-box that test to a value the team can tune—for example, 10 working days—and require a written result. The point is to retire a specific uncertainty, not to let a prototype become production infrastructure by default.

The cheaper cloud bill can be the more expensive product plan

Compare options over the same period and include the labor each one consumes. The managed plan pays for Fargate tasks, load balancing, storage, database capacity, and usage that changes with traffic. The internal-platform plan may have a lower compute bill at a steady workload, but it also needs build time, upgrades, incident response, and capacity planning. Neither comparison is credible if it prices one option as a service and the other as a collection of EC2 instances.

Amazon publishes a 1-minute minimum charge for Linux Fargate tasks. That billing rule matters when estimating short-lived jobs, although it says little about the total cost of a continuously running service. Use vendor pricing for the proposed region and task sizes, then test sensitivity to workload changes rather than copying a generic per-month estimate into the roadmap.

The following Python 3 calculation runs without cloud credentials. Its dollar figures and hours are illustrative inputs, not a vendor quote or a measured result; replace them with the team’s estimates. It deliberately charges recurring platform care against the apparent monthly infrastructure saving.

python3 - <<'PY'
managed_monthly = 2400
platform_monthly = 1500
build_hours = 420
loaded_hourly = 110
monthly_care_hours = 28
monthly_savings = managed_monthly - platform_monthly - monthly_care_hours * loaded_hourly
print(f"Net monthly savings: ${monthly_savings:,.0f}")
print("Payback months:", round(build_hours * loaded_hourly / monthly_savings, 1) if monthly_savings > 0 else "none")
PY

With those inputs, the internal platform has no financial payback: its estimated monthly care costs more than its infrastructure saving. That does not forbid building it, because a platform might enable a product requirement worth more than the difference. It does require the sponsor to name that requirement instead of presenting a lower EC2 bill as the entire business case.

Keep delivery capacity separate from the cost calculation. An engineer diverted from a committed feature can delay revenue or learning even if their salary is already in the budget. Ask for two dates alongside each estimate: when the infrastructure can host a service, and when a product team can deploy, observe, and recover that service without help from its original builders. The gap between those dates is work the PM must schedule.

A reversible choice needs an exit test before launch

Managed services are easier to adopt than to leave if application code assumes their interfaces everywhere. Internal platforms create a different trap: teams can move workloads into the cluster faster than they can document the deployment contract. Neither risk calls for building a universal abstraction layer. It calls for identifying the few dependencies that would make a later change expensive.

For either option, put the container build, required environment variables, health endpoint, and database migration procedure in version control. Prefer a documented OCI container image and an explicit HTTP health response over deployment behavior that exists only in one engineer’s console session. Those choices make a second deployment target testable, although they do not make migration free.

Set a provisional 15-minute rollback target only if the product’s failure tolerance supports it, and revise the target after a rehearsal. A rollback test should restore the previous application version and verify a user-visible request; redeploying an old image is insufficient when a new database migration has changed the data it reads. Record the actual elapsed time from the rehearsal as a measured result, including the time spent deciding to roll back. Until that test runs, a target is a planning assumption, not an operational claim.

Do not treat the maintenance warning (Buying Cloud Infrastructure Means Owning the Hidden Maintenance Load) as a reason to reject every vendor; use it to assign ownership of the dependencies the contract leaves with the team. Put a named owner against IAM changes, database upgrades, backup restores, and vendor-limit reviews. On the internal-platform path, add node images, controller upgrades, and cluster recovery. An unowned task has a cost even when it has no line in the cloud invoice.

The exit test can be small. Once, deploy the same image into a disposable second environment, provide its secrets through the documented interface, and run one representative request. If that takes longer than expected, capture the blocker as backlog work with an owner. The PM now has evidence about switching cost without commissioning a second production platform.

The first decision artifact should be a release gate

Before requesting infrastructure estimates, write a one-page release gate with the committed workload, its managed-service constraint, a rollback demonstration, a restore demonstration, and the engineer who will own each after launch. Ask both options to price and date that same gate. If no committed requirement defeats ECS on Fargate, scope the managed deployment first and reserve platform work for a constraint the team can prove.