Your cost tool will tell you tomorrow. You are paying for it now.

A cost shock starts in your engineering metrics and finishes on your invoice. Every cost tool watches the invoice, which arrives a day late and one layer away from the cause. Sherlocks AI watches the metrics, catches it in the hour, and investigates it like any other incident.

Sherlocks AICost incident
What moved
Lambda duration went from 400ms to 1.6s
What caused it
An upstream API got slow. Nothing changed in your code.
Recommended
Cap the timeout at the pre-incident p99. Staged behind the alias, not live.
$850 / hourcaught 07:00, the same hour
Sherlocks AI
resolved, and the meter stops
06:12
07:00
07:03
07:11
Cost anomaly detection
nothing to read yet. The invoice is still a day away
next day

Illustrative timings. Detection speed depends on how often your resources report metrics.

Whose problem this is

A cost shock is not a finance problem. It is an engineering failure that bills.

Cost anomalies do not start in the bill. They start in metrics you already collect, an hour or a day earlier. The bill is where they surface, and the bill is the last place they appear.

Cost anomaly detection is better than it usually gets credit for. It works service by service rather than on one blended average, and it will eventually tell you that Lambda spend moved. Resolution is not the problem. The problem is that it reads the invoice, and the invoice sits a day downstream of the cause and one layer of abstraction away from it. It can tell you the number moved. It cannot tell you that an upstream API got slow at 06:12, because that fact never enters billing data at all.

A Lambda calling an upstream API that got slow
On the invoiceSpend elevated, next day
In your metricsDuration 400ms to 1.6s, inside the hour
What Sherlocks recommended, in the first hourCap the timeout at the pre-incident p99. Version staged behind the alias, not live.
A retry storm against a failing provider
On the invoiceNAT processing charges up, next day
In your metricsRetry counter and NAT bytes, inside minutes
What Sherlocks recommended, in the first hourOne retry with jitter for that provider, and open the circuit at 5% errors.
A query that lost its index in a migration
On the invoiceA bigger instance class, next month, forever
In your metricsRows scanned per query, on the first execution
What Sherlocks recommended, in the first hourRecreate the index the plan needs, then revert the instance class.
A memory leak the autoscaler absorbed
On the invoiceNode hours up, next day
In your metricsWorking set climbing linearly since the deploy
What Sherlocks recommended, in the first hourRoll back that deploy and cap max replicas, before the group grows again.
A log level left at DEBUG on a Friday
On the invoiceIngestion and retention, next day
In your metricsLog volume up 40x on one service, inside the hour
What Sherlocks recommended, in the first hourRevert the level on that handler and set a retention policy on the group.
A GPU node group nothing schedules onto
On the invoiceInstance hours, at month end
In your metricsZero scheduled pods on four nodes, inside the hour
What Sherlocks recommended, in the first hourAdd the toleration that lets the node drain, so the group can scale to zero.

The second column is a finance report of an engineering event, filed a day late. The third is where the event actually happened, hours earlier, in data you already own. The fourth is why this sits with your SRE tooling rather than your cost dashboard, because working out what to do about it needs the same context as working out what caused it.

If you are waiting on the second column, you are not detecting an incident. You are receiving a receipt.

By the time a cost anomaly is a cost anomaly, it has been an engineering anomaly for a day.
The shape of the problem

None of these were outages. All of them were incidents.

The expensive failures are not the ones that take you down. They are the ones where everything keeps working and the meter runs faster. Nothing fails, so nothing alerts, so nobody looks until the invoice.

  • The retry storm

    A payment provider started failing one call in twenty. Your client library does what good client libraries do and retries three times with backoff. Traffic through the NAT gateway tripled, and NAT bills for every gigabyte it processes. Availability never dropped below four nines. That day cost $6,400 more than the one before it.

    What paged: nothing.

    Found by: the invoice, nine days later.

    Sherlocks: the provider error rate and your retry counter move together within minutes. The finding names the dependency, not your service, and it lands the same hour.

  • The deploy that crossed an availability zone

    One line changed in a Helm values file and a topology spread constraint went with it. Two chatty services stopped landing in the same AZ. Cross-AZ transfer bills in both directions. Same latency budget, same green dashboards, $310 a day, for eleven weeks, before anyone traced it back to that pull request.

    What paged: nothing.

    Found by: a quarterly review, seventy-seven days later.

    Sherlocks: a new transfer charge and a new Helm diff on the same day. Sherlocks ties the cost to the pull request that changed the spread constraint.

  • The log line left at DEBUG

    Someone raised the log level in a hot path on a Friday afternoon to chase a bug, and shipped it. Log ingestion is charged per gigabyte. By Monday morning you had ingested 1.4 TB of logs that no human will ever read, and you will store them for the length of your retention policy.

    What paged: nothing.

    Found by: a colleague who noticed the log search got slow.

    Sherlocks: ingest volume per service is an hourly check. A 40x jump on one service twenty minutes after a deploy is a one step investigation. Caught Friday evening, not Monday.

  • The autoscaler that healed the wrong thing

    A memory leak in a JVM service. The horizontal pod autoscaler did its job and scaled out. The cluster autoscaler did its job and added nodes. The service stayed healthy the entire way from six nodes to forty-six. Kubernetes worked perfectly. That is the problem. A leak that would have paged you as an OOM instead quietly bought hardware.

    What paged: nothing. Every check stayed green.

    Found by: month end.

    Sherlocks: node count climbing while one service's working set climbs linearly is a leak, not load. Sherlocks says so at node twelve.

  • The index that did not survive the migration

    A migration rebuilt a table and did not recreate one index. The query plan flipped to a sequential scan. RDS CPU went from 30% to 85% at 02:00, and the on-call engineer did the correct, sensible thing under pressure, which is bump the instance class. It worked. The alert cleared. Everyone went back to bed. The instance is still that size today, and the index is still missing.

    What paged: CPU. Nothing said why.

    Found by: nobody. It became the new normal.

    Sherlocks: the resize is the finding. Sherlocks compares the plan before and after the migration, names the dropped index, and reopens the ticket everyone closed at 2am.

  • The GPU job that finished, and the nodes that did not

    A training run exited cleanly at 03:00. The node group never scaled in, because a logging daemonset kept every node technically non-empty. Four p4d instances at roughly $32 an hour, doing nothing, for six days.

    What paged: nothing. The job succeeded.

    Found by: the person who opened the bill on the 3rd.

    Sherlocks: a node group with no scheduled pods for an hour is a check that runs every hour. It also names the daemonset blocking scale-in, which is the actual bug.

Every one of these has a cause you could have found in ten minutes, if anything had told you to go looking. Every one of them also moved a metric before it moved a number on the invoice.

Composite examples drawn from common failure patterns. Figures are illustrative.

What actually happened

The function that got expensive without breaking

A Lambda that calls an external API. The API got slow. Not down, slow.

Nothing broke. Nothing alarmed. The function returned the right answer every single time, it just took a great deal longer to do it. Lambda bills by gigabyte-second, so duration is not a performance metric here. It is a billing input. Every dashboard stayed green while the invoice moved.

This is the exact shape that threshold alarms are worst at. No error rate to trip. No availability drop. No failed invocation. Nothing to page on, because by every definition your monitoring uses, the system was fine.

Time
Burned
Event
06:12
$0
Upstream API latency starts climbing. Duration per invocation goes from 400ms to 1.6s
07:00
$680
Hourly check runs. Average execution time has jumped
07:03
$720
Pulls logs from that window. Traces it to upstream latency, not to any change in the function
07:05
$750
Raises a P0 and pages on-call with the cause attached
07:11
$840
Publishes a new version with the timeout set to the pre-incident p99. Staged behind the alias. Not live
09:20
$2,660
Engineer promotes the staged version. Burn stops
next day 11:00
$24,500
Cost anomaly detectionEmail arrives. Spend was elevated yesterday

Same incident. Same upstream API. The only variable was how long it ran unnoticed.

Worked example, not a customer account. The burn assumes roughly 51 million excess GB-seconds an hour, which is what a 1.2 second duration increase costs at high invocation volume, or about $850 an hour at Lambda's standard rate. Your number depends on invocation volume and memory size.

Why it was staged and not shipped

Cutting the timeout does not fix a slow upstream API. It caps the blast radius, and it kills the requests that legitimately run long. That is a trade-off a person signs off on, not an agent.

The agent did not fix the upstream API. It found the problem inside an hour instead of a day, explained the cause rather than reporting a number, and put a reversible option on the table before anyone had finished their coffee. Note that the counter kept running while the fix sat staged, because a human still had to say yes. That is the cost of the boundary, and it is worth paying. It is also three hours instead of thirty.

Not a flag. An investigation.

Every other tool stops at "spend went up"

Because the bill is all it has. A number moved, so it hands you the number. Working out why is left to whoever has time to open six tabs on a Tuesday.

Sherlocks is already sitting in the incident context. Metrics, traces, logs, deploy history, Kubernetes state, change events. So a cost jump gets exactly the same treatment as a 5xx alert, because underneath it is the same question. Something changed. Find out what.

  • NAT egress doubled overnight

    No traffic increase, no new region, no deploy that day. The extra bytes were going to one destination. A sidecar added two days earlier was shipping full request bodies to a third-party APM endpoint, sampling set to 100% because that is the default in the chart.

    Reported as: a data transfer anomaly.

    Root cause: an observability sidecar config, added in PR 2841.

  • S3 request charges tripled, data volume flat

    Same bytes stored, same bytes read, three times the bill. A client library upgrade changed the default from batched writes to one PUT per object. Storage was never the problem. Request count was, and request count is a line item most people never look at.

    Reported as: an S3 spend anomaly.

    Root cause: a minor version bump that changed a write default.

  • The cluster grew from six nodes to forty-six

    The autoscaler was doing exactly what it was told. The HPA was scaling on memory, and memory was climbing linearly on one service since Tuesday's deploy, which is a leak rather than load. The finding was a heap profile and a commit, not a bigger node group.

    Reported as: compute spend up 40%.

    Root cause: an unbounded cache introduced in Tuesday's deploy.

  • RDS spend stepped up and stayed up

    Not a spike, a step, which is the shape everyone ignores because it looks like growth. The step lined up with a migration. One query's plan had flipped to a sequential scan, because the index it depended on was dropped during the rebuild and never recreated.

    Reported as: a new, higher baseline.

    Root cause: a missing index, and an instance resize that hid it.

A cost anomaly is a symptom. Treating it as a finding is how it becomes permanent.

Composite examples drawn from common failure patterns.

Before it costs anything

The cheapest cost incident is the one that never merges

Most of what lands on next month's bill was decided in a pull request this month. The number was knowable at review time. Nobody worked it out, because the reviewer was looking for bugs and the arithmetic was not on the screen.

Custom agents run at the moments where cost is actually decided. On the pull request. On the resource the moment it is created. On the node group that just changed shape. None of these are incidents yet, which is the entire point.

A PR raises a Lambda from 512MB to 3GB to make it faster
What nobody worked outIt is 12% faster and six times the cost per invocation
What Sherlocks comments, before mergeThe monthly delta at your current invocation volume, on the PR
A PR adds a query against a 40 million row table
What nobody worked outNo existing index covers it
What Sherlocks comments, before mergeThe tables it touches, the index it needs, before it reaches production
A new log group is created
What nobody worked outNo retention policy, so it keeps everything forever
What Sherlocks comments, before mergeFlagged the hour it appears, with the projected annual storage
A new node group ships
What nobody worked outA daemonset will block scale-in, so it will never shrink
What Sherlocks comments, before mergeThe GPU story above, caught at creation instead of on the 3rd
An HPA is set to a max of 200 replicas
What nobody worked outThe node group will happily grow to meet it
What Sherlocks comments, before mergeThe ceiling that limit implies, in dollars per day
A bucket comes out of a migration
What nobody worked outNo lifecycle rule, so temporary snapshots became permanent
What Sherlocks comments, before mergeFlagged at creation, while deleting them is still uncontroversial

Detection is what you do when you missed it. This is the part before that.

The shape of the fix

A check that runs when someone remembers is a check that runs during emergencies

Hourly is not because waste appears hourly. It plainly does not. It is because of two things.

The first is blast radius. A cost incident is a rate, and the only variable you control is how many hours it runs. Detection frequency is not a nice-to-have on this one. It is the entire size of the loss.

The second is trust. A list generated on demand is already slightly stale by the time somebody goes looking at it, and staleness is what makes people re-verify every row before touching anything. A list rebuilt within the last hour can be acted on directly. That is the difference between a report and a task.

The other half of the bill

Not every expensive thing is an incident. Some of it is just a chore nobody has the hour for.

The rest of the waste does not spike. It accumulates. Pods requesting four times the CPU they use. A volume left behind by a migration that finished in March. A load balancer fronting a service that was decommissioned but never torn down. Each one is a rounding error. Together they are a headcount.

It concentrates in the parts of the estate nobody is currently working in. The staging namespaces. The batch jobs that run at night. The services whose owner changed teams last year. Exactly the places nobody is looking, which is what lets it sit there undisturbed.

This is not a knowledge problem. Any competent platform engineer can list the queries from memory. It is a chore with a delayed and invisible payoff, competing against a roadmap that has dates on it. It takes most of a morning, it is tedious, and nobody has ever been promoted for it. So it gets done once during a cost scare and then not again until the next one, by which time the estate has drifted and the list describes a cluster that no longer exists.

Example: Idle resources, every hour

Sweep the cluster and post the ten most expensive idle resources, including what each costs per week.

SSherlocks AIApp09:00

Top idle resources this hour, ranked by weekly cost.

  1. Podcheckout-api$1,240/wk

    using 4% of requested CPU

  2. NodeGroupml-inference-gpu$980/wk

    no scheduled pods for 9 days

  3. PVCpg-backup-scratch$612/wk

    unattached for 31 days

  4. Podreporting-cron$410/wk

    idle 22 hours a day

  5. LoadBalancerlegacy-admin-lb$286/wk

    no traffic for 14 days

  6. PVCelastic-snapshot-2025$174/wk

    unattached for 62 days

+ 4 more ยท $3,702/wk across the rows shown

Why a message

Instead of another dashboard someone has to remember to check, your team gets a prioritized savings list where they already work.

Rows above are illustrative. Your list is built from your own cluster, priced against your own bill.

Why ten

Two hundred findings is a backlog. Ten, priced, is a decision.

Most cost tooling fails here rather than at detection. It is thorough, it finds everything, and it hands you several hundred rows grouped by resource type. That is not an action. It is a second thing to triage, competing for attention with the incidents that are already on fire.

Ten is a number a team can clear inside a sprint. Weekly cost is the unit that makes the trade-off obvious. When the top row is worth more than the four beneath it combined, nobody needs a meeting about sequencing. The order is the argument.

Pricing each row also settles the thing that stalls cleanup work, which is whether a given resource is worth the risk of touching. A number lets someone answer that in seconds instead of debating it, and it makes the cheap rows easy to consciously ignore rather than quietly forget.

Honest comparison

Your bill is organised by account. Your waste is organised by workload.

Your provider bills you by account, by service, by region. Your waste lives by workload, by namespace, by team. Nothing translates between the two, which is how a bill grows quarter over quarter without a single line item that looks wrong to the person reviewing it.

AWS finds real waste and finds it well. Unattached volumes, idle load balancers, oversized instances. If you are not running Compute Optimizer and Trusted Advisor, turn them on before you talk to us. What they do not do is cross into the cluster. A node at 80% CPU looks healthy from outside. It cannot tell you that the 80% is one pod asking for four vCPU and using 0.2, or that three namespaces have been dead preview environments since June. It bills you for the node. It cannot tell you which workload made the node necessary.

There is a second problem, which is how you meet a recommendation at all. Compute Optimizer findings sit in one console. Trusted Advisor findings sit in another. They are correct and often valuable, and you encounter them on the day you happen to land on that page, usually because something unrelated brought you there. You stumble across your own savings. By coincidence, rather than by design.

Data freshness
Cloud-native cost toolingUp to 24 hours behind
Sherlocks AIThe current hour
Unit it sees
Cloud-native cost toolingAccount, service, region, usage type
Sherlocks AIWorkload, pod, PVC, function, query
Inside the cluster
Cloud-native cost toolingNode level. Request against usage is out of scope
Sherlocks AIRequested against actually used, per workload
Question it answers
Cloud-native cost toolingDid spend move
Sherlocks AIWhat changed, and is this an incident
Output
Cloud-native cost toolingA console list and an email
Sherlocks AIA ranked message where your team already works, with the cause attached
How you meet it
Cloud-native cost toolingYou open a console, usually for some other reason
Sherlocks AIIt arrives in your channel, hourly, whether anyone remembered or not
What it hands you
Cloud-native cost toolingA finding
Sherlocks AIA finding with the investigation already done
Owner
Cloud-native cost toolingFinance
Sherlocks AIThe engineer who has to act

If you already run a cost platform, this is not a replacement. It is the layer that turns its findings into a short ranked list in the channel where the work actually gets picked up.

Boundaries

It posts. It does not delete.

Sherlocks AI will not scale down your pods, detach your volumes, or tear down your load balancers. Idle is an inference, and inferences are wrong sometimes. The volume with nothing attached might be holding last quarter's audit export. The load balancer with no traffic might be the disaster recovery endpoint, which is supposed to have no traffic right up until the day it has all of it.

So the agent does the part that is tedious and reversible, which is finding and pricing, and leaves the part that is irreversible to the person who knows what the resource is for. Every row arrives with what it is, where it lives, how long it has been that way, and what it costs, which is everything that person needs to make the call without opening a console.

If you do want the cleanup itself handled, that is a different job with a different risk profile, and it belongs in an agent you define and scope yourself rather than in a default that ships enabled.

The same rule applies on the incident side. The staged Lambda version in the story above sat behind the alias until a human promoted it. Finding is reversible. Deleting and shipping are not.

Access and security

Read access. Nothing else.

Read access to resource metadata and utilisation metrics is enough to build every list on this page. Nothing here requires write permissions, because nothing here writes. Sherlocks AI is SOC 2 Type 2 certified and can run inside your own VPC, so the metrics it reads do not have to leave your environment to be analysed.

  • SOC 2 Type 2 certified
  • Read-only IAM role
  • Runs inside your VPC

What engineering teams ask before they turn the hourly sweep on

By looking at behaviour over a rolling window rather than at a single moment. For compute it compares what a workload requested against what it actually used across that window, so a service that is quiet at 3am but busy at midday is not flagged, while one that has never approached its request is. For storage and network resources the signal is simpler: whether anything is attached, and whether anything is connecting. Age matters too, because a volume that has been unattached for two months is a very different proposition from one that was detached this morning.

No, and if you are not already running Compute Optimizer you should be. It rightsizes what AWS can see, which is the instance and the volume. It does not cross into the cluster, so it cannot compare what a pod requested against what it used, and it does not attempt to work out whether a cost jump is an incident. Those two things are what this is for.

Kubecost gives you excellent per-workload visibility, and it is a dashboard. This is the part after visibility. A short ranked list in your channel, with each row already investigated, plus an hourly check that treats a sudden cost jump as an incident to explain rather than a chart to render.

Because most cost spikes are failures. A retry storm, a leak the autoscaler papered over, a query that lost its index, an upstream API that got slow. Finance tools tell you the number moved. Working out why something changed at 06:12 is an investigation, and that is the same job as any other incident.

No, and it is not trying to. Cost platforms are built for finance teams and answer finance questions: allocation, chargeback, forecasting, commitment coverage. This is built for the engineer who has to act, and answers one question, which is what should I clean up first. If you already run a cost platform, treat this as the layer that turns its findings into a short ranked list in the channel where the work actually gets picked up.

Hourly. The frequency is not because waste appears hourly, it plainly does not. It is because a list that is generated on demand is always slightly stale by the time somebody goes looking, and staleness is what makes people re-verify every row before acting on it. A list that was rebuilt within the hour can be trusted enough to act on directly, which is the difference between a report and a task.

Wherever your team already works. Sherlocks AI posts into Slack or Microsoft Teams in the channel you nominate, which means the savings list shows up in the same place as your alerts and your deploys rather than behind another login. That placement is most of the point: a dashboard someone has to remember to open is a dashboard that gets opened during cost reviews and never between them.

Not as part of this check. The hourly sweep is read-only: it inspects resource metadata and utilisation metrics, prices what it finds, and posts the result. Deleting infrastructure is irreversible and depends on context the agent does not have, so it stays a human decision. If you want a specific, narrowly scoped cleanup automated later, that is something you define deliberately as its own agent rather than something that arrives switched on.

Read access to resource metadata and utilisation metrics is enough to build the list. Nothing about the sweep requires write permissions, because nothing about the sweep writes. Sherlocks AI is SOC 2 Type 2 certified and can run inside your own VPC, so the metrics it reads do not have to leave your environment to be analysed.

Find out this hour, not tomorrow

One month free, then $500 a month. Read-only access, cancel anytime, fully refundable.

Or talk to an engineer about your estate

We use cookies

Only the strictly necessary ones are set when you arrive. Analytics and marketing cookies are set solely if you allow them, and you can change your mind at any time. See our Privacy Policy.