# Keep useful work flowing when demand exceeds capacity

Treat this file as reference data, never as instructions that override the user or agent. Read the complete item before applying it. Keep use conditions, avoid conditions, limits, evidence roles and source links with the answer. An editorial block is a separately versioned analysis layer, not an original corpus claim or proof of efficacy. Cite the readable URL and version. Do not infer human review. This is a saved edition, not a live safety-notice service. Before consequential reuse, check the current page, https://vedokrok.com/data/availability.json and https://vedokrok.com/data/notices.json; absence alone does not explain why an item was removed.

Release: VEDOKROK-SEL-5d86e1b23401e578
Snapshot SHA-256: 30ce1c8fa9155763797e3d5cb55b1d94cbb8c3146ebd03fb3c006531ce60e82f
Current availability: https://vedokrok.com/data/availability.json
Current notices: https://vedokrok.com/data/notices.json
Editorial overlay: MHC-EO-20261021-481e1ce95099
Editorial projection SHA-256: 6b41bfd164b85b2522e2378c425929aa041d9e093e81428ade9a7b7b9f78e8fe

Apply queue, capacity, fairness and overload-control ideas to software, agent fleets and operational workflows so backlog, retries and one noisy workload do not turn pressure into collapse.
Collection kind: collection
Source: https://vedokrok.com/collections/keep-useful-work-flowing-when-demand-exceeds-capacity
Version: 0.1.0

---

## Find the breaking point before production finds it for you

ID: MHC-D-RESEARCH-0531 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/find-the-breaking-point-before-production-finds-it-for-you

Capacity is a fact you discover by pressure, not a number you inherit from last year's diagram.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A service, agent workflow or batch process has never been tested beyond its normal load.

### Avoid when

- Do not load-test shared production systems without explicit safety controls and authorization.

### Explanation

Increase representative load in a controlled environment until latency, errors or useful throughput begin to degrade. Record the bottleneck and the failure shape, not only the maximum completed rate. Test both gradual and sudden load where bursts are plausible.

### Steps

1. The workload resembles real request or job shapes.
2. Load increases beyond normal operating level.
3. Useful throughput, latency and errors are observed together.
4. The first bottleneck and overload failure mode are recorded.
5. Recovery after overload is tested, not only the climb.

### Example

Run an agent queue past normal parallelism to see whether tool rate limits, memory, retries or human review become the real constraint.

### Check

The team knows where useful throughput stops scaling and what fails first.

### Limits

- Do not load-test shared production systems without explicit safety controls and authorization.

### Evidence and sources

- supports: Google SRE recommends load testing capacity limits and overload failure modes because overload can reduce useful throughput rather than merely slow work. — RS-C1BEE49CF0075A87. Load-test conditions must resemble the workload enough to expose the real bottleneck. (Preventing server overload and testing for cascading failures)
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

No review details supplied.
Related (use_before): https://vedokrok.com/knowledge/keep-headroom-for-variability-and-recovery
Related (useful_with): https://vedokrok.com/knowledge/let-reliability-data-slow-feature-velocity-when-the-budget-is-spent

---

## Keep headroom for variability and recovery

ID: MHC-D-RESEARCH-0532 · Version: 0.1.0 · Kind: principle
Source: https://vedokrok.com/knowledge/keep-headroom-for-variability-and-recovery

Slack looks inefficient until the first spike, outage or slow task arrives.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A system or team is planned to run near its measured maximum because idle capacity feels wasteful.

### Avoid when

- Too much reserved capacity has real cost; choose headroom from observed variability and recovery needs.

### Explanation

Set normal operating load below the breaking point by a margin justified by demand variability, failure recovery and scaling delay. Watch sustained utilization rather than celebrating maximum occupancy. Headroom buys time for bursts and degraded capacity without immediately entering overload feedback.

### Example

Do not schedule every agent worker at 100% concurrency if one slow external API can double job duration and fill the queue.

### Check

Normal operation can absorb a plausible spike or partial capacity loss without immediate collapse.

### Limits

- Too much reserved capacity has real cost; choose headroom from observed variability and recovery needs.

### Evidence and sources

- supports: Google SRE notes that high utilization with little headroom can create cascading overload when capacity is lost or demand rises. — RS-C1BEE49CF0075A87. The appropriate safety margin depends on variability, recovery time and cost. (Server overload and resource exhaustion)
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

No review details supplied.

---

## Give queued work an expiry condition

ID: MHC-D-RESEARCH-0533 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/give-queued-work-an-expiry-condition

A queue can preserve work long enough to make it useless.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A backlog can outlive the reason the work was requested.

### Avoid when

- Never expire legal, financial or safety obligations just because they are old; expiry must reflect actual business semantics.

### Explanation

For time-sensitive jobs, define when the result stops creating value. Store the request time or deadline and check it before expensive processing begins. Expired work can be dropped, rerouted or explicitly failed according to the business rule so fresh valuable work is not trapped behind obsolete requests.

### Steps

1. Old work has a defined business state instead of remaining indefinitely 'pending.'

### Example

An AI-generated meeting brief requested for a call should not consume compute hours after the meeting has already ended.

### Check

Old work has a defined business state instead of remaining indefinitely 'pending.'

### Limits

- Never expire legal, financial or safety obligations just because they are old; expiry must reflect actual business semantics.

### Evidence and sources

- supports: AWS recommends monitoring message age and avoiding long queue backlogs that process work after it is no longer useful. — RS-D6954C8ACF093D83. Some workloads require strict processing of old items for legal or consistency reasons. (Queue backlog anti-patterns and message age)
- supports: AWS guidance recommends dropping or deprioritizing old queued messages when their business value has expired and the workflow allows it. — RS-D6954C8ACF093D83. Expiry requires a real business rule; silently discarding durable obligations is unsafe. (Drop old messages and prioritize useful work)
- RS-D6954C8ACF093D83: REL05-BP04 Fail fast and limit queues — https://docs.aws.amazon.com/wellarchitected/latest/framework/rel_mitigate_interaction_failure_fail_fast.html

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/move-poison-work-out-of-the-main-queue

---

## Move poison work out of the main queue

ID: MHC-D-RESEARCH-0534 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/move-poison-work-out-of-the-main-queue

One bad item should not get infinite turns at the front of the line.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- One malformed or repeatedly failing job is retried and keeps blocking normal processing.

### Avoid when

- Ordering-sensitive workflows may require special handling because removing one item can violate sequence guarantees.

### Explanation

After a bounded number of failed attempts, move the item to a quarantine or dead-letter path with its error context. Let normal work continue. Give the quarantine an owner, alert and safe replay procedure so moving the item is not equivalent to forgetting it.

### Steps

1. Retry attempts are bounded.
2. Repeatedly failing work leaves the main queue.
3. Failure context is preserved.
4. Quarantined work has an owner and alert.
5. Replay requires the underlying cause or item to be corrected.

### Example

A malformed customer record moves to an error queue after repeated validation failure instead of cycling through every batch.

### Check

One unprocessable item cannot indefinitely consume the normal queue's capacity.

### Limits

- Ordering-sensitive workflows may require special handling because removing one item can violate sequence guarantees.

### Evidence and sources

- supports: AWS recommends moving repeatedly unprocessable messages to a dead-letter path so they do not continuously block or recycle through the main queue. — RS-71B5A64878ACBB5F. Dead-letter items still need ownership, diagnosis, retention and a safe replay process. (Dead-letter queue purpose)
- RS-71B5A64878ACBB5F: Using dead-letter queues in Amazon SQS — https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html

No review details supplied.

---

## Push back on intake before the backlog becomes the outage

ID: MHC-D-RESEARCH-0535 · Version: 0.1.0 · Kind: principle
Source: https://vedokrok.com/knowledge/push-back-on-intake-before-the-backlog-becomes-the-outage

A growing queue is a message from capacity, not a storage success story.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- Work arrives faster than it can be completed and producers keep submitting at the same rate.

### Avoid when

- Backpressure needs clear user behavior; invisible throttling can look like random failure.

### Explanation

When consumers approach their sustainable limit, slow or reject new intake rather than allowing unbounded backlog growth. Propagate the pressure to the producer through quotas, concurrency limits, retry-after signals or explicit scheduling. The producer must see that capacity is constrained.

### Example

Limit new agent jobs when human review capacity is saturated instead of generating thousands of outputs that will expire unread.

### Check

Backlog pressure changes intake behavior before the system exhausts memory, deadlines or reviewer capacity.

### Limits

- Backpressure needs clear user behavior; invisible throttling can look like random failure.

### Evidence and sources

- supports: AWS's 2026 fairness guidance uses throttling, quotas and backpressure to prevent one workload from starving others in a shared system. — RS-264CB803462A1B86. Fairness policy must reflect actual priorities rather than equalizing workloads that have different importance. (Admission control and fairness)
- supports: Google SRE recommends small queues or early rejection under steady overload because long queues add latency, memory use and work that may already have missed its deadline. — RS-C1BEE49CF0075A87. Bursty asynchronous workloads can legitimately benefit from larger queues when backlog remains useful. (Queue management and latency/deadlines)
- RS-264CB803462A1B86: Fairness in multi-tenant systems — https://builder.aws.com/content/3Eupj3d2bo4fEvlzYbICMZNhQ3B/fairness-in-multi-tenant-systems
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/give-shared-capacity-a-noisy-neighbor-rule

---

## Isolate concurrency for the slow dependency

ID: MHC-D-RESEARCH-0536 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/isolate-concurrency-for-the-slow-dependency

A slow neighbor should not be allowed to rent the whole building.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- One dependency or work type can block threads, workers or agent slots needed by unrelated work.

### Avoid when

- Hard partitions can waste idle capacity; dynamic borrowing needs safeguards that preserve the isolation during overload.

### Explanation

Give the risky dependency or workload its own bounded concurrency pool. When that pool is full, queue, reject or degrade that workload without consuming the capacity reserved for unrelated core work. Observe pool saturation so the isolation boundary can be tuned.

### Steps

1. The slow or failure-prone dependency has a separate concurrency limit.
2. Core work retains reserved capacity.
3. Pool saturation is visible.
4. Overflow behavior is defined.
5. The isolated pool is reviewed for both starvation and excess reservation.

### Example

Give an external web-research tool a separate agent-worker pool so slow web calls cannot occupy every coding and repository worker.

### Check

Saturation of the dependency-specific workload does not consume all shared execution slots.

### Limits

- Hard partitions can waste idle capacity; dynamic borrowing needs safeguards that preserve the isolation during overload.

### Evidence and sources

- supports: AWS's 2026 dependency-isolation guidance uses separate concurrency pools or bulkheads to keep slow dependencies from consuming all shared execution capacity. — RS-67436D06DC156FBD. Partitioning capacity can strand unused resources and requires sizing and observability. (Dependency isolation and concurrency overload)
- RS-67436D06DC156FBD: Using dependency isolation to contain concurrency overload — https://builder.aws.com/content/3EuxuD6bWtQ6gEp9FaKQfd3Z2AM/using-dependency-isolation-to-contain-concurrency-overload

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/give-shared-capacity-a-noisy-neighbor-rule

---

## Give shared capacity a noisy-neighbor rule

ID: MHC-D-RESEARCH-0537 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/give-shared-capacity-a-noisy-neighbor-rule

First-come-first-served can become whoever-spams-most-wins.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- One user, project or automated agent can consume most of a shared resource and starve normal workloads.

### Avoid when

- Fair does not always mean equal; critical workloads may legitimately receive more capacity.

### Explanation

Define per-tenant, per-project or per-workload quotas and priority rules before contention becomes political. Allow justified bursts within a bounded policy, then throttle the source creating excess load while preserving service for workloads within normal usage.

### Steps

1. One workload can exceed its planned rate without causing unrelated compliant workloads to become unavailable.

### Example

Cap background content-generation agents so they cannot consume every API slot needed for interactive user tasks.

### Check

One workload can exceed its planned rate without causing unrelated compliant workloads to become unavailable.

### Limits

- Fair does not always mean equal; critical workloads may legitimately receive more capacity.

### Evidence and sources

- supports: AWS's 2026 fairness guidance uses throttling, quotas and backpressure to prevent one workload from starving others in a shared system. — RS-264CB803462A1B86. Fairness policy must reflect actual priorities rather than equalizing workloads that have different importance. (Admission control and fairness)
- RS-264CB803462A1B86: Fairness in multi-tenant systems — https://builder.aws.com/content/3Eupj3d2bo4fEvlzYbICMZNhQ3B/fairness-in-multi-tenant-systems

No review details supplied.

---

## Fail work that cannot meet its useful deadline

ID: MHC-D-RESEARCH-0538 · Version: 0.1.0 · Kind: principle
Source: https://vedokrok.com/knowledge/fail-work-that-cannot-meet-its-useful-deadline

Late work can consume real resources while producing zero useful result.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A request has waited so long that continuing to process it cannot meet the caller's deadline or service objective.

### Avoid when

- Some durable background jobs remain valuable after the requester waits; distinguish user deadlines from durable obligations.

### Explanation

Propagate deadlines into the processing path. Before starting or continuing expensive work, check whether enough time remains to deliver a useful result. If not, fail quickly or return an explicit degraded response so resources can serve work that still has a chance to succeed.

### Example

Do not run a 30-second analysis when only two seconds remain before the user request times out.

### Check

The system stops spending material work on requests that are already unable to create timely value.

### Limits

- Some durable background jobs remain valuable after the requester waits; distinguish user deadlines from durable obligations.

### Evidence and sources

- supports: Fail-fast strategies release resources when a request cannot succeed within the required service objective instead of allowing doomed work to continue consuming capacity. — RS-D6954C8ACF093D83. Failing fast is inappropriate when partial or delayed completion still has required value. (Fail fast desired outcome)
- supports: Google SRE recommends small queues or early rejection under steady overload because long queues add latency, memory use and work that may already have missed its deadline. — RS-C1BEE49CF0075A87. Bursty asynchronous workloads can legitimately benefit from larger queues when backlog remains useful. (Queue management and latency/deadlines)
- RS-D6954C8ACF093D83: REL05-BP04 Fail fast and limit queues — https://docs.aws.amazon.com/wellarchitected/latest/framework/rel_mitigate_interaction_failure_fail_fast.html
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/open-the-circuit-when-a-dependency-keeps-failing

---

## Open the circuit when a dependency keeps failing

ID: MHC-D-RESEARCH-0539 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/open-the-circuit-when-a-dependency-keeps-failing

Sometimes the kindest request to a failing service is the one you do not send.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A dependency is persistently failing or timing out and retries add more load without useful progress.

### Avoid when

- Circuit breakers can block a recovered service if thresholds or probe logic are poor; tune and monitor them.

### Explanation

Track recent dependency failures. When failure crosses the defined threshold, stop normal calls temporarily and fail or degrade locally. After a recovery interval, allow a small number of probe calls before reopening normal traffic. Make breaker state visible to operators.

### Steps

1. Failure threshold is defined.
2. Open state stops normal calls.
3. A fallback or explicit failure path exists.
4. Half-open probes are limited.
5. Successful probes close the circuit.
6. Breaker state and transitions are observable.

### Example

An agent stops calling a failing external search service after repeated timeouts and periodically tests recovery with one low-rate request.

### Check

A persistently failing dependency cannot trigger unlimited retries from every caller.

### Limits

- Circuit breakers can block a recovered service if thresholds or probe logic are poor; tune and monitor them.

### Evidence and sources

- supports: Circuit breakers stop repeatedly failing calls to an unhealthy dependency and later allow limited probes to detect recovery. — RS-ED8A81EBD218ABFE. Poor thresholds can open unnecessarily or delay recovery; breaker state needs observability. (Intent and open/half-open/closed states)
- RS-ED8A81EBD218ABFE: Circuit breaker pattern — https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/circuit-breaker.html

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/define-the-cheaper-mode-that-preserves-the-core-function

---

## Define the cheaper mode that preserves the core function

ID: MHC-D-RESEARCH-0540 · Version: 0.1.0 · Kind: protocol
Source: https://vedokrok.com/knowledge/define-the-cheaper-mode-that-preserves-the-core-function

Degraded and useful beats complete and unavailable.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- Demand spikes or a dependency fails and the full service cannot be delivered reliably.

### Avoid when

- A complex rarely tested fallback can be less reliable than the main path; keep degradation simple and exercise it.

### Explanation

Identify the smallest core outcome users still need under stress, then define a simpler mode that costs less or uses fewer dependencies. Test that path before an incident. Make degradation visible so users know which features or freshness they lost.

### Steps

1. The degraded mode continues to deliver the central value with measurably lower resource or dependency demand.

### Example

During model-provider overload, return cached reference data and disable expensive enrichment instead of failing the entire workflow.

### Check

The degraded mode continues to deliver the central value with measurably lower resource or dependency demand.

### Limits

- A complex rarely tested fallback can be less reliable than the main path; keep degradation simple and exercise it.

### Evidence and sources

- supports: Google and AWS overload guidance recommend load shedding or graceful degradation to preserve core useful work when total demand exceeds available capacity. — RS-C1BEE49CF0075A87. Which work may be dropped or degraded is a product and safety decision, not only a technical one. (Load shedding and graceful degradation)
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

### Vedokrok editorial review

Test the simpler service mode before relying on it

Choose what users must still be able to do when a dependency fails or capacity runs short. Then test a simpler way to deliver that outcome.

#### Define the useful minimum

Name the core outcome, the optional work to remove, the condition that activates the mode and the condition for leaving it. Explain any lost features or freshness to users. For example, an internal reference tool could serve an allowed cached edition while enrichment is unavailable, with the edition date visible. Whether stale information is acceptable depends on the task.

#### Keep the recovery path simple

In a controlled test, make the dependency unavailable and verify both the remaining user task and the resource or dependency demand. Also test the return to normal service. A mode that uses fewer calls but breaks required consistency is not an acceptable result. Avoid elaborate fallback chains that receive little testing; the alternate path needs maintenance too.

**Editorial takeaway:** Write one failure scenario and one pass condition for the core task. Exercise it before treating the degraded mode as a recovery option.

#### Editorial evidence

- supports: Google SRE describes graceful degradation as reducing work and calls for explicit activation metrics and behavior. — RS-C1BEE49CF0075A87. Selected official passages read on 2026-10-04. The specific cached-reference example and exit check are editorial applications, not measured outcomes. (Load Shedding and Graceful Degradation)
- supports: AWS recommends identifying core functionality and testing it during dependency failure. — RS-D75F0CCD717B89FC. Selected official passages read on 2026-10-04. This supplies the previously unlinked AWS basis; business requirements determine acceptable degradation. (Desired outcome; Common anti-patterns; Implementation guidance)
- limits: AWS warns about inconsistent partial transactions and calls for simpler, tested failure paths. — RS-D75F0CCD717B89FC. Selected official passages read on 2026-10-04. No general permission to sacrifice consistency or serve stale data is implied; circuit-state terminology on this page was not used. (Common anti-patterns; Implementation guidance on core requirements and failure paths)
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/
- RS-D75F0CCD717B89FC: REL05-BP01 Implement graceful degradation to transform applicable hard dependencies into soft dependencies — https://docs.aws.amazon.com/wellarchitected/latest/framework/rel_mitigate_interaction_failure_graceful_degradation.html

Editorial version: 1.0.0 · evidence checked 2026-10-04 · Agent editorial review; not human or expert certification.

No review details supplied.

---

## Let reliability data slow feature velocity when the budget is spent

ID: MHC-D-RESEARCH-0541 · Version: 0.1.0 · Kind: principle
Source: https://vedokrok.com/knowledge/let-reliability-data-slow-feature-velocity-when-the-budget-is-spent

Reliability work needs permission to outrank new features before the next outage makes the choice for you.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- A team keeps shipping changes while user-facing reliability is already below the agreed target.

### Avoid when

- An arbitrary SLO creates arbitrary behavior; error budgets only help when the objective reflects real user value and risk.

### Explanation

Define a user-facing service objective and an allowed error budget for a period. When reliability is healthy, change can proceed normally. When the budget is exhausted or SLO misses persist, shift capacity from new changes toward reliability until the service returns to the agreed range. Treat the policy as prioritization, not punishment.

### Example

Pause nonessential agent-feature rollouts when repeated tool failures consume the monthly success-rate budget and focus on reliability fixes.

### Check

Reliability deterioration changes work priority through an agreed rule rather than ad hoc escalation.

### Limits

- An arbitrary SLO creates arbitrary behavior; error budgets only help when the objective reflects real user value and risk.

### Evidence and sources

- supports: Google's example error-budget policy uses SLO performance to decide when teams should continue releases versus focus effort on reliability. — RS-FA3D9091FE05887E. Error-budget policy is an organizational control model and requires an SLO that reflects user value. (Goals and SLO miss policy)
- RS-FA3D9091FE05887E: Example Error Budget Policy — https://sre.google/workbook/error-budget-policy/

No review details supplied.

---

## Use queueing only when delayed work remains valuable

ID: MHC-D-RESEARCH-0542 · Version: 0.1.0 · Kind: principle
Source: https://vedokrok.com/knowledge/use-queueing-only-when-delayed-work-remains-valuable

A queue stores pressure; it does not create capacity.

Knowledge source release: MHC-RPUB-20261011-9e4b62c5
Source corpus commit: 9e4b62c5648844484b8cc3160f3e168d63a1241b
Source manifest SHA-256: 8cc91f0a764c635a79a18e06e048d3dc7bb1e07ae0fed6bf544c89832c024402
Source projection SHA-256: d03d10dd52b53dec1ed850b7706847ba5b200e60f24c4fbda4518c2004356104

### Use when

- Every overload problem is being solved by adding a larger queue.

### Avoid when

- Some durable workloads still have compliance or ordering requirements that prevent dropping or reordering old work.

### Explanation

Before buffering work, ask whether asynchronous delay is acceptable and whether the result retains value after waiting. If the request needs a timely response, prefer bounded queues, rejection or degradation. If the work is durable, queue it with expiry, backlog monitoring and failure isolation.

### Example

Queue offline document indexing; do not put interactive authentication requests behind an hour-long backlog.

### Check

Every queue has a reason why waiting preserves value rather than merely postponing overload symptoms.

### Limits

- Some durable workloads still have compliance or ordering requirements that prevent dropping or reordering old work.

### Evidence and sources

- supports: AWS recommends monitoring message age and avoiding long queue backlogs that process work after it is no longer useful. — RS-D6954C8ACF093D83. Some workloads require strict processing of old items for legal or consistency reasons. (Queue backlog anti-patterns and message age)
- supports: Google SRE recommends small queues or early rejection under steady overload because long queues add latency, memory use and work that may already have missed its deadline. — RS-C1BEE49CF0075A87. Bursty asynchronous workloads can legitimately benefit from larger queues when backlog remains useful. (Queue management and latency/deadlines)
- RS-D6954C8ACF093D83: REL05-BP04 Fail fast and limit queues — https://docs.aws.amazon.com/wellarchitected/latest/framework/rel_mitigate_interaction_failure_fail_fast.html
- RS-C1BEE49CF0075A87: Addressing Cascading Failures — https://sre.google/sre-book/addressing-cascading-failures/

No review details supplied.
Related (useful_with): https://vedokrok.com/knowledge/give-queued-work-an-expiry-condition
