aws devops · the complete 2026 guide

AWS DevOps — what it actually covers, what good looks like, and what it costs.

AWS DevOps is the whole discipline of getting code from a laptop to production on AWS safely, repeatably, and cheaply — IaC, CI/CD, containers, networking, IAM and security, observability, reliability, and cost. This guide maps the full surface area, compares the AWS-native toolchain to the third-party stack teams actually run, lays out the maturity ladder, and answers the question everyone eventually asks: build the team, hire a contractor, or have a vetted AWS partner deliver it — often AWS-funded, so it costs you $0.

surfaces to cover
8
first prod deploy
2–6 wks
senior DevOps salary
$160K+/yr
partner-built cost
$0–low
TL;DR
  • AWS DevOps is eight surfaces, not one tool: infrastructure-as-code, CI/CD, containers, networking, IAM/security, observability, reliability/DR, and cost. "Doing DevOps on AWS" means having a credible, automated answer for all eight — most teams have three and a pile of click-ops for the rest.
  • The AWS-native toolchain (CloudFormation/CDK, CodePipeline, ECS/EKS, CloudWatch, Control Tower) is real but rarely run pure. Production teams blend it with Terraform or OpenTofu for IaC, GitHub Actions or GitLab CI for pipelines, and Datadog or Grafana for observability. Picking the blend per surface is the actual decision — this guide gives you a sane default for each.
  • Three ways to get it done: build in-house ($160K–$220K per senior hire, 3–6 months to real maturity), hire a fractional/contract engineer ($120–$250/hr), or have a vetted AWS partner deliver it. For credit-eligible companies the partner engagement is often AWS-funded — partner paid through AWS programs, your bill covered by credits — so you pay $0 or low cost. CloudRoute routes you to that partner and skips the hiring slog.
the eight surfaces

IWhat AWS DevOps actually covers — the eight surfaces

DevOps is the practice of shipping software through automation, fast feedback, and shared ownership of production; "AWS DevOps" is that practice applied to the AWS platform. Concretely it is eight surfaces, and a complete practice has a credible, automated answer for all of them. The fastest audit of where you stand: read each one and ask whether it is in code, automated, and owned — or a console click somebody remembers how to do.

AWS DevOps is its own skill set — distinct from generic DevOps — because AWS is enormous and opinionated: 200-plus services and at least three reasonable ways to do almost anything (run a container on ECS, EKS, or App Runner; define infra in CloudFormation, CDK, Terraform, or Pulumi), where the wrong combination is expensive and slow to unwind. Nobody starts with all eight surfaces. Most early teams are solid on one or two (usually a CI pipeline and some containers), improvising on three, and have nothing for the rest — disaster recovery and cost governance are most commonly missing. Each surface below has a sane 2026 default, the AWS-native option, the common third-party alternative, and a link to its cluster deep-dive.

1. Infrastructure as code (IaC)

VPCs, databases, clusters, IAM roles, and DNS in version-controlled files instead of console clicks — so an environment is reproducible, reviewable in a pull request, and recoverable. The foundation; without it the other seven are sandcastles. AWS-native: CloudFormation and the AWS CDK. Market default: Terraform (HashiCorp, BSL-licensed since 2023) or its open fork OpenTofu; Pulumi is the general-purpose-language alternative. Deep dive: infrastructure-as-code on AWS, Terraform vs CloudFormation, and Terraform vs Pulumi.

2. CI/CD — the path to production

The automated pipeline that turns a merged commit into a tested, built, deployed artifact with no human running commands — tests, an immutable artifact (container image or Lambda bundle), promotion through staging to production, and a rollback. AWS-native: CodePipeline + CodeBuild + CodeDeploy. Market default: GitHub Actions or GitLab CI deploying into AWS via OIDC (no long-lived keys); Jenkins still runs much of the enterprise world; Argo CD brings GitOps for Kubernetes. Deep dive: CI/CD on AWS and GitOps on AWS.

3. Containers & compute

How your code actually runs. The dominant pattern is containers, and on AWS that is a choice: Amazon ECS (simpler, AWS-opinionated orchestration), Amazon EKS (managed Kubernetes — portable, powerful, more operational surface), or Fargate (serverless containers — no nodes to patch, runs under both ECS and EKS). App Runner and Lambda cover the simplest and event-driven ends. ECS-vs-EKS is one of the most consequential early decisions and the one teams most often get wrong by reaching for Kubernetes too soon. Deep dive: ECS vs EKS, Amazon ECS setup, Amazon EKS setup, and Kubernetes consulting.

4. Networking

The VPC, subnets, routing, load balancing, DNS, and CDN that connect your services to each other and the internet, securely — get it wrong and you have either an open attack surface or a tangle nothing can reach. Core services: VPC, Application/Network Load Balancers (ALB/NLB), Route 53 (DNS), CloudFront (CDN), and for multi-VPC growth, Transit Gateway and PrivateLink. Deep dive: load balancing on AWS and the foundational AWS landing zone.

5. IAM, security & the account foundation

Who and what can do what — least-privilege IAM roles, no long-lived keys, secrets in Secrets Manager, and a multi-account structure so a compromised dev account cannot reach production. The 2026 baseline is a landing zone: AWS Control Tower + Organizations + IAM Identity Center giving separate accounts per environment, guardrails, and centralized logging from day one. This is also where SOC 2 / ISO 27001 / HIPAA readiness lives. Deep dive: AWS landing zone and the broader Well-Architected review.

6. Observability

Knowing what production is doing — metrics, logs, traces, alerts — before customers tell you it is broken. Three pillars: metrics (is it healthy?), logs (what happened?), traces (where did the request slow down?). AWS-native: CloudWatch (metrics, logs, dashboards, alarms), X-Ray (tracing), and managed Prometheus/Grafana. Market default layers on Datadog, Grafana Cloud, or an OpenTelemetry pipeline for richer, vendor-portable telemetry. Deep dive: AWS observability setup.

7. Reliability & disaster recovery

Staying up when an Availability Zone, a region, or a bad deploy fails. Multi-AZ is the floor; then a deployment strategy that limits blast radius (blue/green and canary); then a documented DR posture with real recovery-time and recovery-point objectives (RTO/RPO) — backup-and-restore, pilot-light, warm-standby, or active-active, depending on what downtime costs you. Deep dive: blue/green deployment on AWS, disaster recovery on AWS, and SRE on AWS.

8. Cost & FinOps

AWS bills are easy to grow and hard to shrink. Cost governance means right-sizing compute, Savings Plans and Spot where appropriate, tagging so spend is attributable, catching the forgotten NAT gateway and over-provisioned RDS instance, and — critically for funded startups — funding the bill itself with AWS credits. This is the surface most directly tied to the CloudRoute offer: credit-eligible companies can have much of the early AWS bill credit-covered. See $100K in AWS credits.

toolchain

IIAWS-native toolchain vs the third-party stack teams actually run

AWS sells a complete first-party DevOps toolchain. Almost nobody runs it pure. Understanding why — and where the native option is genuinely the right call — saves you from both lock-in dogma and the opposite mistake of reaching for a heavyweight third-party tool you do not need.

The honest 2026 pattern is a blend. CloudFormation and CDK are excellent for tightly AWS-scoped infrastructure, but Terraform/OpenTofu wins when you also manage non-AWS resources (DNS, SaaS, Datadog, Cloudflare) under one tool and one state model. CodePipeline is fine and cheap, but most teams live in GitHub or GitLab and want the pipeline next to the pull request — so GitHub Actions and GitLab CI dominate, deploying over OIDC. CloudWatch is the cheapest start and the source of truth for AWS metrics, but its dashboards and tracing are weaker than Datadog or Grafana, so growing teams layer those on.

The decision is per-surface, not a religion, and turns on two questions: how much of your world is outside AWS, and how much operational maturity you already have. A pre-seed team migrating onto AWS is best served by the simplest credible thing — ECS Fargate, GitHub Actions, CloudWatch, a CDK or Terraform baseline — graduating later. A scaling team with multi-cloud surface area rationally runs Terraform/OpenTofu + Argo CD + Datadog. Picking the right blend for your stage is exactly the judgement a good AWS DevOps engineer or partner brings.

aws devops toolchain — native vs common third-party, per surface (2026)
SurfaceAWS-nativeCommon third-partySane default for most teams
IaCCloudFormation / CDKTerraform (BSL) · OpenTofu · PulumiOpenTofu or Terraform; CDK if AWS-only & TS/Python team
CI/CDCodePipeline / CodeBuild / CodeDeployGitHub Actions · GitLab CI · JenkinsGitHub Actions → AWS via OIDC
ContainersECS · EKS · Fargate · App RunnerSelf-managed k8s · NomadECS on Fargate (start); EKS when you truly need k8s
NetworkingVPC · ALB/NLB · Route 53 · CloudFrontCloudflare (DNS/CDN/WAF)AWS-native VPC + ALB; Cloudflare at the edge if already there
IAM / foundationControl Tower · Organizations · Identity CenterOkta · third-party SSOControl Tower landing zone + Identity Center
ObservabilityCloudWatch · X-Ray · Managed Grafana/PrometheusDatadog · Grafana Cloud · OpenTelemetryCloudWatch to start; Datadog/Grafana as you scale
ReliabilityMulti-AZ · CodeDeploy blue/green · AWS BackupSpinnaker · Argo RolloutsMulti-AZ + native blue/green; canary as traffic grows
Cost / FinOpsCost Explorer · Budgets · Savings Plans · Activate creditsVantage · CloudZero · KubecostBudgets + tagging + credits first; FinOps tool later
There is no single right column — production teams mix native and third-party per surface. The default column is a reasonable starting blend for a funded startup on AWS, not a mandate. The right blend depends on how much of your stack lives outside AWS and how mature your team already is.
the maturity ladder

IIIThe maturity ladder: greenfield → production-ready → platform

AWS DevOps is not a binary — it is a ladder. Knowing which rung you are on tells you what to build next and, just as importantly, what to NOT build yet. The most expensive mistake is building rung-three infrastructure for a rung-one company.

Each rung is defined by what is true about your deploys, infrastructure, and ability to recover; you climb by closing the gaps on the eight surfaces. Most teams that contact CloudRoute sit between rung one and rung two and want to get safely to "production-ready" — credible enough to pass a customer security review or SOC 2 audit — without over-engineering toward a platform they do not yet need.

Rung 1 — Greenfield / just-shipping

Where most pre-seed and seed teams are. The app runs on AWS (or is moving onto it), but infrastructure was clicked together in the console, deploys are manual or a single CI script, there is one shared account, secrets live in environment variables, and "disaster recovery" is hoping nothing breaks. Fine for finding product-market fit; dangerous the moment you have real customers or data. The goal is not perfection — it is getting the foundation (IaC + a real pipeline + a sane account structure) in place before the improvisation calcifies into something nobody can safely change.

Rung 2 — Production-ready

The bar that lets you sell to companies that care, pass a security questionnaire, and sleep through the night: infrastructure in code and reproducible; CI/CD automated end-to-end with rollback; a multi-account landing zone with least-privilege IAM and centralized logging; Multi-AZ workloads; observability covering metrics, logs, traces, and alerting that pages a human before a customer notices; a documented, tested backup/restore. The rung most funded startups should target, and the one a focused 4–8 week partner engagement is designed to deliver.

Rung 3 — Platform

Self-service infrastructure for a growing engineering org: developers ship through golden paths without filing ops tickets; environments are provisioned on demand; there is an internal developer platform (often a portal like Backstage plus opinionated modules); GitOps drives deploys; SLOs and error budgets govern reliability. The right investment when many teams are slowed by the ticket-to-ops bottleneck — and premature with one product team. Deep dives: internal developer platform and platform engineering on AWS.

where to aim

For most funded startups the target is rung 2 — production-ready: sellable, auditable, on-call-survivable. Reach for rung 3 (a full internal developer platform) only once multiple teams are blocked by ops tickets — building it early is the most common form of premature infrastructure.

the bar

IVWhat "good" looks like — a production-readiness checklist

A concrete, non-hand-wavy definition of a healthy AWS DevOps setup — roughly the punch list a competent partner works through to take a team from rung one to rung two, and a useful self-audit even if you build it yourself. You do not need every item from day one, but each should eventually answer "yes, in code, automated, and owned" rather than "someone knows how to click that."

  • All infrastructure is in code — Every VPC, database, cluster, role, and DNS record in Terraform/OpenTofu/CDK, reviewed in pull requests, with remote state and drift detection — recreatable from an empty account.
  • One-click, reversible deploys — A merged commit flows through an automated pipeline to production with no manual steps, immutable artifacts, and a tested rollback. Deploy frequency is the team's choice, not what ops can hand-crank.
  • A multi-account landing zone — Separate accounts per environment under Control Tower/Organizations, Identity Center for human access, least-privilege roles, secrets in Secrets Manager, centralized logging. No long-lived keys in CI.
  • Multi-AZ by default — Compute and data span at least two Availability Zones, with load balancing and auto-scaling configured rather than aspirational, so a single AZ failure does not take you down.
  • Observability that pages before customers do — Metrics, logs, and traces in one place, dashboards for the services that matter, and alerts on the symptoms users feel (latency, error rate, saturation) routed to whoever is on call.
  • A tested recovery path — Automated backups, an RTO/RPO matched to what downtime actually costs, and a restore you have actually run — not a backup you hope works. The DR tier is a deliberate choice.
  • Security and compliance baked in — Encryption at rest and in transit, GuardDuty/Security Hub monitoring, a Well-Architected review on record, and SOC 2 / ISO 27001 controls already mapped to AWS services.
  • Cost is visible and governed — Everything tagged, budgets and anomaly alerts on, Savings Plans where steady-state, and — if credit-eligible — the early bill funded by AWS credits rather than burned cash.
the real decision

VBuild the team, hire a contractor, or have a partner deliver it

Once you know what AWS DevOps covers and what good looks like, the only question left is who does the work. There are three honest options, each right in different situations. Here is the trade-off without the sales gloss — and where the AWS-funded partner route genuinely changes the math.

Build in-house. Hire a platform/DevOps engineer (or a few) and own the capability — the right end-state if infrastructure is core to your product and you are at the scale where a dedicated team pays for itself. The cost is real: a senior engineer runs roughly $160K–$220K base plus equity, weeks to hire and months to ramp, and one person is a single point of failure and retention risk — the person who "knows the account" leaving is the exact scenario driving a lot of these searches. Below ~20–30 engineers, a full in-house platform team is usually premature.

Hire a contractor / go fractional. Bring in an independent DevOps engineer or fractional platform lead for a defined scope or a few days a week. Rates are typically $120–$250/hr; a fractional arrangement might be $4K–$12K/month. Flexible and fast to start, but quality varies enormously, you do the vetting yourself, and continuity is fragile — a solo contractor can disappear mid-engagement. Deep dives: fractional DevOps, outsourced DevOps, hire a DevOps engineer, and hire a Terraform consultant.

Have a vetted AWS partner deliver it. Engage an AWS Advanced/Premier partner who has built this exact thing dozens of times to deliver a defined outcome — a landing zone, a CI/CD pipeline, an EKS platform, a production-readiness uplift. You get a team rather than a single point of failure, AWS-pattern-aligned work, and a fixed scope. The cost surprise is the good one: for credit-eligible companies the engagement is often substantially AWS-funded — the partner is paid through AWS partner programs and your consumption is covered by credits — so you pay $0 or low cost. If you are not credit-eligible it is still a vetted referral that skips the hiring-and-vetting slog. This is what CloudRoute routes. Deep dives: DevOps-as-a-Service, DevOps consulting, AWS DevOps services, Terraform consulting, and the honest DevOps consulting pricing breakdown.

CloudRoute's routing rule: build in-house if DevOps is core and you are at scale; go fractional/contract for a small, well-defined scope you will own afterward; route to a partner for a production-ready outcome — especially if you are credit-eligible, because then it is AWS-funded and the cost-to-you collapses to roughly zero.

numbers

VIRealistic cost and timeline — what the work actually takes

Concrete ranges for the engagements teams most often need, so you can sanity-check any quote (or salary plan) against reality. These are representative 2026 ranges; your numbers move with scope, region, and how much existing mess has to be unwound — and note the right-hand column, where for credit-eligible companies the partner-delivered cost is frequently $0.

The single biggest variable is starting state: greenfield (empty account, clean slate) is faster and cheaper than remediating a two-year-old account full of click-ops, surprise dependencies, and one production database nobody is sure how to back up. The timelines below assume a focused engagement with an available point of contact on your side.

representative aws devops engagement cost + timeline (2026)
EngagementTypical timelineBuild/contract cost (representative)Vetted partner, credit-eligible
Landing zone (multi-account foundation)1–3 weeks$8K–$25KOften $0 (AWS-funded)
CI/CD pipeline + IaC baseline2–4 weeks$10K–$30KOften $0 (AWS-funded)
First production deploy on AWS (greenfield)2–6 weeks$15K–$50KOften $0–low
ECS/EKS containerization3–8 weeks$20K–$60KOften $0–low
Production-readiness uplift (rung 1 → rung 2)4–8 weeks$25K–$75KOften $0–low
Internal developer platform (rung 3)8–20 weeks$80K–$250K+Partly fundable; usually low cost
Ongoing fractional DevOpscontinuous$4K–$12K/monthVaries by program
In-house senior DevOps hire6–12 weeks to hire$160K–$220K/yr base + equityn/a (you employ them)
Build/contract figures are representative market ranges, not quotes — scope, region, and existing technical debt move them substantially. "Often $0" applies to credit-eligible engagements where the partner is AWS-funded and your spend is credit-covered; otherwise it is a vetted referral at the partner's normal rate. Confirm eligibility and scope before assuming $0.
how cloudroute fits

VIIWhere CloudRoute fits — and how the $0 actually works

CloudRoute is not an agency and not a tool — it is the routing layer: you tell us what you need, we match you to a vetted AWS partner who has built it before, and wherever you are eligible the engagement is structured so AWS funds it and you pay $0 or low cost. Here is the honest mechanic.

The economics work because three incentives line up. AWS wants startups consolidated on AWS long term, so it funds both credit pools (covering your bill) and partner-engagement programs (paying the partner to do the work). The partner wants funded, well-scoped engagements that AWS underwrites. CloudRoute is paid a routing commission by the partner on closed engagements. You sit outside that loop — which is why, for credit-eligible work, your invoice is $0. Nobody is being charitable; the structure simply does not require you in the payment chain.

The boundary: $0 applies to credit-eligible engagements. If your company qualifies for AWS Activate / partner-funded programs — typically institutionally funded startups with a real AWS workload — the partner work is frequently fully AWS-funded and your bill is credit-covered. If not (bootstrapped at small scale, an individual project, an AWS competitor, or an enterprise buying through procurement), CloudRoute is still a vetted-partner referral at the partner's normal rate. We tell you which bucket you are in before anything starts.

Because cost and credits are tightly linked, the credit conversation rides along with the DevOps one: a credit-eligible team getting a production-readiness uplift built can, in the same motion, have the bill funded — see $100K in AWS credits for the partner-filed credit mechanic, and the startup persona overview for how routing is tailored to early-stage teams. Get the work done, get it funded — that is the whole CloudRoute proposition.

the one-line version

Tell CloudRoute what you need built on AWS. We route you to a vetted AWS partner who has done it before. If you are credit-eligible, AWS funds the engagement and covers your bill — you pay $0 or low cost. If not, it is still a vetted referral that skips the hiring slog. No procurement, no vetting on your side, no single-point-of-failure hire.

side by side

Build vs hire vs partner — the AWS DevOps decision in one table

The three ways to get AWS DevOps done, on the dimensions that actually decide it. There is no universally right column — it depends on your scale, how core infrastructure is to your product, and whether you are credit-eligible.

DimensionBuild in-houseFractional / contractorVetted AWS partner (CloudRoute)
Time to start6–12 weeks (hiring)DaysDays (matched fast)
Time to production-ready3–6 monthsWeeks–months (varies)4–8 weeks (defined scope)
Cost$160K–$220K/yr per senior hire$120–$250/hr · $4K–$12K/moOften $0 if credit-eligible; else partner rate
Quality / vettingYou hire and assessYou vet the individualPre-vetted AWS Advanced/Premier partner
Continuity riskSingle point of failure if one hireSolo contractor can disappearA team, not a person
Best whenInfra is core + you are at scaleSmall, well-defined, you own it afterYou want a production-ready outcome delivered
AWS-funded?NoRarelyFrequently, for credit-eligible companies
Build if DevOps is core and you are past ~20–30 engineers. Go fractional for small, bounded scopes you will own afterward. Route to a partner for a delivered production-ready outcome — especially if you are credit-eligible, because then the engagement is typically AWS-funded and the cost to you approaches $0.
know what you need built?
Get it built by a vetted AWS partner — often AWS-funded, so $0 to you
Get matched in 24h →
a recent match

Heroku-to-AWS, production-ready in seven weeks — anonymized

inquiry · seed-stage b2b saas, 9 engineers, EU
Seed-stage B2B SaaS (workflow automation), 9 engineers, running on Heroku, just signed first enterprise pilot

Situation: The pilot came with a security questionnaire Heroku could not satisfy — no multi-account isolation, no audit logging, no documented DR. They needed to be on AWS and production-ready (rung 2) before the security review, but had zero in-house DevOps: the senior backend engineer was improvising infrastructure between feature work and dreaded owning it. Hiring would have meant months they did not have and a $180K salary they could not yet justify.

What CloudRoute did: Routed within 24 hours to an EU-region AWS Advanced partner with a Heroku-migration and SOC 2 track record. The partner delivered a Control Tower landing zone (dev/staging/prod accounts, Identity Center, centralized logging), containerized the app onto ECS Fargate, stood up a GitHub Actions → AWS OIDC pipeline with blue/green deploys and rollback, wired CloudWatch plus an OpenTelemetry trace pipeline, and set up Multi-AZ RDS with automated, tested backups. In parallel — Series-seed with institutional funding and a real AWS workload — the partner filed for AWS credits to cover the bill.

Outcome: Production-ready on AWS in 7 weeks, ahead of the security review, which they passed. The engagement was AWS-funded and the first months of spend were credit-covered, so the customer paid $0 for the build and ~$0 for the bill. The backend engineer went back to shipping product, and CloudRoute was paid its routing commission by the partner.

engagement window: 7 weeks · founder/eng time: ~12 hours · outcome: rung-2 production-ready + credits · cost to customer: $0

faq

Common questions

What does "AWS DevOps" actually include?
Eight surfaces: infrastructure-as-code (Terraform/OpenTofu/CDK/CloudFormation), CI/CD (GitHub Actions, GitLab CI, or CodePipeline), containers (ECS, EKS, Fargate, Lambda), networking (VPC, load balancers, Route 53, CloudFront), IAM and security (a Control Tower landing zone, least-privilege roles, secrets, SOC 2 readiness), observability (CloudWatch, X-Ray, Datadog/Grafana), reliability and DR (Multi-AZ, blue/green and canary deploys, backups with real RTO/RPO), and cost/FinOps (right-sizing, Savings Plans, tagging, AWS credits). A complete practice has an automated, owned answer for all eight.
Should I use the AWS-native toolchain or Terraform, GitHub Actions, and Datadog?
Almost no production team runs the AWS-native stack pure — they blend it. CloudFormation/CDK are great for AWS-only infrastructure; Terraform or OpenTofu wins when you also manage non-AWS resources under one tool and one state model. CodePipeline works, but most teams prefer GitHub Actions or GitLab CI deploying into AWS over OIDC, next to their code. CloudWatch is the cheapest start for observability; Datadog or Grafana get layered on as you scale. The right blend is per-surface and depends on how much of your stack lives outside AWS and how mature your team is.
ECS or EKS — which should I start with?
For most teams, start with Amazon ECS on Fargate: production-grade container orchestration with far less operational surface than Kubernetes — no control plane or nodes to manage. Reach for Amazon EKS (managed Kubernetes) only when you genuinely need it: multi-cloud portability, the k8s-native tooling ecosystem, or teams that already operate Kubernetes well. Reaching for EKS too early is a common and expensive AWS DevOps mistake. See our ECS vs EKS deep dive for the full decision.
How long does it take to get production-ready on AWS?
For a focused engagement with an available point of contact, a greenfield first production deploy is typically 2–6 weeks, and a full production-readiness uplift (reproducible IaC, automated CI/CD with rollback, a Control Tower landing zone, Multi-AZ, real observability, a tested recovery path) is usually 4–8 weeks. Remediating a messy two-year-old account takes longer. Building an in-house team to the same bar typically takes 3–6 months once you account for hiring and ramp.
What does AWS DevOps cost — should I hire, contract, or use a partner?
A senior in-house engineer runs roughly $160K–$220K base plus equity and months to hire and ramp. A fractional or contract engineer is typically $120–$250/hr, or $4K–$12K/month ongoing. A vetted AWS partner delivering a defined outcome (landing zone, CI/CD, containerization, production-readiness) is often substantially AWS-funded for credit-eligible companies — $0 or low cost — and for non-eligible companies is a vetted referral at the partner's normal rate. Build in-house if infra is core and you are at scale; contract for small bounded scopes; use a partner for a delivered outcome.
Is the "$0" real, or is there a catch?
It is real for credit-eligible engagements, with no catch for you. AWS funds the partner through partner programs and covers your bill through credits because it wants startups on AWS long term. The partner is paid by AWS; CloudRoute is paid a routing commission by the partner; you sit outside that loop, so your invoice is $0. The boundary is eligibility — typically institutionally funded startups with a real AWS workload. If you are not eligible, CloudRoute is still a vetted-partner referral at the partner's normal rate. We tell you which bucket you are in upfront.
Is Terraform still the default in 2026, given the license change?
Terraform moved to the Business Source License (BSL) in 2023, prompting the community to create OpenTofu — a fully open (Linux Foundation) fork that is drop-in compatible for the vast majority of use cases. In 2026 both are widely used: Terraform retains the larger ecosystem and HashiCorp Cloud integration; OpenTofu is the open-license choice many teams adopt to avoid BSL terms. CDK and Pulumi (general-purpose languages) and CloudFormation (AWS-native) are the main alternatives. The practical default is OpenTofu or Terraform; CDK is strong for AWS-only shops with a TypeScript/Python team.
We have one engineer who knows our AWS account and they might leave. What do we do?
This is one of the most common reasons teams search for AWS DevOps help — a textbook bus-factor problem. The fix is to get the account into a reproducible, documented, owned state before that knowledge walks out the door: infrastructure in code, the landing zone formalized, deploys automated, runbooks written. A vetted partner can do exactly this uplift in a focused 4–8 week engagement — often AWS-funded for credit-eligible companies. CloudRoute routes you to one fast so the departure stops being an existential risk.

Get your AWS DevOps built by a vetted partner — often $0

Landing zone, CI/CD, containers, observability, production-readiness — delivered by an AWS Advanced/Premier partner who has done it dozens of times. Credit-eligible? It is typically AWS-funded, so you pay $0. No hiring, no vetting, no single-point-of-failure.

matched within< 24h
production-ready in4–8 wks
cost if eligible$0
AWS DevOps — the complete 2026 guide (cost, build vs hire) · CloudRoute