What the bill, the latency graph and the migration plan look like from inside a production platform.
A cloud bill growing with revenue is fine. One growing faster is a business problem hiding inside an infrastructure report. Pick the unit, attribute the shared cost, and the conversation with the board changes.
Formatting and validation are free, static analysis is nearly free, policy on the plan is cheap, and real apply-and-destroy tests are expensive and slow. Spend accordingly, and know what each layer cannot catch.
The two failures are a module that wraps one resource and adds nothing, and a module that does everything and nobody dares change. A minimal interface, safe defaults and honest versioning are what separate them.
A StatefulSet guarantees less than people assume, a volume pins a pod to a zone, and the honest question is whether that database belongs in the cluster at all.
Most service level objectives are picked from the metric the team already had, and never change anyone's behaviour. Here is how to choose the indicator from the user's experience and wire an error budget to a real decision.
A plan is a thousand lines of diff in a terminal. The questions you actually want answered — what does this cost, what does it expose, what breaks if it fails — are not in that format. Here is how we made Skyline answer them from the code alone.
Most teams running two or more clouds have never seen them on one page. When they do, the surprises are consistent enough to list: regions nobody chose, resources Terraform does not know about, and a cost distribution that does not match anyone's mental model.
Mutual TLS, fine-grained traffic control and uniform telemetry without touching application code. What each one actually costs in latency, memory and operational load, and the cheaper things that cover two out of three.
The choice is not about elegance. It is traffic shape, cold start tolerance, execution duration, environment control and what your team can actually operate at three in the morning.
Most teams have backups and no idea how long a restore takes. Set recovery targets per service, prove them with a quarterly restore test, and write the plan so it fits on one page.
One distributes work and forgets it. The other is an ordered log several consumers can replay. Choosing the wrong one produces an architecture that fights you for years.
Loops, types and tests come free with a general-purpose language. What you give up is a plan a non-programmer can review, and a low floor for the people who have to maintain it at three in the morning.
Cardinality is behind almost every Prometheus problem you will have, and it is usually one label added by one well-meaning engineer. How to find it, how to survive retention and HA, and when Thanos or Mimir is actually justified.
Nearly every performance incident we investigate is a missing index, a connection pool that is not there, or autovacuum sized for a database a tenth the size. Resizing the instance is the fix people try first and it is almost never the answer.
The licence change matters differently to an end user, a software vendor and a consultancy. Compatibility is high and diverging, migration is cheap and returning is not. Here is the decision framework without the partisanship.
OpenTelemetry is not equally mature across traces, metrics and logs, and the adoption plans that fail treat it as one migration. Here is the order that works and where the double-billing months come from.
Allocation by requests or by usage creates opposite incentives, shared costs start the argument, and showback before chargeback is what stops the whole exercise being rejected.
Compartments and defined tags are the allocation model, flexible shapes make rightsizing continuous rather than stepwise, and the universal credit commitment behaves differently from a reservation.
Cold, warm and hot standby differ by an order of magnitude in price and by minutes or hours in recovery. Pick the tier from what an outage actually costs you, and be honest that most estates should buy multi-zone instead.
Log volume rises with traffic, with every new service and with every debugging session somebody forgot to turn off. Structure decides whether they are useful, and six rules decide whether they are affordable.
Open table formats changed the negotiation by separating storage from compute. What is left to decide is your workload mix, your governance boundary, and which cost model you can actually control.
A namespace is a naming boundary, not a security boundary. Quotas, default-deny network policy, workload identity and a clear answer on node isolation are what make a shared cluster work.
The support calendar decides your schedule whether you plan or not. Deprecated APIs, blocked drains and add-ons that lag the control plane are the three things that turn an upgrade into an incident.
Most companies running Jenkins are not running it badly, they are running it unattended. How to tell a Jenkins worth keeping from one that is quietly costing you a day a week, and what migration actually costs.
Infracost turns a Terraform plan into a monthly delta on the pull request. What it estimates well, what it cannot estimate at all, and how to keep the comment from becoming wallpaper.
An exclusion filter at the sink is the highest-return control in the whole platform, and the storage class minimums punish a lifecycle rule written without reading them.
Standard bills for nodes you provision, Autopilot bills for pod resources you request. Both are dominated by the same number, and it is the gap between what pods ask for and what they use.
Gateway API is usually sold on features. The real reason to move is that Ingress has no separation between the team that owns the load balancer and the team that owns the route. Here is the migration that does not need a maintenance window.
Every provider names, groups and dates its billing data differently, so multi-cloud cost reporting turns into a translation project. An open specification fixes the schema, and what it cannot fix is worth knowing before you build.
Most tracing deployments produce disconnected single spans and a bill. Context propagation, tail sampling and a handful of useful attributes are what turn a trace store into the tool you open during an incident.
A pipeline runs when someone triggers it. A controller reconciles continuously, which fixes drift by construction. What you pay is another control plane to operate and a harder debugging story.
A budget does not stop spending and a forecast alert arrives late. What actually catches a cost spike is a short detection window, a small set of known failure shapes and a named owner.
Chaos engineering fails when it starts with a tool and a production cluster. Start with a hypothesis, a small blast radius and a stop condition, and the first five experiments will find something every time.
Invalidation, stampede and the day the cache fills are the three. A time to live is the boring correct answer to the first, and most caching problems turn out to be a missing index.
Ransomware crews go for the backups first, and cloud backups are easier to delete than tape ever was. Immutability, credential separation and a copy outside the blast radius are what turn a backup into a recovery.
Backstage solves three real problems: finding who owns a service, creating one with the right scaffolding, and keeping docs near the code. It fails when the catalogue is maintained by hand.
Storage looks cheap per gigabyte, so nobody audits it. Then redundancy, transactions, early-deletion penalties and cross-region transfer turn a small line into a large one.
Log Analytics ingestion is the line that grows without anyone deciding it should. Six controls bring it down, and none of them mean losing the telemetry you actually use.
The AKS control plane is nearly free, so everything you pay comes from node pools, and the defaults are expensive. Here is what we change, in the order that finds money fastest.
S3 looks like a per-gigabyte price and it is not. Minimum durations, per-object overheads, transition requests and the transfer boundaries around the bucket are where the money actually goes.
Ingestion, storage, custom metrics, dashboards and queries are priced separately. The dimension explosion in custom metrics and debug logging left on in production account for most of the surprise.
Commitments lock in whatever you are running today. Before you sign one, walk the bill layer by layer and remove what should not be there. Here is the order we use.
An on-call rota that gets 40 pages a week is not monitoring, it is a filter that trains humans to dismiss things. Alert on symptoms, alert on burn rate, and delete everything nobody has ever acted on.
Airflow should schedule and coordinate, never process. dbt should transform inside the warehouse with tests attached. The failure that costs most is data quality nobody checked until a dashboard was wrong for a quarter.
The three changes that turn a hand-configured Jenkins into one you can rebuild from an empty machine in twenty minutes, and what each one costs to adopt.
Most multi-account designs fail because nobody agreed what an account is for. Here is the account map we deploy, what lives in each one, and the three guardrails that make it hold.
Both will build your containers. The differences that actually decide it are runner economics, how each handles multi-repo pipelines, and what happens to your secrets.
Hosted minutes stop being cheap somewhere around 100,000 a month. Running your own runners on Kubernetes is straightforward; running them safely takes three specific decisions.
Pipeline duration is the cheapest developer productivity lever most teams never pull. Where the time really goes, and how to get a 40-minute build under 10 without changing CI vendor.
Argo CD is easy to install and easy to misuse. The repository layout, the sync policy and the secrets decision that separate a working GitOps setup from a dashboard full of red.
Shifting 10 percent of traffic to a new version is not a canary if nothing is watching. The metrics, the analysis window and the abort rule that make progressive delivery worth the complexity.
Terraform creates the machine, Ansible decides what is on it. Where the boundary belongs, why provisioners are a trap, and what changes when your estate is mostly containers.
Kubernetes-native CI gives you pipelines as custom resources and scaling for free. It also gives you a pipeline engine you now operate. When that trade is worth making.
ARM instances are 20 to 40 percent cheaper for the same work, and the migration is mostly a build problem, not a code problem. Here is the order we do it in and the four things that bite.
Kubernetes hides waste better than any other platform, because everything looks busy. Four measurements tell you where the money goes, and three changes usually halve it.
An agent with cloud credentials is the most useful and most dangerous automation you can build. The pattern that works is investigation with a read-only role and change as a reviewed plan.
Most Terraform pain is not HCL. It is one enormous state file, applies from laptops and three years of manual console changes nobody imported. Here is how we untangle it.
Aurora is not automatically better or cheaper. It wins on specific axes, loses on others, and the migration has one path that keeps downtime under a minute. Here is the decision and the runbook.
Networking mistakes in AWS are the expensive kind, because fixing them means moving workloads. These six come up in almost every estate we review, and five of them are cheap to get right on day one.
In GCP the project is the blast radius and the folder is where policy lives. Most estates we see have neither used deliberately. Here is the structure we deploy and the eight policies we set on day one.
On-demand BigQuery charges for bytes scanned, so one badly written dashboard can cost more than your compute. Here is how we cap it without slowing anyone down.
Autopilot charges for what your pods request and removes node management. That is a better deal than it sounds for most teams and a worse one for a few. Here is how to tell which you are.
Most teams running GKE would be better served by Cloud Run, and a few running Cloud Run are fighting it. The decision is not about scale — it is about four specific requirements.
CUDs come in two flavours that behave very differently, and buying the wrong one locks you to a machine family for three years. Here is the sequence we follow.
The google provider has behaviours that will surprise you the first time — authoritative IAM resources that wipe bindings, projects that will not delete, APIs that must be enabled before anything works. Here is the setup we use.
The Cloud Adoption Framework reference architecture is large and most teams deploy a fraction of it. Here is the subset that carries the weight: management groups, subscription boundaries and the policies that hold it together.
Azure has more discount mechanisms than any other cloud and they stack in a specific order. Get the order wrong and you commit to capacity a hybrid benefit would have made unnecessary.
Network plugin, identity model, node pool layout and upgrade strategy are all chosen in the first hour and all painful to change afterwards. Here is what we pick and why.
Locking down PaaS services in Azure is straightforward until the name resolution breaks in a way that only shows up from one subnet. Here is the model that works and how to lay out the hub.
The three options differ on features, cost and how much of your existing database you have to change. Here is the decision tree and the migration that keeps downtime short.
Bicep is better at Azure than Terraform in several specific ways, and worse in several others. The right answer depends on whether Azure is your only cloud and who maintains the code.
Oracle Cloud puts everything in one tenancy and separates it with compartments. That is a different model from AWS accounts or Azure subscriptions, and copying either one produces a mess.
OCI prices egress and compute differently enough that a like-for-like comparison with AWS misleads in both directions. Here is what genuinely moves and how we model it.
Oracle's managed Kubernetes is closer to the others than people expect, with three genuine differences: the free control plane, the ARM allowance and a networking model you choose at creation.
It genuinely removes patching, tuning and backup configuration. It does not remove schema design, connection management or the need to understand what your queries do. Here is where it fits.
A VCN looks like a VPC until you meet the four gateway types and two firewall models. Here is the layout we build and the specific choices that avoid rework.
Oracle ships a managed Terraform service that removes the backend and the runner. Here is when it is the right call, when to run your own pipeline, and the OCI-specific things that catch people.
Most services have a counterpart and the translation is mechanical. Three things are not mechanical, and they decide whether the migration is worth doing at all.