diff --git a/openspec/changes/add-usage-budget-controls/design.md b/openspec/changes/add-usage-budget-controls/design.md
new file mode 100644
index 0000000000..c073d24c1c
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/design.md
@@ -0,0 +1,893 @@
+# Design: Add Usage Budget Controls
+
+## Overview
+
+Add three complementary usage budget controls:
+
+1. **Organization budget alert emails** — warnings sent when organization accepted event usage crosses configured percentage thresholds.
+2. **Automatic smart project throttling** — automatic project-isolated throttling/sampling when a project spikes enough to threaten organization usage.
+3. **Optional project event budgets** — user-configured project-level accepted event caps.
+
+These are event-usage controls, not generic API request throttling controls.
+
+The implementation should extend existing usage and notification paths:
+
+- `UsageService` remains responsible for usage totals, budget threshold detection, smart throughput calculations, and limit calculations.
+- Existing organization overage notification behavior remains unchanged.
+- `OverageMiddleware` remains the event-post gate for coarse request-level enforcement.
+- `EventPostsJob` / event post processing is where project-level sampled acceptance should happen after events are parsed.
+- Existing organization usage enforcement remains the outer hard limit.
+- Existing `ThrottlingMiddleware` remains unchanged for this feature.
+- Budget alert and smart throttling emails are asynchronous side effects and must not block event ingestion.
+
+## Existing code paths
+
+### Event post enforcement
+
+`OverageMiddleware` currently:
+
+1. Skips non-event posts.
+2. Gets the default organization id from the authenticated request.
+3. Rejects when event submission is globally disabled.
+4. Rejects invalid/oversized posts.
+5. Calls `UsageService.GetEventsLeftAsync(organizationId)`.
+6. Rejects organization overage.
+7. Allows the request to continue.
+
+This change keeps that coarse gate but does not rely on it as the only project-level enforcement layer.
+
+### Usage tracking
+
+`UsageService.IncrementTotalAsync(organizationId, projectId, eventCount)` already increments both:
+
+- organization bucket total
+- project bucket total
+
+Existing cache key helpers accept an optional `projectId`.
+
+Use these existing counters for organization budget alerts, smart project throttling, and project event budgets. Do not introduce a parallel accepted-event counter.
+
+### Event post processing
+
+`EventPostsJob` already:
+
+- loads project and organization
+- parses the post into events
+- calculates how many events can be processed
+- processes only allowed events
+- increments blocked usage for events over plan limit
+- increments accepted total usage for processed events
+- increments discarded usage for discarded events
+
+Extend this path for sampled project-level acceptance.
+
+### Existing organization notice email path
+
+Existing flow for monthly/hourly overage notices:
+
+1. `UsageService` publishes `PlanOverage`.
+2. `EnqueueOrganizationNotificationOnPlanOverage` subscribes to `PlanOverage`.
+3. It enqueues `OrganizationNotificationWorkItem`.
+4. `OrganizationNotificationWorkItemHandler` loads organization and users.
+5. The handler sends organization emails only to users with verified email addresses and email notifications enabled.
+6. `Mailer.SendOrganizationNoticeAsync` renders the organization notice email.
+
+Budget alerts and project smart throttling notifications should follow this pattern with new message/work item/mailer/template types.
+
+---
+
+## Automatic Smart Project Throttling
+
+### Overview
+
+Automatic smart project throttling is the default guardrail for sudden event spikes.
+
+It addresses historical feedback that:
+
+- organization-level throttling can punish all projects when one project is noisy
+- throttling should notify users when applied
+- throttling should still allow a small percentage of events through for troubleshooting
+- users should not need to configure many options before this protection works
+
+This is separate from optional project event budgets:
+
+- Smart throttling is automatic and adaptive.
+- Project event budgets are explicit user-configured caps.
+
+### Design principle: minimal configuration
+
+Smart project throttling should not require users to configure project percentages, per-project caps, or per-stack settings.
+
+The UI may expose status and explanation, but not a large set of tuning options.
+
+### Throughput calculation
+
+Smart throttling should use remaining monthly allowance and remaining time in the monthly usage period.
+
+Preferred formula shape:
+
+```text
+maxThroughput(window) = eventsLeftInMonth / windowsLeftInMonth * burstMultiplier
+```
+
+Where:
+
+* `eventsLeftInMonth` is the organization's current effective monthly allowance minus accepted usage.
+* `windowsLeftInMonth` is the number of five-minute usage buckets remaining in the period.
+* `burstMultiplier` is 10 to preserve existing Exceptionless burst tolerance.
+* Accepted totals include the current and previous unsaved buckets.
+
+This is intentionally different from a static `monthlyPlanLimit / timeInMonth` calculation. Customers should not be throttled harshly late in the month when they still have substantial allowance remaining.
+
+### Project isolation
+
+When organization-level smart throttling would apply, the system should identify the project or projects contributing to the spike and throttle those projects first.
+
+Observable behavior:
+
+* One noisy project should not cause all other projects in the organization to stop ingesting events.
+* Other projects should continue under organization-level usage enforcement unless they also exceed smart-throttling criteria.
+* If the organization hard monthly limit is exhausted, all projects remain subject to existing organization overage behavior.
+
+### Sampling while throttled
+
+When a project is smart-throttled and the organization still has remaining monthly allowance, Exceptionless should accept a small sample of events from that project.
+
+Recommended v1 behavior:
+
+```text
+sampleRate = 5%
+```
+
+V1 uses stable hash selection across the whole post. Sampling is a long-run probability, so a single-event post is genuinely accepted about 5% of the time rather than being forced through.
+
+Sampling goals:
+
+* Preserve visibility into whether the problem is still occurring.
+* Preserve visibility into whether a deployed fix reduced occurrences.
+* Preserve a representative long-run sample without a per-post minimum that biases single-event traffic.
+* Avoid allowing a noisy project to consume the entire organization allowance.
+
+### Event processing location
+
+Smart throttling and sampled acceptance should be implemented in the event processing path after event posts are parsed, not solely in `OverageMiddleware`.
+
+Reason:
+
+* `OverageMiddleware` can reject the entire request before the event count is known.
+* It cannot preserve a 1–5% sample of events from a batch.
+* `EventPostsJob` already parses the post, calculates `eventsToProcess`, processes only allowed events, and increments blocked usage for the rest.
+* Extending this job/path allows project-level partial acceptance while preserving existing usage accounting.
+
+### Event selection
+
+When only part of a batch can be accepted, the implementation should avoid always taking only the first events if doing so would bias troubleshooting data.
+
+Acceptable v1 approaches:
+
+* deterministic sampling by event id/hash
+* random sampling with stable seed per post
+* first-N selection only if no safe sampling utility exists, but this should be documented as a known limitation
+
+### Smart throttling state
+
+The system may store project throttling state in cache to avoid recalculating expensive decisions on every event.
+
+Suggested key shape:
+
+```text
+usage:{fiveMinuteBucket}:{organizationId}:{projectId}:smart-throttle
+```
+
+Suggested value:
+
+```json
+{
+  "is_throttled": true,
+  "sample_rate": 0.05,
+  "effective_until_utc": "..."
+}
+```
+
+TTL: short window, aligned with usage bucket/window duration.
+
+If cached throttle state expires, the system can re-evaluate based on current usage counters.
+
+`EnableSmartProjectThrottling` defaults to enabled and acts only as an operational kill switch for automatic smart throttling. Project-list status enrichment bulk-reads these short-lived keys once.
+
+### Smart throttling notification
+
+When a project enters smart-throttled state, eligible organization users should receive an email notification.
+
+Notification behavior:
+
+* Send at most once per project per throttling period or cooldown window.
+* Reuse the existing organization notification eligibility rules.
+* Do not send repeated emails for every event post while the project remains throttled.
+* Include project name, organization name, current project accepted usage, current fair-share limit, and a link to project usage.
+* Re-check current plan, usage, kill-switch, and throttle state in the delayed handler before sending.
+* Emit the dedicated throttled-event metric for sampled-out events and structured logs only when state transitions to active.
+
+Suggested message/work item:
+
+```csharp
+public record ProjectSmartThrottleApplied
+{
+    public required string OrganizationId { get; init; }
+    public required string ProjectId { get; init; }
+    public required double SampleRate { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+}
+```
+
+Suggested mailer method:
+
+```csharp
+Task SendProjectThrottledNoticeAsync(
+    User user,
+    Organization organization,
+    Project project,
+    double sampleRate,
+    int currentEventCount,
+    int eventLimit);
+```
+
+### Relationship to organization overage
+
+Smart project throttling is not a substitute for organization hard overage enforcement.
+
+Behavior:
+
+* If organization monthly allowance remains, smart-throttled projects may still have sampled events accepted.
+* If organization monthly allowance is exhausted, existing organization overage behavior applies.
+* Project sampling must not allow accepted event totals to exceed the organization hard monthly allowance.
+
+### Relationship to optional project event budgets
+
+If a project has an explicit project event budget, that budget participates in the same allowed-event calculation.
+
+Recommended order:
+
+```text
+organization hard allowance
+↓
+explicit project budget, if configured
+↓
+automatic smart throttling sample allowance, if active
+```
+
+The final number of events accepted from a batch should be the minimum allowed by all applicable controls.
+
+### Relationship to budget alert emails
+
+Smart throttling email notification is distinct from organization budget alert emails.
+
+* Budget alerts notify when organization accepted usage crosses configured percentages.
+* Smart throttling notifications notify when the system starts sampling/throttling a noisy project.
+* A project can be smart-throttled before any budget alert threshold is crossed.
+* A budget alert can fire without any project being smart-throttled.
+
+---
+
+## Organization Budget Alert Emails
+
+### Overview
+
+Add configurable organization-level event budget alert emails. These alerts warn users before monthly plan overage, based on accepted event usage crossing configured percentage thresholds.
+
+Budget alerts are informational only. They do not block ingestion and do not replace organization overage enforcement, smart throttling, or project event budgets.
+
+### Domain model
+
+Add budget alert settings to Organization.
+
+```csharp
+public class Organization
+{
+    // existing properties...
+    public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
+}
+```
+
+Add a new model:
+
+```csharp
+namespace Exceptionless.Core.Models;
+
+public class OrganizationBudgetAlertSettings
+{
+    public bool Enabled { get; set; }
+
+    /// <summary>
+    /// Percentage thresholds of the organization's effective monthly event allowance.
+    /// Example: [50, 80, 90].
+    /// </summary>
+    public SortedSet<int> Thresholds { get; set; } = [];
+}
+```
+
+### Defaults
+
+Existing organizations:
+
+```text
+budget_alert_settings = null
+```
+
+Null means disabled.
+
+New organizations:
+
+```text
+budget_alert_settings = null
+```
+
+The UI may suggest default thresholds [50, 80], but alerts must not be enabled until a user explicitly saves settings.
+
+### Validation
+
+Validation rules:
+
+* `BudgetAlertSettings == null` is valid.
+* `Enabled == false` with empty thresholds is valid.
+* If enabled, thresholds must contain at least one value.
+* Each threshold must be greater than 0.
+* Each threshold must be less than 100.
+* Threshold 100 is not allowed because existing monthly overage notification already handles reaching/exceeding the plan limit.
+* Duplicate thresholds must be removed.
+* Thresholds must be stored sorted ascending.
+* Percentage budget alerts must be rejected or disabled for unlimited organizations.
+
+### API contract
+
+Add `BudgetAlertSettings` to organization update and view DTOs.
+
+Preferred cleanup:
+
+```csharp
+public record UpdateOrganization
+{
+    public string Name { get; set; } = null!;
+    public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
+}
+```
+
+Then update `OrganizationController` generic usage from:
+
+```csharp
+RepositoryApiController<IOrganizationRepository, Organization, ViewOrganization, NewOrganization, NewOrganization>
+```
+
+to:
+
+```csharp
+RepositoryApiController<IOrganizationRepository, Organization, ViewOrganization, NewOrganization, UpdateOrganization>
+```
+
+If minimizing backend churn is preferred, `BudgetAlertSettings` can be added to `NewOrganization` because the current controller uses `NewOrganization` for both create and update. However, adding `UpdateOrganization` is cleaner because `NewOrganization` currently only contains the required organization name.
+
+Add to `ViewOrganization`:
+
+```csharp
+public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
+```
+
+Both `budget_alert_settings: null` and `ingest_limit: null` clear their settings. The canonical Delta OpenAPI transformer must generate the referenced complex component schemas and represent these PATCH properties as `oneOf: [null, $ref]`; snapshots and generated clients are regenerated from that output.
+
+Serialized JSON uses the existing snake_case policy.
+
+### Threshold calculation
+
+Use the same effective organization allowance as existing usage enforcement:
+
+```csharp
+effectiveOrganizationAllowance = organization.GetMaxEventsPerMonthWithBonus(timeProvider)
+```
+
+If effective allowance is negative/unlimited:
+
+```text
+budget alert thresholds are inactive
+```
+
+Threshold event count:
+
+```csharp
+thresholdEventCount = ceil(effectiveOrganizationAllowance * thresholdPercent / 100)
+```
+
+### Triggering alerts
+
+Budget alert checks should run in the accepted-event usage increment path.
+
+Recommended location:
+
+```text
+UsageService.IncrementTotalAsync
+```
+
+Observable behavior must be:
+
+* Alert fires when usage crosses threshold.
+* Alert does not fire before threshold.
+* Alert does not fire repeatedly after threshold.
+* Multiple crossed thresholds can fire if a large batch jumps over more than one threshold.
+* Crossing compares bucket-inclusive previous and current accepted totals.
+* Enabling alerts after usage already exceeds a threshold evaluates the newly active thresholds once immediately after save.
+
+### Deduplication
+
+Each organization threshold must email at most once per monthly usage period.
+
+Recommended cache key:
+
+```text
+usage-budget-alert:{yyyyMM}:{organizationId}:{threshold}
+```
+
+TTL: until end of current monthly usage period + safety buffer.
+
+The cache key is claimed atomically with `AddAsync` before publishing to prevent duplicate sends under concurrency.
+
+### Message and work item
+
+Add a new message:
+
+```csharp
+namespace Exceptionless.Core.Messaging.Models;
+
+public record OrganizationBudgetAlert
+{
+    public required string OrganizationId { get; init; }
+    public required int Threshold { get; init; }
+    public required int ThresholdEventCount { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+}
+```
+
+Add a new work item:
+
+```csharp
+namespace Exceptionless.Core.Models.WorkItems;
+
+public record OrganizationBudgetAlertWorkItem
+{
+    public required string OrganizationId { get; init; }
+    public required int Threshold { get; init; }
+    public required int ThresholdEventCount { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+}
+```
+
+Add a startup subscriber:
+
+```text
+EnqueueOrganizationBudgetAlertOnUsageThreshold
+```
+
+### Work item handler
+
+Add:
+
+```text
+OrganizationBudgetAlertWorkItemHandler
+```
+
+Behavior:
+
+* Load organization by id.
+* Load users in organization.
+* Send only to users with verified email addresses.
+* Send only to users with `EmailNotificationsEnabled == true`.
+* Use the same eligibility rules as existing organization notices.
+* Do not send if organization no longer exists.
+* Re-check current organization budget alert settings before sending.
+* If budget alerts are disabled or the threshold was removed, skip sending.
+
+### Mailer
+
+Add to `IMailer`:
+
+```csharp
+Task SendOrganizationBudgetAlertAsync(
+    User user,
+    Organization organization,
+    int threshold,
+    int thresholdEventCount,
+    int currentEventCount,
+    int eventLimit);
+```
+
+Add implementation in `Mailer`.
+
+Add template:
+
+```text
+src/Exceptionless.Core/Mail/Templates/organization-budget-alert.html
+```
+
+Template must include:
+
+* organization name
+* threshold percentage
+* threshold event count
+* current accepted event count
+* organization event limit
+* remaining event count
+* link to organization usage
+* link to billing/plan management when applicable
+* link to notification settings
+
+Do not include event payload data.
+
+---
+
+## Optional Project Event Budgets
+
+### Overview
+
+Add optional project-level event budgets enforced during event processing. This is an event-usage control, not generic API request throttling.
+
+### Domain model
+
+Add a nullable event budget configuration to Project.
+
+```csharp
+public class Project
+{
+    // existing properties...
+    public ProjectIngestLimit? IngestLimit { get; set; }
+}
+```
+
+Add a new model in `src/Exceptionless.Core/Models/ProjectIngestLimit.cs`:
+
+```csharp
+namespace Exceptionless.Core.Models;
+
+public class ProjectIngestLimit
+{
+    public ProjectIngestLimitType Type { get; set; }
+    public int? FixedLimit { get; set; }
+    public decimal? PercentOfOrganizationLimit { get; set; }
+}
+
+public enum ProjectIngestLimitType
+{
+    Fixed = 0,
+    PercentOfOrganizationLimit = 1
+}
+```
+
+### Naming
+
+Use `IngestLimit`, not `RateLimit`, because the feature limits accepted event volume for a project, not generic request rate.
+
+Use `ProjectIngestLimit`, not `ProjectQuota`, because this is a cap, not a reservation.
+
+### API contract
+
+Add `IngestLimit` to:
+
+```text
+src/Exceptionless.Web/Models/Project/UpdateProject.cs
+src/Exceptionless.Web/Models/Project/ViewProject.cs
+```
+
+Recommended DTO shape:
+
+```csharp
+public record UpdateProject
+{
+    public string Name { get; set; } = null!;
+    public bool DeleteBotDataEnabled { get; set; }
+    public ProjectIngestLimit? IngestLimit { get; set; }
+}
+
+public class ViewProject
+{
+    // existing properties...
+    public ProjectIngestLimit? IngestLimit { get; set; }
+    public int? EffectiveIngestLimit { get; set; }
+    public bool IsSmartThrottled { get; set; }
+    public double? SmartThrottleSampleRate { get; set; }
+}
+```
+
+### Project update behavior
+
+Use existing `PATCH /api/v2/projects/{id}`. Do not add a new endpoint.
+
+Clear project budget:
+
+```json
+{
+  "ingest_limit": null
+}
+```
+
+Fixed budget:
+
+```json
+{
+  "ingest_limit": {
+    "type": "fixed",
+    "fixed_limit": 20000
+  }
+}
+```
+
+Percentage budget:
+
+```json
+{
+  "ingest_limit": {
+    "type": "percent_of_organization_limit",
+    "percent_of_organization_limit": 20
+  }
+}
+```
+
+### Validation
+
+General validation:
+
+* `ingest_limit == null` is valid and means Off.
+* Unknown limit type is invalid.
+* Limit values must not be negative.
+* Ingest limit validation must not change existing project name validation.
+
+For Fixed:
+
+* `fixed_limit` is required.
+* `fixed_limit` must be greater than 0.
+* `percent_of_organization_limit` should be ignored or cleared server-side.
+* Backend should not reject a fixed limit greater than the current organization limit. The effective cap is clamped during evaluation.
+
+For PercentOfOrganizationLimit:
+
+* `percent_of_organization_limit` is required.
+* Percentage must be greater than 0.
+* Percentage must be less than or equal to 100.
+* `fixed_limit` should be ignored or cleared server-side.
+* If the organization currently has an unlimited event allowance, the API should reject setting a percentage cap because a percentage of unlimited is not meaningful.
+* If an existing percentage cap later encounters an unlimited organization due to a plan change, enforcement should treat the percentage cap as inactive until the organization returns to a finite allowance.
+
+### Effective project limit calculation
+
+Use the same effective organization max that current usage enforcement uses.
+
+```csharp
+private static int? GetEffectiveProjectIngestLimit(ProjectIngestLimit? limit, int organizationMaxEvents)
+{
+    if (limit is null)
+        return null;
+
+    return limit.Type switch
+    {
+        ProjectIngestLimitType.Fixed when limit.FixedLimit is > 0 =>
+            organizationMaxEvents < 0
+                ? limit.FixedLimit.Value
+                : Math.Min(limit.FixedLimit.Value, organizationMaxEvents),
+        ProjectIngestLimitType.PercentOfOrganizationLimit
+            when organizationMaxEvents > 0 && limit.PercentOfOrganizationLimit is > 0 =>
+                Math.Max(1, (int)Math.Ceiling(organizationMaxEvents * (limit.PercentOfOrganizationLimit.Value / 100m))),
+        _ => null
+    };
+}
+```
+
+### UsageService API
+
+Add project-aware/budget-aware event allowance calculation.
+
+The final event count accepted from a parsed batch should be the minimum allowed by:
+
+1. organization hard allowance
+2. explicit project event budget, if configured
+3. automatic smart throttling sampled allowance, if active
+
+Avoid a design that returns only a Boolean. The event processing path needs a count.
+
+Suggested result:
+
+```csharp
+public record EventIngestAllowanceResult
+{
+    public int EventsAllowed { get; init; }
+    public int OrganizationEventsLeft { get; init; }
+    public int? ProjectEventsLeft { get; init; }
+    public int? EffectiveProjectLimit { get; init; }
+    public bool IsSmartThrottled { get; init; }
+    public double? SmartThrottleSampleRate { get; init; }
+    public string? Reason { get; init; }
+}
+```
+
+Suggested method:
+
+```csharp
+public Task<EventIngestAllowanceResult> GetEventIngestAllowanceAsync(
+    Organization organization,
+    Project project);
+```
+
+Behavior:
+
+* Compute organization and project totals from one bulk read of persisted-total/current-bucket/previous-bucket cache keys.
+* If organization events left is <= 0, allow 0 events.
+* Compute explicit project budget events left if configured.
+* Compute smart throttling state/sample allowance if project is noisy.
+* Return the minimum allowed count.
+* Never return an allowed count greater than submitted event count.
+* Never return an allowed count greater than organization events left.
+
+### Refactor current events-left logic
+
+The event job's project-aware path uses the organization and project it already loaded. It must not issue repository rereads in normal traffic. Existing middleware may retain the organization-id-only helper for its coarse gate.
+
+```csharp
+public Task<EventIngestAllowanceResult> GetEventIngestAllowanceAsync(
+    Organization organization,
+    Project project)
+```
+
+Use existing total and bucket cache keys with optional project id. Query the repository's canonically invalidated organization project-count cache only when spike and remaining-allowance checks require fair-share evaluation.
+
+### OverageMiddleware behavior
+
+`OverageMiddleware` should continue handling request-level event-post gates:
+
+* non-event posts are skipped
+* missing organization context is rejected
+* globally disabled event submission is rejected
+* missing content length is rejected
+* oversized posts are rejected
+* organization hard overage can still be rejected early when there are no events left
+
+Project-level smart throttling and sampled project-budget behavior should not be implemented solely as early middleware rejection because early rejection drops the entire post and cannot preserve a sample.
+
+If `OverageMiddleware` detects that the organization has no remaining monthly allowance, it may preserve the existing organization overage rejection behavior.
+
+If the organization has remaining allowance, project-level controls should be evaluated later in `EventPostsJob` / `UsageService` after events are parsed.
+
+### Status code behavior
+
+* Organization monthly/bucket hard overage remains `402 PaymentRequired` where existing behavior already returns that status.
+* Oversized submissions continue to return `413 RequestEntityTooLarge`.
+* Missing content length continues to return `411 LengthRequired`.
+* Missing organization context continues to return `401 Unauthorized`.
+* Disabled event submission continues to return `503 ServiceUnavailable`.
+* Project smart throttling should not require changing the HTTP response for accepted queued posts; the job may accept a sample and block/discard the rest asynchronously.
+* Project hard rejection may return `429 TooManyRequests` only in code paths where the server can make an immediate project-level decision without sacrificing sampled acceptance. For the normal queued event-post path, project throttling should be represented by partial processing and blocked/discarded usage accounting rather than a full-request 429.
+
+### Headers
+
+Do not repurpose existing generic API throttle headers for project monthly ingest caps or smart project throttling in this change.
+
+### API throttling middleware
+
+Do not change `ThrottlingMiddleware` for this feature.
+
+### Storage and indexing
+
+Persisted data:
+
+* Existing organizations have `BudgetAlertSettings = null`.
+* Existing projects have `IngestLimit = null`.
+* No migration/backfill is required.
+* Null/default behavior must preserve current behavior.
+
+Elasticsearch:
+
+* Do not add Elasticsearch mappings for `Organization.BudgetAlertSettings` or `Project.IngestLimit` unless filtering/sorting/searching by those fields is required.
+* Avoid reindexing.
+
+### Organization Usage UI
+
+Add budget alert settings to:
+
+```text
+src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte
+```
+
+Place above the usage chart.
+
+Suggested card:
+
+```text
+Budget Alerts
+Receive an email when your organization reaches selected percentages of its monthly event allowance.
+[ ] Enable budget alerts
+Thresholds
+[50] [80] [90]
+[+ Add threshold]
+Current plan allowance: 100,000 events
+50% = 50,000 events
+80% = 80,000 events
+Alerts are sent once per threshold per monthly usage period to organization users who have email notifications enabled.
+```
+
+### Project Usage UI
+
+Add project event budget and smart throttling status to:
+
+```text
+src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte
+```
+
+Copy:
+
+```text
+Project Event Budget
+Protect your organization's monthly event allowance by limiting how many accepted events this project can use.
+This is a cap, not a reservation. Other projects are not guaranteed unused capacity.
+```
+
+Smart throttling status copy when active:
+
+```text
+Smart throttling is currently active for this project. Exceptionless is accepting a small sample of events so you can continue troubleshooting while protecting your organization's monthly event allowance.
+```
+
+Do not expose many tuning knobs.
+
+### Project usage chart behavior
+
+If `effective_ingest_limit` is not null, display the dashed limit line as the project limit.
+
+If `effective_ingest_limit` is null, keep showing the organization limit.
+
+Show smart throttling status as text or badge if active.
+
+### Accessibility
+
+* Slider controls must have accessible labels.
+* Numeric inputs must have associated labels.
+* Computed threshold/effective limit text should update in screen-reader-friendly text.
+* Do not rely on color only.
+* Save success/error must use existing toast/error patterns.
+
+### Security
+
+* Only users authorized to update the organization may update budget alert settings.
+* Only users authorized to update the project may update project event budgets.
+* Budget alert and smart throttling emails are sent only to verified users with email notifications enabled.
+* Project budgets do not grant additional access.
+* Users cannot increase organization allowance through project budgets.
+* Smart throttling must not allow accepted usage beyond organization hard allowance.
+
+### Privacy
+
+No new personal event data is collected.
+
+Budget alert and smart throttling emails include organization/project names and aggregate usage numbers only. They must not include event payload data, stack data, user-identifying event details, or project-specific event contents.
+
+### Failure modes
+
+**Budget alert email queue failure**
+
+If mail queue enqueue fails, do not block event ingestion.
+
+**Smart throttling email queue failure**
+
+If smart throttling notification enqueue fails, do not block event ingestion.
+
+**Dedupe cache failure**
+
+If dedupe cache fails, prefer avoiding ingestion failure. The implementation may skip alert sending rather than risk duplicate emails or ingestion failure.
+
+**Organization/project settings changed after message publication**
+
+Re-load settings in the work item handler. If the relevant notification is disabled or no longer applicable, skip sending.
+
+**Project lookup fails**
+
+If the project cannot be loaded during project-level evaluation, do not block solely due to project-level settings. Continue organization-level enforcement.
+
+**Invalid persisted settings**
+
+Treat invalid persisted settings as inactive for enforcement/notification. Do not crash event ingestion.
diff --git a/openspec/changes/add-usage-budget-controls/proposal.md b/openspec/changes/add-usage-budget-controls/proposal.md
new file mode 100644
index 0000000000..e4cee16752
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/proposal.md
@@ -0,0 +1,224 @@
+# Proposal: Add Usage Budget Controls
+
+## Summary
+
+Add usage budget controls that help organizations both **warn before overage** and **prevent noisy projects from consuming the full organization event allowance**.
+
+This change includes three related capabilities:
+
+1. **Organization budget alert emails** — configurable percentage thresholds such as 50% and 80% of the organization's monthly event allowance. When accepted event usage crosses a configured threshold, Exceptionless sends a budget alert email to eligible organization users.
+2. **Automatic smart project throttling** — when a project/environment starts sending enough events to threaten the organization's budget, Exceptionless should automatically isolate throttling to the noisy project where possible, instead of stopping ingestion for the entire organization.
+3. **Optional project event budgets** — project-level budget caps that allow customers to explicitly limit how many accepted events a project can consume in the monthly usage period.
+
+Budget alerts are warning controls. Smart project throttling is the default automatic guardrail. Project event budgets are optional prevention controls for customers who want explicit per-project limits.
+
+This change addresses customer feedback asking for budget alerts before plan overage:
+
+> Hi support team
+>
+> Is there any budget alerts we can configure in terms of the number of events? For example I want to receive an email when i have reached 50% of my plan, and then when 80% of my plan.
+>
+> This month we have exceeded twice our plan, and we should have a mechanism to prevent this situation.
+
+It also addresses historical customer feedback from issue #112 requesting smarter throttling:
+
+- project-level throttling
+- email notification when throttling is applied
+- 1–5% of errors delivered even under throttling
+
+## User-visible behavior
+
+### Organization budget alerts
+
+Users managing an organization can configure event budget alert thresholds from Organization Settings → Usage.
+
+Supported behavior:
+
+- Alerts are disabled by default for existing organizations.
+- Users can enable budget alerts and configure one or more percentage thresholds.
+- Example thresholds: 50%, 80%, 90%.
+- A threshold represents the organization's current monthly event allowance, including active bonus events if those are included by existing usage enforcement.
+- When accepted usage crosses a configured threshold for the first time in a monthly usage period, eligible organization users receive an email.
+- Each threshold is emailed at most once per monthly usage period.
+- Alerts are not sent for unlimited organizations because a percentage of unlimited usage is undefined.
+- Alerts do not block event ingestion.
+- Existing monthly overage emails remain unchanged.
+
+### Automatic smart project throttling
+
+Exceptionless should automatically protect organization usage when one project starts sending a large event spike.
+
+Supported behavior:
+
+- Users should not be required to configure smart throttling.
+- The system should avoid exposing a large number of throttling options.
+- When throttling is needed, it should be scoped to the noisy project where possible rather than blocking all projects in the organization.
+- While a project is throttled, Exceptionless should still accept a small sample of events from that project when the organization has remaining monthly allowance.
+- The accepted sample should preserve troubleshooting visibility so users can tell whether the issue is still happening and whether a deployed fix helped.
+- When smart throttling is applied, eligible organization users should receive an email notification.
+- Smart throttling should use remaining monthly allowance and remaining time in the period, not only the static plan size, to avoid throttling customers who still have substantial monthly allowance left.
+
+### Optional project event budgets
+
+Users managing a project can configure a Project Event Budget from Project Settings → Usage.
+
+Supported modes:
+
+- **Off**: no project-specific cap; current behavior is preserved.
+- **Fixed limit**: cap this project at a configured number of accepted events per monthly usage period.
+- **Percentage of organization limit**: cap this project at a percentage of the organization's current monthly event allowance.
+
+Examples:
+
+- A project with no configured ingest limit can consume organization events as it does today.
+- A project with a fixed limit of `20,000` can accept up to `20,000` events in the current monthly usage period, subject to the organization still having events available.
+- A project with a `20%` limit in an organization with `100,000` monthly events has an effective project cap of `20,000`.
+- If the organization plan changes, percentage-based project caps are recalculated from the organization's current event allowance.
+
+When a project limit is reached:
+
+- Event submissions for that project are limited or sampled.
+- Event submissions for other projects in the organization are not limited solely because this project reached its cap.
+- Blocked event usage is recorded for the project and organization.
+- Existing organization overage behavior remains unchanged.
+
+## Classification
+
+- **Type:** Feature
+- **Affected areas:** Backend/API, billing/usage enforcement, organization model, project model, Redis/cache usage counters, mail/work items, Svelte UI, generated API types, tests
+- **OpenSpec justification:** This change affects event ingestion behavior, organization/project usage limits, smart throttling behavior, email notification behavior, API response contracts, persisted organization/project data, Redis/cache usage state, SDK/client expectations, jobs, and Svelte UI/API contracts.
+
+## Current implementation context
+
+Exceptionless currently enforces organization event overage in `OverageMiddleware` for event posts. The middleware checks the authenticated organization id, rejects disabled event submission, rejects oversized submissions, and calls `UsageService.GetEventsLeftAsync(organizationId)` before allowing the event post to continue.
+
+`UsageService` already tracks both organization and project usage counters. `IncrementTotalAsync` increments organization totals and project totals using existing cache keys that accept an optional `projectId`.
+
+`EventPostsJob` already parses queued event posts, calculates how many events may be processed, processes only allowed events, increments blocked usage for events over the limit, and increments total/discarded usage for processed events. This is the correct place to implement project-level sampled acceptance.
+
+Exceptionless already has an organization overage email path. Existing usage overage publishes `PlanOverage`, which enqueues `OrganizationNotificationWorkItem`, and the work item handler sends organization notice emails to verified users with email notifications enabled. Budget alerts and project throttling notifications should reuse that mail/work-item pattern with distinct alert types rather than overloading monthly/hourly overage booleans.
+
+The existing generic API throttling middleware remains separate. It limits API requests over a short period and is not the same as event-plan usage enforcement.
+
+## Affected areas
+
+### Backend/API
+
+- Add organization usage budget alert settings to organization model/API responses.
+- Add project event budget fields to project model/API responses.
+- Extend usage tracking to publish budget-alert notifications when configured thresholds are crossed.
+- Extend usage/event post processing to compute smart project throttling and sampled acceptance.
+- Extend usage/event post processing to compute optional project budget limits.
+- Preserve existing organization-level overage behavior and status codes.
+- Avoid implementing project sampled throttling solely in middleware.
+
+### Redis/cache
+
+- Reuse existing organization/project usage counter keys.
+- Add budget alert dedupe state keyed by organization, threshold, and monthly usage period.
+- Add smart project throttling state or notification dedupe state keyed by organization/project/window where useful.
+- Preserve existing usage counter TTL behavior.
+- Do not add new project usage counter families unless required for efficient limit evaluation.
+
+### Mail/work items
+
+- Reuse the existing organization notification pattern.
+- Add budget-alert-specific message/work item/template.
+- Add project-smart-throttling-specific message/work item/template.
+- Send emails only to verified users with email notifications enabled, matching existing organization notice behavior.
+
+### Svelte UI
+
+- Add organization budget alert controls to the Svelte Organization Settings → Usage page.
+- Add project event budget controls to the Svelte Project Settings → Usage page.
+- Surface smart throttling status where feasible, especially on Project Usage.
+- Show computed thresholds/caps and current usage.
+- Update the project usage chart to display the project limit when configured.
+
+### Legacy Angular UI
+
+- Legacy Angular parity is out of scope for this change unless the release path requires these settings to be available in the legacy UI.
+- This change must not break existing legacy Angular organization or project management behavior.
+
+### SDK/client compatibility
+
+- Existing event submission authentication mechanisms must continue to work.
+- Existing project API keys and user tokens must continue to work.
+- Organization overage behavior must remain compatible.
+- Smart project throttling for queued event posts should prefer asynchronous sampled processing over changing the HTTP submission response.
+- Budget alert emails must be asynchronous side effects and must not change normal event submission success responses.
+
+### Tests
+
+- Add backend unit/integration tests for budget threshold calculation, smart throughput calculation, sampled acceptance, and project budget computation.
+- Add usage service tests for threshold crossing, dedupe, organization cap, project cap, and smart throttling behavior.
+- Add event post job tests for sampled acceptance and blocked usage accounting.
+- Add API tests for organization budget alert and project event budget update/validation.
+- Add mail/work-item tests for budget alert and smart throttling email eligibility/dedupe behavior.
+- Add Svelte UI tests or targeted manual QA for the Usage page controls.
+- Update HTTP samples if request/response contracts are changed.
+
+## Compatibility risks
+
+| Risk | Mitigation |
+|------|------------|
+| Existing event submissions could be rejected unexpectedly | Project event budgets default to null/Off for all existing projects. Smart throttling should preserve sampled acceptance when organization allowance remains. |
+| Existing organization overage behavior could change | Keep organization-level monthly/bucket enforcement intact. Organization hard overage remains the outer limit. |
+| Middleware-level project rejection would drop 100% of events | Project smart throttling and sampled acceptance must be implemented in the event processing path after events are parsed, not only in `OverageMiddleware`. |
+| Too much configuration conflicts with product direction | Smart project throttling must work automatically with minimal or no required user configuration. |
+| Existing customers expect some data while throttled | When the organization still has allowance, throttled projects should retain a small accepted sample rather than being fully blocked. |
+| Static monthly plan throttling can feel unfair late in the month | Throughput calculations should consider events remaining in the monthly period and time remaining in the monthly period. |
+| Project cap could be confused with reserved quota | UI copy must state that this is a cap, not a reservation. Other projects are not guaranteed unused capacity. |
+| Percentage caps could behave unexpectedly when organization plans change | Effective percentage caps are recalculated from the current organization event allowance each time limits are evaluated. |
+| Unlimited organization plans make percentage caps ambiguous | Percentage mode must be disabled or invalid for unlimited organizations. Fixed limits remain supported for project event budgets. Budget alert percentages are unavailable for unlimited organizations. |
+| Budget alerts could send unexpected emails | Default budget alert settings to disabled for existing organizations. Users must opt in. |
+| Duplicate threshold emails could annoy users | Each configured threshold is sent at most once per organization per monthly usage period. |
+| Existing overage emails could change | Keep existing `PlanOverage` monthly/hourly emails unchanged and add budget alerts and smart throttling emails as separate notification types. |
+| Persisted project or organization model changes could require Elasticsearch mapping/reindex | Store new settings source-only unless filtering/searching is added. No Elasticsearch mapping or reindex is required for enforcement. |
+
+## Non-goals
+
+- Do not implement API-key/token-level ingest limits in this change.
+- Do not implement rate-based billing.
+- Do not implement reserved project quotas.
+- Do not change plan billing, invoices, Stripe integration, or organization plan limits.
+- Do not change generic API request throttling behavior in `ThrottlingMiddleware`.
+- Do not add new public event-submission endpoints.
+- Do not migrate historical usage data.
+- Do not require Elasticsearch reindexing.
+- Do not require existing organizations or projects to be backfilled.
+- Do not implement per-recipient custom alert thresholds in this change.
+- Do not implement Slack/webhook budget alerts in this change.
+- Do not implement stack-level adaptive throttling in v1 unless it can be done with low risk; project-level isolation is the v1 scope.
+- Do not expose a large set of smart throttling tuning options in the UI.
+
+## Future considerations
+
+This design should leave room for future layers:
+
+1. Organization plan/event allowance.
+2. Organization budget alert thresholds.
+3. Automatic smart project throttling.
+4. Optional project event budget.
+5. API key/token ingest cap.
+6. Future rate-based or usage-based billing.
+
+Budget alerts should leave room for future channels and scopes:
+
+- fixed event-count alert thresholds
+- project-specific budget alerts
+- token/API-key-specific budget alerts
+- Slack/webhook alert delivery
+- role-based recipients
+- rate-based billing alerts
+
+The original issue suggested stack-level adaptive throttling with approximate occurrence counts. This change should leave room for that future direction, but v1 should focus on project-level isolation because it is simpler, aligns with project usage counters already tracked by Exceptionless, and directly addresses the customer problem of one product/environment affecting all others.
+
+## Rollback plan
+
+- Because project event budgets are opt-in, disabling or removing the UI leaves existing unset project budgets unchanged.
+- Because budget alerts are opt-in, disabling or removing the UI leaves existing unset organization alert settings unchanged.
+- If smart project throttling causes issues, smart throttling can be disabled while leaving budget alerts and optional project budgets in place.
+- If budget alert emails cause issues, budget alert publishing/subscribers can be disabled while leaving stored settings in place.
+- Existing organizations and projects default to null/Off, so rolling back model/API exposure has no effect on existing ingestion behavior unless users have already configured settings.
+- If stored settings must be disabled quickly, project budget and budget alert evaluation can be short-circuited to treat all settings as unset.
diff --git a/openspec/changes/add-usage-budget-controls/specs/api-compatibility/spec.md b/openspec/changes/add-usage-budget-controls/specs/api-compatibility/spec.md
new file mode 100644
index 0000000000..580e18bb3c
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/api-compatibility/spec.md
@@ -0,0 +1,158 @@
+# Spec: API Compatibility
+
+## ADDED Requirements
+
+### Requirement: Event submission MUST preserve existing organization overage behavior
+
+Exceptionless event submission MUST preserve existing organization overage and API authentication behavior while adding automatic smart project throttling and optional project event budgets.
+
+#### Scenario: Organization overage status remains unchanged
+
+Given an organization has no remaining event allowance
+When an event is submitted for a project in that organization
+Then the response status code must remain the existing organization overage status code.
+
+#### Scenario: Project smart throttling preserves queued event post compatibility
+
+Given an organization has remaining event allowance and a project is under smart throttling
+When an event post is submitted through the normal queued event submission path
+Then the HTTP response should not be changed solely to report project throttling.
+
+#### Scenario: Generic API throttle behavior is unchanged
+
+Given API request throttling is enabled
+When non-event API requests are made
+Then existing generic API request throttle behavior must remain unchanged.
+
+#### Scenario: Existing client API keys continue to authenticate
+
+Given an existing project API key is used for event submission and the project has no configured event budget
+When an event is submitted
+Then authentication and authorization behavior must match existing behavior.
+
+### Requirement: Rate-limit headers MUST NOT be repurposed for project monthly controls
+
+Existing generic API throttle response headers MUST NOT be redefined to mean project monthly event budgets or smart project throttling.
+
+#### Scenario: Generic API throttle headers remain request-rate headers
+
+Given generic API throttling emits request-rate headers
+When usage budget controls are added
+Then those headers must continue to represent generic API request throttling behavior.
+
+### Requirement: Organization API exposes budget alert settings
+
+The organization API SHALL expose and support updates to budget alert settings as an additive organization field.
+
+#### Scenario: Organization response includes budget alert settings
+
+Given an organization has budget alert settings
+When the organization is returned from the API
+Then the response must include budget_alert_settings.
+
+#### Scenario: Existing organization response remains compatible
+
+Given an existing organization has no budget alert settings
+When the organization is returned from the API
+Then budget_alert_settings may be null and existing fields must remain unchanged.
+
+#### Scenario: Authorized user updates budget alert settings
+
+Given a user is authorized to update an organization
+When the user updates budget alert settings with valid thresholds
+Then the API must persist the settings and include them in the response.
+
+#### Scenario: Invalid budget alert settings rejected
+
+Given a user is authorized to update an organization
+When the user submits invalid budget alert settings
+Then the API must reject the request with a validation error.
+
+### Requirement: Budget alert emails are asynchronous side effects
+
+Budget alert emails are side effects of accepted usage threshold crossing and MUST not change event submission success responses.
+
+#### Scenario: Event crosses budget alert threshold
+
+Given budget alerts are enabled and an accepted event causes usage to cross a threshold
+When the event submission completes
+Then the event submission response must remain the normal accepted response.
+
+#### Scenario: Budget alert failure does not reject event
+
+Given budget alerts are enabled and budget alert queuing fails
+When an event is submitted
+Then the event must not be rejected solely because budget alert queuing failed.
+
+### Requirement: Project API accepts event budget configuration
+
+The project update API SHALL accept an optional project event budget configuration as an additive project field.
+
+#### Scenario: Clear project event budget
+
+Given an authorized user can update a project
+When the user patches the project with ingest_limit set to null
+Then the project event budget must be cleared.
+
+#### Scenario: Set fixed project event budget
+
+Given an authorized user can update a project
+When the user patches the project with a fixed positive ingest_limit
+Then the project must persist the fixed event budget.
+
+#### Scenario: Set percentage project event budget
+
+Given an authorized user can update a project and the organization has finite allowance
+When the user patches the project with a valid percentage event budget
+Then the project must persist the percentage event budget.
+
+#### Scenario: Invalid fixed limit is rejected
+
+Given an authorized user can update a project
+When the user patches the project with a fixed event budget less than or equal to 0
+Then the API must reject the request with a validation error.
+
+#### Scenario: Invalid percentage limit is rejected
+
+Given an authorized user can update a project
+When the user patches the project with a percentage event budget less than or equal to 0 or greater than 100
+Then the API must reject the request with a validation error.
+
+### Requirement: Project response MUST include budget and throttling state
+
+Project responses used by the UI MUST expose the configured project event budget, currently effective cap, and smart throttling state where available.
+
+#### Scenario: Project has no event budget
+
+Given a project has no configured event budget
+When the project is returned from the API
+Then ingest_limit must be null and effective_ingest_limit must be null.
+
+#### Scenario: Project has fixed event budget
+
+Given a project has a fixed event budget
+When the project is returned from the API
+Then effective_ingest_limit must contain the currently effective cap.
+
+#### Scenario: Project is smart-throttled
+
+Given a project is currently under smart throttling
+When the project is returned from the API
+Then the response should indicate smart throttling state where feasible.
+
+### Requirement: Nullable complex PATCH contracts MUST be generated canonically
+
+Organization and project settings MUST be clearable with JSON null, and their OpenAPI contracts MUST reference the canonical complex component schemas.
+
+#### Scenario: Clear organization budget settings
+
+Given an authorized user can update an organization
+When the user patches budget_alert_settings with null
+Then the settings must be cleared.
+
+#### Scenario: Delta OpenAPI schema
+
+Given a nullable complex property belongs to a Delta PATCH model
+When OpenAPI is generated
+Then the property must be represented as null or a component schema reference
+And generated clients must come from that document rather than manual snapshot edits.
diff --git a/openspec/changes/add-usage-budget-controls/specs/event-ingestion/spec.md b/openspec/changes/add-usage-budget-controls/specs/event-ingestion/spec.md
new file mode 100644
index 0000000000..bef73b6309
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/event-ingestion/spec.md
@@ -0,0 +1,384 @@
+# Spec: Event Ingestion
+
+## ADDED Requirements
+
+### Requirement: Smart throttling works without required user configuration
+
+Exceptionless MUST provide automatic smart project throttling without requiring users to configure per-project or per-stack throttling settings.
+
+#### Scenario: No smart throttling configuration exists
+
+Given an organization has projects
+And no smart throttling settings have been configured
+When one project starts sending a large event spike
+Then Exceptionless should still be able to apply smart throttling automatically.
+
+#### Scenario: UI does not require many throttling options
+
+Given smart throttling is available
+When a user views organization or project usage settings
+Then the UI must not require the user to configure many low-level throttling parameters before smart throttling can protect the organization.
+
+### Requirement: Smart throttling uses remaining allowance and remaining time
+
+Smart throttling MUST calculate allowed throughput using the organization's remaining monthly event allowance and the time remaining in the monthly usage period.
+
+#### Scenario: Organization has substantial allowance remaining late in the month
+
+Given an organization is late in the monthly usage period
+And the organization still has substantial event allowance remaining
+When smart throttling calculates allowed throughput
+Then the calculation must account for remaining event allowance
+And must not rely only on the static monthly plan size divided by the original month duration.
+
+#### Scenario: Organization has little allowance remaining
+
+Given an organization has little event allowance remaining
+When smart throttling calculates allowed throughput
+Then the allowed throughput should decrease to protect the remaining monthly allowance.
+
+### Requirement: Smart throttling isolates noisy projects where possible
+
+When one project is responsible for a usage spike, smart throttling MUST apply to that project where possible rather than fully throttling the entire organization.
+
+#### Scenario: One project spikes
+
+Given an organization has Project A and Project B
+And Project A sends a large event spike
+And Project B remains within normal usage
+When smart throttling is applied
+Then Project A may be throttled or sampled
+And Project B must not be blocked solely because Project A spiked.
+
+#### Scenario: Multiple projects spike
+
+Given an organization has multiple projects
+And more than one project exceeds smart throttling criteria
+When smart throttling is applied
+Then each noisy project may be evaluated and throttled independently.
+
+### Requirement: Smart throttling preserves a sample of events
+
+When a project is smart-throttled and the organization still has remaining monthly allowance, Exceptionless MUST continue accepting a small sample of events for that project.
+
+#### Scenario: Project is throttled but organization has allowance
+
+Given an organization has remaining monthly event allowance
+And a project is under smart throttling
+When events are submitted for that project
+Then Exceptionless must accept a small sample of events
+And must block or discard the remainder according to usage accounting rules.
+
+#### Scenario: Sample rate remains small
+
+Given a project is under smart throttling
+When the accepted sample is calculated
+Then the accepted sample should be within the intended 1 to 5 percent range
+Unless a lower organization or project hard limit leaves fewer events available.
+
+#### Scenario: Organization allowance exhausted
+
+Given an organization has no remaining monthly event allowance
+And a project is under smart throttling
+When events are submitted for that project
+Then existing organization overage behavior must apply
+And smart throttling must not allow sampled events beyond the organization hard allowance.
+
+### Requirement: Smart throttling operates after event posts are parsed
+
+Smart project throttling MUST be evaluated in a processing path that knows the number of events in the post so it can accept a sample and block the remainder.
+
+#### Scenario: Batch contains more events than allowed
+
+Given a queued event post contains many events
+And smart throttling allows only a sample
+When the event post is processed
+Then the processor must process only the sampled/allowed events
+And must record blocked usage for the rest.
+
+#### Scenario: Full request rejection would prevent sampling
+
+Given an event post would otherwise be rejected entirely by project-level throttling
+When the organization still has remaining allowance
+Then the system should prefer sampled processing over full request rejection.
+
+### Requirement: Smart throttling sends project throttling notification
+
+When smart throttling is applied to a project, Exceptionless MUST send an email notification to eligible organization users.
+
+#### Scenario: Project enters smart-throttled state
+
+Given a project was not previously smart-throttled
+And smart throttling is applied to the project
+When notification processing runs
+Then eligible organization users must receive a project throttling notification email.
+
+#### Scenario: Project remains smart-throttled
+
+Given a project is already smart-throttled
+When additional event posts are processed while the project remains throttled
+Then Exceptionless must not send duplicate throttling emails for every post.
+
+#### Scenario: User is not email-eligible
+
+Given a user belongs to the organization
+And the user does not have a verified email address or has email notifications disabled
+When a project throttling notification is sent
+Then that user must not receive the email.
+
+### Requirement: Smart throttling usage accounting remains accurate
+
+Smart throttling MUST record accepted, blocked, and discarded event counts consistently with existing usage accounting.
+
+#### Scenario: Sampled events accepted
+
+Given a project is smart-throttled
+When a sample of events is accepted
+Then accepted organization and project usage must increase by the number of processed events.
+
+#### Scenario: Non-sampled events blocked
+
+Given a project is smart-throttled
+When some events in a post are not accepted due to throttling
+Then blocked usage must increase by the number of non-accepted events.
+
+#### Scenario: Budget alerts use accepted events only
+
+Given budget alerts are enabled and a project is smart-throttled
+When non-sampled events are blocked
+Then blocked events must not count as accepted usage for organization budget alert thresholds.
+
+### Requirement: Smart throttling does not replace explicit project budgets
+
+Automatic smart throttling MUST coexist with optional project event budgets.
+
+#### Scenario: Project has no explicit budget
+
+Given a project has no configured project event budget
+When the project spikes
+Then automatic smart throttling may still apply.
+
+#### Scenario: Project has explicit budget
+
+Given a project has an explicit project event budget and automatic smart throttling also applies
+When events are processed
+Then the number of events accepted must not exceed the lowest applicable allowance from organization hard limit, project budget, and smart throttling sample.
+
+### Requirement: Projects MUST be able to define optional event budgets
+
+Exceptionless projects MUST be able to define an optional project-level event budget that caps or limits the number of accepted events for that project within the current monthly usage period.
+
+#### Scenario: Project has no event budget
+
+Given a project has no configured event budget and the organization has remaining event allowance
+When an event is submitted for the project
+Then the explicit project event budget must not block the event
+And existing organization-level usage enforcement and automatic smart throttling must apply.
+
+#### Scenario: Existing projects remain uncapped
+
+Given a project existed before project event budgets were introduced
+When the project is loaded
+Then its project event budget must be treated as unset.
+
+### Requirement: Fixed project event budgets MUST cap accepted project events
+
+A fixed project event budget MUST cap accepted event volume for a project to a configured positive integer for the current monthly usage period.
+
+#### Scenario: Fixed project budget allows events below cap
+
+Given an organization has remaining event allowance and a project has a fixed event budget of 20000 events
+And the project has accepted fewer than 20000 events in the current monthly usage period
+When an event is submitted for the project
+Then the event must not be blocked by the explicit project event budget.
+
+#### Scenario: Fixed project budget limits events at cap
+
+Given an organization has remaining event allowance and a project has a fixed event budget of 20000 events
+And the project has accepted 20000 events in the current monthly usage period
+When events are submitted for the project
+Then accepted events for that project must be limited by the project event budget
+And blocked usage must be recorded for non-accepted events.
+
+#### Scenario: Fixed project budget above organization allowance is clamped
+
+Given an organization has a finite monthly event allowance of 10000 events
+And a project has a fixed event budget of 20000 events
+When the effective project event budget is evaluated
+Then the effective project event budget must be 10000 events.
+
+#### Scenario: Fixed project budget on unlimited organization
+
+Given an organization has unlimited event allowance and a project has a fixed event budget of 20000 events
+When the effective project event budget is evaluated
+Then the effective project event budget must be 20000 events.
+
+### Requirement: Percentage project event budgets MUST derive from organization allowance
+
+A percentage project event budget MUST cap accepted event volume for a project to a percentage of the organization's current finite monthly event allowance.
+
+#### Scenario: Percentage project budget computes effective cap
+
+Given an organization has a finite monthly event allowance of 100000 events
+And a project has a percentage event budget of 20 percent
+When the effective project event budget is evaluated
+Then the effective project event budget must be 20000 events.
+
+#### Scenario: Percentage project budget on unlimited organization is inactive
+
+Given an organization has unlimited event allowance and a project has a percentage event budget
+When the effective project event budget is evaluated
+Then the percentage project event budget must not produce an effective project cap.
+
+### Requirement: Project event budgets MUST be caps, not reservations
+
+Project event budgets MUST prevent a project from exceeding its cap but MUST not reserve organization event allowance for other projects.
+
+#### Scenario: Unused project budget does not reserve events
+
+Given an organization has a monthly event allowance of 100000 events
+And Project A has a percentage event budget of 20 percent and uses 0 events
+When Project B submits events
+Then Project B must not be blocked solely because Project A has unused project budget.
+
+#### Scenario: Project budget does not increase organization allowance
+
+Given an organization has no remaining event allowance and a project has remaining project event budget
+When an event is submitted for the project
+Then the event must be rejected due to organization overage.
+
+### Requirement: Project event budget exhaustion MUST limit only the capped project
+
+When one project reaches its project event budget, other projects in the same organization MUST continue to be evaluated independently.
+
+#### Scenario: One capped project does not block another project
+
+Given an organization has remaining event allowance
+And Project A has reached its project event budget and Project B has no project event budget
+When an event is submitted for Project B
+Then the event must not be blocked because Project A reached its budget.
+
+#### Scenario: Multiple projects have independent budgets
+
+Given an organization has remaining event allowance
+And Project A has a fixed event budget of 1000 events and Project B has a fixed event budget of 2000 events
+When Project A reaches 1000 accepted events
+Then Project A must be limited by its project event budget
+And Project B must continue to be evaluated against its own 2000-event budget.
+
+### Requirement: Organization overage MUST remain the hard outer limit
+
+Organization-level event allowance MUST remain the hard billing/usage boundary.
+
+#### Scenario: Organization overage takes precedence
+
+Given an organization has no remaining event allowance and a project has remaining project event budget
+When an event is submitted for the project
+Then the event must be rejected due to organization overage.
+
+### Requirement: Project ingest controls MUST reuse existing usage accounting
+
+Project budget and smart throttling enforcement MUST use existing project usage counters.
+
+#### Scenario: Accepted event increments project usage
+
+Given an organization has remaining event allowance and a project has remaining project event budget
+When an event is accepted for the project
+Then existing project accepted event usage must be incremented.
+
+#### Scenario: Blocked event does not count as accepted project usage
+
+Given a project has reached its project event budget
+When an event is submitted for the project
+Then accepted project usage must not increase for non-accepted events
+And blocked usage must be recorded.
+
+### Requirement: Project controls MUST support safe defaults on failure
+
+Project budget and smart throttling evaluation MUST avoid introducing new ingestion failures when project data is missing or invalid.
+
+#### Scenario: Missing project does not cause project-budget rejection
+
+Given an event submission has an organization id and the project cannot be loaded
+When project controls are evaluated
+Then the system must not reject the event solely due to project budget evaluation.
+
+#### Scenario: Invalid persisted project budget is treated as inactive
+
+Given a project has an invalid persisted event budget configuration
+When event ingestion evaluates project controls
+Then the invalid project budget must be treated as inactive.
+
+### Requirement: Project ingest controls MUST prefer sampled processing over full request rejection
+
+Project-level ingest controls MUST preserve sampled visibility where possible.
+
+#### Scenario: Queued event post contains many project events
+
+Given an event post has been queued and the project is over its smart throttling allowance
+And the organization still has remaining allowance
+When the event post is processed
+Then the job should process an allowed sample and record blocked usage for non-sampled events.
+
+#### Scenario: Middleware cannot sample project events
+
+Given a project-level condition would require preserving only 1 to 5 percent of events
+When the request is still in middleware before parsing
+Then middleware must not be the only enforcement layer.
+
+### Requirement: Smart throttling MUST use stable five-percent sampling
+
+Automatic project throttling MUST select events with a stable five-percent hash sample across the complete parsed post.
+
+#### Scenario: Single-event post is genuinely sampled
+
+Given a project is smart-throttled and the organization has remaining allowance
+When repeated single-event posts with stable distinct identities are processed
+Then approximately five percent must be accepted over time
+And no per-post minimum may force every single event through.
+
+#### Scenario: Nonaccepted events are counted once
+
+Given organization allowance, explicit project budget, and smart sampling are evaluated for one parsed post
+When the final accepted set is selected
+Then every event outside that set must increment blocked usage exactly once
+And those events must not also increment discarded usage.
+
+### Requirement: Smart throttling MUST be cheap and operationally disableable
+
+Automatic project throttling MUST use bucket-inclusive totals, five-minute remaining windows, the existing ten-times burst tolerance, and current noisy-project fair share.
+
+#### Scenario: Normal unlimited traffic avoids extra work
+
+Given an organization has unlimited allowance and the project has no explicit cap
+When ingestion evaluates the already-loaded organization and project
+Then it must not reload either model or query the organization project count.
+
+#### Scenario: Kill switch is disabled
+
+Given EnableSmartProjectThrottling is false
+When a noisy project submits events
+Then automatic sampling must be bypassed
+And explicit project and organization limits must remain enforced.
+
+### Requirement: Completed reservations MUST preserve failed event retries
+
+A completed reservation MUST retain the original indexes of retryable failed events until each retry has been queued. Recovery MUST skip events already counted as processed. Legacy completed records without retry metadata MUST be treated as having no pending retries.
+
+#### Scenario: Completion side effect fails for a mixed batch
+
+Given a batch contains one processed event and one retryable failure
+When a cache operation fails after the reservation commits
+Then redelivery queues only the failed event and does not increment accepted usage for the processed event again.
+
+#### Scenario: Retry dispatch partially succeeds
+
+Given a completed reservation contains multiple failed event indexes
+When one retry is queued and acknowledged but the next enqueue fails
+Then redelivery dispatches only the unacknowledged indexes.
+
+#### Scenario: Enqueue succeeds but acknowledgement fails
+
+Given a failed event has been queued for retry
+When acknowledgement cannot be persisted
+Then the event remains pending for at-least-once delivery and may be queued again, while processed events in the original batch remain completed.
diff --git a/openspec/changes/add-usage-budget-controls/specs/jobs-notifications-and-queues/spec.md b/openspec/changes/add-usage-budget-controls/specs/jobs-notifications-and-queues/spec.md
new file mode 100644
index 0000000000..1ec1a1d5f9
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/jobs-notifications-and-queues/spec.md
@@ -0,0 +1,216 @@
+# Spec: Jobs, Notifications & Queues
+
+## ADDED Requirements
+
+### Requirement: Organizations may configure budget alert thresholds
+
+Organizations SHALL be able to configure event budget alert thresholds as percentages of their effective monthly event allowance. Budget alerts are disabled by default.
+
+#### Scenario: Existing organization has no budget alerts
+
+Given an organization existed before budget alerts were introduced
+When the organization is loaded
+Then budget alerts must be treated as disabled.
+
+#### Scenario: Enable budget alerts with thresholds
+
+Given an authorized user can update an organization
+When the user enables budget alerts with thresholds 50 and 80
+Then the organization must store budget alert settings as enabled with thresholds 50 and 80.
+
+#### Scenario: Disable budget alerts
+
+Given an organization has enabled budget alerts
+When an authorized user disables budget alerts
+Then budget alert emails must no longer be sent for that organization.
+
+### Requirement: Budget alert thresholds validate percentage values
+
+Budget alert threshold percentages MUST be valid pre-overage warning thresholds.
+
+#### Scenario: Reject zero threshold
+
+Given an authorized user can update budget alert settings
+When the user configures threshold 0
+Then the API must reject the request with a validation error.
+
+#### Scenario: Reject threshold at or above one hundred percent
+
+Given an authorized user can update budget alert settings
+When the user configures threshold 100 or above
+Then the API must reject the request with a validation error.
+
+#### Scenario: Enabled alerts require at least one threshold
+
+Given an authorized user can update budget alert settings
+When the user enables budget alerts with no thresholds
+Then the API must reject the request with a validation error.
+
+### Requirement: Budget alerts use effective organization allowance
+
+Budget alert thresholds MUST be evaluated against the same effective organization event allowance used by existing usage enforcement.
+
+#### Scenario: Threshold uses plan allowance
+
+Given an organization has a monthly event allowance of 100000
+And budget alerts are enabled for threshold 50
+When the threshold event count is calculated
+Then the threshold event count must be 50000.
+
+#### Scenario: Unlimited organization has no percentage budget alert
+
+Given an organization has unlimited event allowance
+When budget alert thresholds are evaluated
+Then percentage budget alerts must be inactive and no budget alert email must be sent.
+
+### Requirement: Budget alerts send when accepted usage crosses thresholds
+
+Budget alert emails MUST be triggered when accepted organization event usage crosses a configured threshold for the first time in a monthly usage period.
+
+#### Scenario: Usage below threshold does not send alert
+
+Given an organization has a monthly event allowance of 100000
+And budget alerts are enabled for threshold 50 and accepted event usage is 49998
+When one event is accepted
+Then no budget alert email must be sent.
+
+#### Scenario: Usage crossing threshold sends alert
+
+Given an organization has a monthly event allowance of 100000
+And budget alerts are enabled for threshold 50 and accepted event usage is 49999
+When one event is accepted
+Then a 50 percent budget alert email must be queued.
+
+#### Scenario: Usage already above threshold does not resend alert
+
+Given the 50 percent alert has already been sent in the current monthly usage period
+When another event is accepted
+Then another 50 percent budget alert email must not be queued.
+
+#### Scenario: Large batch crosses multiple thresholds
+
+Given budget alerts are enabled for thresholds 50 and 80 and accepted event usage is 45000
+When a batch of 40000 events is accepted
+Then both the 50 percent and 80 percent budget alert emails must be queued.
+
+### Requirement: Budget alert emails are sent once per threshold per monthly usage period
+
+Each configured threshold MUST generate no more than one budget alert email per organization per monthly usage period.
+
+#### Scenario: Threshold already sent in period
+
+Given the 80 percent alert was sent earlier in the current monthly usage period
+When usage remains above 80 percent
+Then no additional 80 percent budget alert email must be sent.
+
+#### Scenario: New monthly period resets sent threshold state
+
+Given an organization received an 80 percent alert in the previous monthly usage period
+When usage crosses 80 percent in the new period
+Then a new 80 percent budget alert email may be sent.
+
+### Requirement: Budget alert emails use organization email notification eligibility
+
+Budget alert emails MUST be sent only to organization users who are eligible for existing organization email notices.
+
+#### Scenario: Verified user with email notifications enabled receives alert
+
+Given a user belongs to an organization with a verified email and email notifications enabled
+When a budget alert is sent for the organization
+Then the user must receive the budget alert email.
+
+#### Scenario: Unverified user does not receive alert
+
+Given a user belongs to an organization and does not have a verified email address
+When a budget alert is sent for the organization
+Then the user must not receive the budget alert email.
+
+### Requirement: Budget alerts do not block ingestion
+
+Budget alert processing MUST not block accepted event ingestion.
+
+#### Scenario: Alert email enqueue fails
+
+Given budget alerts are enabled and usage crosses a configured threshold
+When the budget alert email cannot be queued
+Then the accepted event must not be rejected solely because the alert email failed.
+
+### Requirement: Budget alerts preserve existing overage notifications
+
+Budget alerts MUST not replace or suppress existing monthly/hourly overage notifications.
+
+#### Scenario: Existing monthly overage still sends
+
+Given an organization reaches or exceeds its monthly event allowance
+When existing monthly overage notification behavior is triggered
+Then the existing monthly overage email must still be sent.
+
+### Requirement: Budget alert emails are separate from smart throttling emails
+
+Organization budget alerts and project smart throttling notifications MUST be distinct notifications.
+
+#### Scenario: Project throttling below budget threshold
+
+Given organization budget alerts are enabled and accepted usage has not crossed a threshold
+When a project enters smart-throttled state
+Then no organization budget threshold email must be sent solely because smart throttling was applied.
+
+### Requirement: Smart throttling MUST send project throttling notification email
+
+When smart throttling is applied to a project, Exceptionless MUST send an email notification to eligible organization users.
+
+#### Scenario: Project enters smart-throttled state
+
+Given a project was not previously smart-throttled and smart throttling is applied
+When notification processing runs
+Then eligible organization users must receive a project throttling notification email.
+
+#### Scenario: Project remains smart-throttled
+
+Given a project is already smart-throttled
+When additional event posts are processed
+Then Exceptionless must not send duplicate throttling emails for every post.
+
+#### Scenario: User is not email-eligible
+
+Given a user belongs to the organization and does not have a verified email or has notifications disabled
+When a project throttling notification is sent
+Then that user must not receive the email.
+
+### Requirement: Budget alert crossings MUST be current and atomically deduplicated
+
+Budget alert publication MUST compare bucket-inclusive previous/current accepted totals and atomically claim each organization-threshold-period key.
+
+#### Scenario: Concurrent crossing
+
+Given concurrent accepted batches cross the same configured threshold
+When each publisher attempts AddAsync for the dedupe key
+Then only the successful claimant may publish the alert.
+
+#### Scenario: Alerts enabled above threshold
+
+Given accepted usage already exceeds a threshold while alerts are disabled
+When an authorized user enables that threshold
+Then it must be evaluated once immediately after settings are saved.
+
+#### Scenario: Invalid disabled threshold
+
+Given budget alert settings exist but are disabled
+When a threshold is outside 1 through 99
+Then validation must reject the settings.
+
+### Requirement: Delayed usage notifications MUST suppress stale mail
+
+Notification handlers MUST re-check current persisted settings, plan, bucket-inclusive usage, and throttle state before sending.
+
+#### Scenario: Budget alert becomes stale
+
+Given a budget alert work item is queued
+When the threshold is removed, alerts are disabled, usage is below the current threshold count, or the plan becomes unlimited before handling
+Then the handler must not send the email.
+
+#### Scenario: Smart throttle becomes stale
+
+Given a smart-throttle work item is queued
+When the operational kill switch is disabled or the project's current throttle state expires before handling
+Then the handler must not send the email.
diff --git a/openspec/changes/add-usage-budget-controls/specs/organizations-projects-users-auth/spec.md b/openspec/changes/add-usage-budget-controls/specs/organizations-projects-users-auth/spec.md
new file mode 100644
index 0000000000..592dfe96f0
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/organizations-projects-users-auth/spec.md
@@ -0,0 +1,107 @@
+# Spec: Organizations, Projects, Users & Auth
+
+## ADDED Requirements
+
+### Requirement: Budget alert settings belong to an organization
+
+Budget alert settings belong to an organization. The API MUST allow changes only by users authorized to update that organization.
+
+#### Scenario: Authorized organization user updates budget alerts
+
+Given a user is authorized to update an organization
+When the user updates budget alert settings
+Then the update must be allowed if the payload is valid.
+
+#### Scenario: Unauthorized user cannot update budget alerts
+
+Given a user is not authorized to update an organization
+When the user attempts to update budget alert settings
+Then the API must reject the operation according to existing organization authorization behavior.
+
+### Requirement: Budget alert email recipients respect user preferences
+
+Budget alert email recipients MUST respect existing user email verification and email notification preferences.
+
+#### Scenario: User email notifications disabled
+
+Given a user belongs to an organization and has email notifications disabled
+When a budget alert is sent
+Then the user must not receive the budget alert email.
+
+#### Scenario: User email unverified
+
+Given a user belongs to an organization and the user's email address is not verified
+When a budget alert is sent
+Then the user must not receive the budget alert email.
+
+#### Scenario: Verified user with email notifications enabled
+
+Given a user belongs to an organization with a verified email and notifications enabled
+When a budget alert is sent
+Then the user may receive the budget alert email.
+
+### Requirement: Project event budget authorization follows project authorization
+
+A project event budget belongs to a project and is scoped by the project's owning organization. The API MUST allow event budget configuration only by users authorized to update the project.
+
+#### Scenario: Authorized project user updates project event budget
+
+Given a user is authorized to update a project
+When the user updates the project's event budget
+Then the update must be allowed if the payload is valid.
+
+#### Scenario: Unauthorized user cannot update project event budget
+
+Given a user is not authorized to update a project
+When the user attempts to update the project's event budget
+Then the API must reject the operation according to existing project authorization behavior.
+
+#### Scenario: Project event budget cannot grant organization capacity
+
+Given a user configures a project event budget
+When events are submitted for the project
+Then the project event budget must not allow accepted event usage beyond the organization's effective allowance.
+
+### Requirement: Budget controls preserve existing token and auth behavior
+
+Budget alert settings, smart project throttling, and project event budget configuration MUST not change API key authentication, token scopes, or user authorization roles.
+
+#### Scenario: Existing project token behavior is preserved
+
+Given an existing project API key has client scope and the project has no configured event budget
+When the key is used for event submission
+Then token authentication and scope behavior must match existing behavior.
+
+#### Scenario: Project smart throttling does not disable API key
+
+Given a project is under smart throttling
+When a project API key is used for a non-ingest API route it is authorized to access
+Then the API key must not be considered disabled solely because the project is smart-throttled.
+
+#### Scenario: Project budget does not disable API key
+
+Given a project reaches its project event budget
+When a project API key is used for a non-ingest API route it is authorized to access
+Then the API key must not be considered disabled solely because the project reached its event budget.
+
+#### Scenario: Disabled or suspended token remains rejected
+
+Given a project has remaining project event budget and the API key is disabled or suspended
+When an event is submitted with that API key
+Then the event must still be rejected due to token authentication state.
+
+### Requirement: Project event budget MUST NOT preclude future token-level caps
+
+Project event budget and smart throttling behavior MUST NOT preclude future API-key/token-level ingest caps.
+
+#### Scenario: Future token cap is absent
+
+Given token-level ingest caps are not implemented
+When a project event budget or smart throttling is evaluated
+Then enforcement must consider organization and project scopes only.
+
+#### Scenario: Project budget remains independent of token count
+
+Given a project has multiple API keys and a configured project event budget
+When events are submitted using different API keys for that project
+Then all accepted events for the project must count against the same project event budget.
diff --git a/openspec/changes/add-usage-budget-controls/tasks.md b/openspec/changes/add-usage-budget-controls/tasks.md
new file mode 100644
index 0000000000..d63e599416
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/tasks.md
@@ -0,0 +1,368 @@
+# Tasks: Add Usage Budget Controls
+
+## OpenSpec
+
+- [x] 1. Create OpenSpec change
+    * Create proposal, design, tasks, and spec deltas for:
+        * organization budget alerts
+        * automatic smart project throttling
+        * project event budgets
+        * API compatibility
+        * organization/project auth behavior
+    * Verification:
+        * openspec validate add-usage-budget-controls --strict --no-interactive
+
+## Backend model and API contract
+
+- [x] 2. Add organization budget alert settings model
+    * Add OrganizationBudgetAlertSettings.
+    * Add nullable BudgetAlertSettings to Organization.
+    * Validate every present threshold as 1-99 even while disabled; enabled settings require at least one threshold.
+    * Verification:
+        * dotnet build
+        * Add model/validation tests if existing model validation tests are available.
+- [x] 3. Add budget alert settings to organization API contract
+    * Add BudgetAlertSettings to ViewOrganization.
+    * Prefer adding UpdateOrganization with Name and BudgetAlertSettings.
+    * Update OrganizationController generic update DTO if using UpdateOrganization.
+    * Regenerate generated API and Svelte schemas.
+    * Verification:
+        * dotnet build
+        * dotnet test -- --filter-class OrganizationControllerTests
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+- [x] 4. Add project event budget domain model
+    * Add ProjectIngestLimit and ProjectIngestLimitType under src/Exceptionless.Core/Models/.
+    * Add nullable Project.IngestLimit.
+    * Add validation for fixed and percentage modes.
+    * Verification:
+        * dotnet build
+        * Add/adjust serializer tests if project model serialization coverage exists.
+- [x] 5. Add project event budget to project DTOs
+    * Add ProjectIngestLimit? IngestLimit to UpdateProject.
+    * Add ProjectIngestLimit? IngestLimit to ViewProject.
+    * Add int? EffectiveIngestLimit to ViewProject.
+    * Add smart throttling state fields to ViewProject if feasible:
+        * bool IsSmartThrottled
+        * double? SmartThrottleSampleRate
+    * Ensure Mapperly maps the new fields or add explicit mapping if required.
+    * Verification:
+        * dotnet build
+        * dotnet test -- --filter-class ProjectControllerTests
+- [x] 6. Regenerate OpenAPI and Svelte generated types
+    * Regenerate src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts.
+    * Regenerate src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts.
+    * Confirm UpdateOrganization, ViewOrganization, UpdateProject, ViewProject, and validation schemas include new fields.
+    * Generate nullable complex Delta properties as `null | $ref` from the canonical transformer and add regression coverage.
+    * Verification:
+        * dotnet build
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+
+## Organization budget alert emails
+
+- [x] 7. Add budget alert threshold calculation
+    * Use the same effective organization allowance as existing usage enforcement.
+    * Support configured percentage thresholds from 1 through 99.
+    * Treat thresholds as inactive for unlimited organizations.
+    * Verification:
+        * Add tests to UsageServiceTests.
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 8. Publish budget alert messages when thresholds are crossed
+    * Add OrganizationBudgetAlert message.
+    * In UsageService.IncrementTotalAsync, detect threshold crossings after accepted event usage increments.
+    * Compare bucket-inclusive previous/current totals and immediately evaluate newly enabled thresholds after settings save.
+    * Publish one message per crossed threshold.
+    * Do not publish repeatedly after threshold was already sent in the current monthly usage period.
+    * Verification:
+        * Tests:
+            * below threshold does not publish
+            * crossing threshold publishes
+            * already-sent threshold does not publish
+            * batch crossing multiple thresholds publishes each crossed threshold
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 9. Add budget alert dedupe
+    * Add dedupe key per organization, threshold, and monthly usage period.
+    * Atomically claim each key with `AddAsync` and set TTL through the end of the monthly usage period plus a safety buffer.
+    * Prefer non-blocking behavior if dedupe cache fails.
+    * Verification:
+        * Add tests for one-email-per-threshold-per-period behavior.
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 10. Add budget alert work item and subscriber
+    * Add OrganizationBudgetAlertWorkItem.
+    * Add startup subscriber that turns OrganizationBudgetAlert messages into work items.
+    * Add work item handler that loads organization/users and sends emails.
+    * Re-check current organization budget alert settings before sending.
+    * Re-check current usage and effective plan allowance before sending stale queued work.
+    * Verification:
+        * dotnet test -- --filter-class OrganizationBudgetAlertWorkItemHandlerTests
+        * If no dedicated handler test class exists, add one.
+- [x] 11. Add budget alert mailer method and template
+    * Add IMailer.SendOrganizationBudgetAlertAsync.
+    * Implement the method in Mailer.
+    * Add organization-budget-alert.html template.
+    * Include current usage, threshold percentage, threshold event count, event limit, remaining events, and links to organization usage/billing.
+    * Verification:
+        * Mailer/template rendering test if existing template tests exist.
+        * dotnet build
+
+## Automatic Smart Project Throttling
+
+- [x] 12. Add smart throughput calculation
+    * Calculate allowed throughput from events left in the monthly period and time/windows left in the period.
+    * Use five-minute windows and preserve the existing 10x burst tolerance.
+    * Avoid static plan-size-only calculations.
+    * Verification:
+        * Tests for early-month, late-month, high-remaining, and low-remaining allowance cases.
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 13. Add project-level smart throttling decision
+    * Detect projects contributing to usage spikes.
+    * Apply smart throttling to noisy projects where possible instead of organization-wide full blocking.
+    * Use the canonically invalidated repository project-count cache only after spike criteria require fair-share evaluation.
+    * Add `EnableSmartProjectThrottling`, default enabled, as an operational kill switch.
+    * Verification:
+        * Tests where Project A spikes and Project B remains unaffected.
+        * Tests where multiple projects are evaluated independently.
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 14. Add sampled acceptance for smart-throttled projects
+    * Implement fixed 5% stable hash sampling across the whole batch, including true sampling of single-event posts.
+    * Count every nonaccepted event exactly once as blocked, never again as discarded.
+    * Verification:
+        * Tests for sampled acceptance count.
+        * Tests that blocked usage increments for non-sampled events.
+        * Tests that accepted usage increments only for sampled events.
+        * dotnet test -- --filter-class EventPostsJobTests
+- [x] 15. Move project-level sampled enforcement into event post processing
+    * Extend EventPostsJob / UsageService after event post parsing to calculate allowed events.
+    * Avoid using only OverageMiddleware for project-level sampled enforcement.
+    * Preserve existing organization hard overage middleware behavior.
+    * Verification:
+        * Tests for batch event posts where only a sample is processed.
+        * Tests for organization hard overage still blocking.
+        * dotnet test -- --filter-class EventPostsJobTests
+        * dotnet test -- --filter-class OverageMiddlewareTests
+- [x] 16. Add smart throttling notification message/work item/email
+    * Add project throttling notification message.
+    * Add work item and handler.
+    * Add mailer method and template.
+    * Send to verified users with email notifications enabled.
+    * Deduplicate notifications during a throttling cooldown window.
+    * Re-check current plan, usage, and throttle state before sending; email fields describe project usage and fair-share limits.
+    * Add a dedicated smart-throttled event metric and transition-only structured logging.
+    * Verification:
+        * dotnet test -- --filter-class ProjectSmartThrottleNotificationWorkItemHandlerTests
+        * dotnet build
+
+## Optional project event budgets
+
+- [x] 17. Refactor UsageService events-left calculation
+    * Make one allowance decision from the organization/project models already loaded by EventPostsJob.
+    * Bulk-read bucket-inclusive organization/project totals using existing project-aware cache key helpers.
+    * Preserve current organization behavior.
+    * Verification:
+        * Add tests for organization-only events-left behavior to ensure no regression.
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 18. Add project effective budget calculation
+    * Implement effective fixed budget calculation.
+    * Implement effective percentage budget calculation.
+    * Clamp fixed budgets to finite organization allowance during enforcement.
+    * Treat percentage budgets as inactive when organization allowance is unlimited.
+    * Verification:
+        * dotnet test -- --filter-class UsageServiceTests
+- [x] 19. Add parsed-event ingest allowance result
+    * Add EventIngestAllowanceResult.
+    * Add UsageService.GetEventIngestAllowanceAsync(Organization organization, Project project) or equivalent without repository reloads.
+    * Return event count allowed, organization remaining, project remaining, effective project budget, and smart throttling state.
+    * Verification:
+        * Tests:
+            * no project id or missing project falls back safely
+            * no project budget uses organization + smart throttling
+            * fixed budget limits allowed event count
+            * percentage budget computes effective cap from organization allowance
+            * organization overage takes precedence over project controls
+            * smart throttling sample and project budget combine by taking the minimum allowed count
+        * dotnet test -- --filter-class UsageServiceTests
+
+## Middleware and event processing
+
+- [x] 20. Keep OverageMiddleware as coarse gate
+    * Preserve existing status codes for organization overage, disabled submission, missing content length, oversized posts, and unauthorized organization context.
+    * Do not implement sampled project enforcement only in middleware.
+    * Verification:
+        * dotnet test -- --filter-class OverageMiddlewareTests
+- [x] 21. Update EventPostsJob for sampled/project-budget allowance
+    * After parsing events, ask UsageService for allowed event count.
+    * Process only allowed events.
+    * Use deterministic sampling/selection when allowed count is lower than submitted count due to smart throttling.
+    * Increment blocked usage for non-accepted events.
+    * Increment blocked usage once after all applicable controls have selected the final accepted set.
+    * Increment accepted usage only for processed events.
+    * Verification:
+        * dotnet test -- --filter-class EventPostsJobTests
+
+## Backend API tests
+
+- [x] 22. Add OrganizationController tests for budget alert settings
+    * Test enabling budget alerts with thresholds.
+    * Test disabling budget alerts.
+    * Test threshold normalization/deduplication.
+    * Test invalid thresholds reject.
+    * Test unauthorized organization update remains rejected.
+    * Verification:
+        * dotnet test -- --filter-class OrganizationControllerTests
+- [x] 23. Add ProjectController tests for event budget update behavior
+    * Test setting fixed event budget.
+    * Test setting percentage event budget.
+    * Test clearing event budget.
+    * Test invalid fixed budget rejects.
+    * Test invalid percentage rejects.
+    * Test percentage budget rejects for unlimited organization or is marked inactive according to final implementation decision.
+    * Verification:
+        * dotnet test -- --filter-class ProjectControllerTests
+- [x] 24. Add event submission integration tests
+    * Verify event submission processing accepts samples under smart throttling.
+    * Verify organization overage behavior remains unchanged.
+    * Verify uncapped projects continue under the organization limit.
+    * Verify crossing budget alert thresholds does not change accepted event response.
+    * Verification:
+        * dotnet test -- --filter-class EventControllerTests
+        * dotnet test -- --filter-class EventPostsJobTests
+- [x] 25. Update HTTP samples if contracts are changed
+    * Update tests/http/*.http samples for organization update/get if organization request/response examples exist.
+    * Update tests/http/*.http samples for project update/get if project request/response examples exist.
+    * Verification:
+        * Manual review of tests/http/*.http.
+        * dotnet build
+
+## Svelte UI
+
+- [x] 26. Add budget alerts UI to Organization Usage page
+    * Update src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte.
+    * Add card for enabling/disabling budget alerts.
+    * Add threshold editor with default suggestions of 50 and 80.
+    * Use TanStack Form, Zod, existing shadcn components, accessible labels/live errors, and explicit loading/saving states.
+    * Show computed event counts for each threshold.
+    * Disable percentage alerts for unlimited organizations.
+    * Use existing organization API query/mutation patterns.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm run check
+        * cd src/Exceptionless.Web/ClientApp && npm run lint
+        * Manual localhost QA on Organization Settings → Usage.
+- [x] 27. Add project event budget UI component
+    * Create src/Exceptionless.Web/ClientApp/src/lib/features/projects/components/project-ingest-limit-card.svelte.
+    * Support Off, Fixed, and Percentage modes.
+    * Show computed effective cap.
+    * Show current project usage against cap when active.
+    * Show fixed-cap warning when fixed cap exceeds current organization allowance.
+    * Disable percentage mode when organization allowance is unlimited.
+    * Reject truncated fixed-limit decimals and enforce backend-identical fixed/percentage ranges.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+        * cd src/Exceptionless.Web/ClientApp && npm run lint
+- [x] 28. Add smart throttling UI status
+    * Surface project smart-throttled status on Project Usage where feasible.
+    * Explain that a sample of events is still accepted.
+    * Link to organization/project usage.
+    * Avoid exposing many tuning options.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm run check
+        * cd src/Exceptionless.Web/ClientApp && npm run lint
+        * Manual localhost QA with a smart-throttled project.
+- [x] 29. Integrate project card into Project Usage page
+    * Add the card to src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte.
+    * Use existing getProjectQuery, getOrganizationQuery, and updateProject mutation.
+    * Invalidate/update project query data after saving.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm run check
+        * Manual localhost QA on /project/{projectId}/usage
+- [x] 30. Update project usage chart limit/status display
+    * Use effective_ingest_limit as the chart limit when present.
+    * Otherwise preserve existing organization limit behavior.
+    * Label the limit line as Project Limit or Organization Limit.
+    * Show smart throttling status text/badge when active.
+    * Verification:
+        * Manual localhost QA with:
+            * no project budget
+            * fixed project budget
+            * percentage project budget
+            * smart-throttled project
+        * Confirm chart remains readable and accessible.
+- [x] 31. Add frontend tests for budget control helpers
+    * Test organization budget alert threshold normalization.
+    * Test organization budget alert threshold validation.
+    * Test budget alert computed event counts.
+    * Test project budget mode-to-payload conversion.
+    * Test project percentage cap calculation display.
+    * Test fixed cap warning.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm run test:unit
+
+## Compatibility and validation
+
+- [x] 32. Verify existing request throttling remains unchanged
+    * Confirm ThrottlingMiddleware behavior and tests are unchanged unless incidental generated code changes require updates.
+    * Verification:
+        * dotnet test -- --filter-class ThrottlingMiddlewareTests
+- [x] 33. Verify existing overage notification remains unchanged
+    * Confirm existing PlanOverage monthly/hourly paths continue to enqueue and send existing organization notices.
+    * Confirm budget alerts and smart throttling use separate message/work item/template.
+    * Verification:
+        * Existing organization notification tests if present.
+        * New budget alert and smart throttling work item tests.
+- [x] 34. Verify no Elasticsearch mapping/reindex is required
+    * Confirm budget alert settings and project event budget are not used for organization/project search/filter/sort.
+    * Confirm no organization/project index version bump is required.
+    * Verification:
+        * Code review checklist item.
+- [x] 35. Local dogfood budget alerts
+    * Run local stack with aspire run or Exceptionless.AppHost.
+    * Use local QA URL only: http://localhost:7110.
+    * Enable budget alerts for a low threshold.
+    * Submit events until threshold is crossed.
+    * Confirm budget alert work item/email is queued.
+    * Confirm alert does not send twice for same threshold in same monthly period.
+    * Confirm disabling alerts prevents future sends.
+    * Verification:
+        * Manual QA notes in PR.
+- [x] 36. Local dogfood project budgets and smart throttling
+    * Run local stack with aspire run or Exceptionless.AppHost.
+    * Use local QA URL only: http://localhost:7110.
+    * Configure a low fixed budget on a project.
+    * Submit events until budget is reached.
+    * Confirm:
+        * project is limited/sampled
+        * blocked usage increases
+        * another project can still ingest events
+        * clearing the budget restores behavior
+    * Create or simulate a noisy project.
+    * Confirm smart throttling applies without manual configuration.
+    * Confirm a sample is still accepted.
+    * Verification:
+        * Manual QA notes in PR.
+
+## Final validation
+
+- [x] 37. Run targeted validation
+    * Keep budget-specific tests out of UsageServiceTests.cs so the existing file does not grow past 1,000 lines.
+    * Commands:
+        * dotnet build
+        * dotnet test -- --filter-class UsageServiceTests
+        * dotnet test -- --filter-class OverageMiddlewareTests
+        * dotnet test -- --filter-class OrganizationControllerTests
+        * dotnet test -- --filter-class ProjectControllerTests
+        * dotnet test -- --filter-class OrganizationBudgetAlertWorkItemHandlerTests
+        * dotnet test -- --filter-class ProjectSmartThrottleNotificationWorkItemHandlerTests
+        * dotnet test -- --filter-class EventControllerTests
+        * dotnet test -- --filter-class EventPostsJobTests
+        * dotnet test -- --filter-class ThrottlingMiddlewareTests
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+        * cd src/Exceptionless.Web/ClientApp && npm run lint
+        * cd src/Exceptionless.Web/ClientApp && npm run test:unit
+- [x] 38. Run OpenSpec validation
+    * Command:
+        * openspec validate add-usage-budget-controls --strict --no-interactive
+- [x] 39. Run full validation before merge
+    * Commands:
+        * dotnet test
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check && npm run lint && npm run test:unit && npm run build
+        * openspec validate --all --strict --no-interactive
+        * git diff --check
+    * Re-run the thermo-nuclear review against `origin/main...HEAD` and require no structural, hot-path, file-size, or generated-artifact drift blockers.
diff --git a/src/Exceptionless.Core/Bootstrapper.cs b/src/Exceptionless.Core/Bootstrapper.cs
index 0d45dc5823..7e4073d940 100644
--- a/src/Exceptionless.Core/Bootstrapper.cs
+++ b/src/Exceptionless.Core/Bootstrapper.cs
@@ -76,6 +76,7 @@ public static void RegisterServices(IServiceCollection services, AppOptions appO
             ResiliencePolicyProvider = s.GetRequiredService<IResiliencePolicyProvider>(),
             LoggerFactory = s.GetRequiredService<ILoggerFactory>()
         }));
+        services.AddSingleton<IAtomicCacheBatch, InMemoryAtomicCacheBatch>();
 
         services.AddSingleton<ExceptionlessElasticConfiguration>();
         services.AddSingleton<ElasticsearchClient>(s => s.GetRequiredService<ExceptionlessElasticConfiguration>().Client);
@@ -97,6 +98,8 @@ public static void RegisterServices(IServiceCollection services, AppOptions appO
             handlers.Register<ForcePredefinedSavedViewsWorkItem>(s.GetRequiredService<ForcePredefinedSavedViewsWorkItemHandler>);
             handlers.Register<OrganizationMaintenanceWorkItem>(s.GetRequiredService<OrganizationMaintenanceWorkItemHandler>);
             handlers.Register<OrganizationNotificationWorkItem>(s.GetRequiredService<OrganizationNotificationWorkItemHandler>);
+            handlers.Register<OrganizationBudgetAlertWorkItem>(s.GetRequiredService<OrganizationBudgetAlertWorkItemHandler>);
+            handlers.Register<ProjectSmartThrottleWorkItem>(s.GetRequiredService<ProjectSmartThrottleWorkItemHandler>);
             handlers.Register<ProjectMaintenanceWorkItem>(s.GetRequiredService<ProjectMaintenanceWorkItemHandler>);
             handlers.Register<ReindexWorkItem>(s.GetRequiredService<ReindexWorkItemHandler>);
             handlers.Register<RemoveBotEventsWorkItem>(s.GetRequiredService<RemoveBotEventsWorkItemHandler>);
diff --git a/src/Exceptionless.Core/Configuration/AppOptions.cs b/src/Exceptionless.Core/Configuration/AppOptions.cs
index a0528ec823..023f33726b 100644
--- a/src/Exceptionless.Core/Configuration/AppOptions.cs
+++ b/src/Exceptionless.Core/Configuration/AppOptions.cs
@@ -45,6 +45,11 @@ public class AppOptions
 
     public bool EventSubmissionDisabled { get; internal set; }
 
+    /// <summary>
+    /// Operational kill switch for automatic project-level sampling. Explicit project limits are unaffected.
+    /// </summary>
+    public bool EnableSmartProjectThrottling { get; internal set; }
+
     internal List<string> DisabledPipelineActions { get; set; } = null!;
     internal List<string> DisabledPlugins { get; set; } = null!;
 
@@ -106,6 +111,7 @@ public static AppOptions ReadFromConfiguration(IConfiguration config)
         options.EnableArchive = config.GetValue(nameof(options.EnableArchive), false);
         options.EnableSampleData = config.GetValue(nameof(options.EnableSampleData), options.AppMode == AppMode.Development);
         options.EventSubmissionDisabled = config.GetValue(nameof(options.EventSubmissionDisabled), false);
+        options.EnableSmartProjectThrottling = config.GetValue(nameof(options.EnableSmartProjectThrottling), true);
         options.DisabledPipelineActions = config.GetValueList(nameof(options.DisabledPipelineActions));
         options.DisabledPlugins = config.GetValueList(nameof(options.DisabledPlugins));
         options.MaximumEventPostSize = config.GetValue(nameof(options.MaximumEventPostSize), 200000).NormalizeValue();
diff --git a/src/Exceptionless.Core/Jobs/EventPostsJob.cs b/src/Exceptionless.Core/Jobs/EventPostsJob.cs
index 40db24f038..062b727cad 100644
--- a/src/Exceptionless.Core/Jobs/EventPostsJob.cs
+++ b/src/Exceptionless.Core/Jobs/EventPostsJob.cs
@@ -3,6 +3,7 @@
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Pipeline;
 using Exceptionless.Core.Plugins.EventParser;
+using Exceptionless.Core.Plugins.EventProcessor;
 using Exceptionless.Core.Queues.Models;
 using Exceptionless.Core.Repositories;
 using Exceptionless.Core.Services;
@@ -162,49 +163,64 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
             return JobResult.Success;
         }
 
-        // Don't process all the events if it will put the account over its limits.
-        int eventsToProcess = await _usageService.GetEventsLeftAsync(organization.Id);
-        if (eventsToProcess < 1)
+        int submittedEventCount = events.Count;
+        bool isSingleEvent = submittedEventCount == 1;
+        var candidates = events
+            .Select((persistentEvent, index) => new EventIngestCandidate(index, GetStableEventHash(entry.Id, persistentEvent, index)))
+            .ToArray();
+        var reservation = await _usageService.ReserveEventIngestAsync(
+            organization,
+            project,
+            entry.Id,
+            candidates,
+            context.CancellationToken,
+            isRedelivery: entry.Attempts > 1);
+        if (reservation.IsCompleted)
         {
-            if (!isInternalProject)
-                _logger.LogDebug("Unable to process EventPost {FilePath}: Over plan limits", payloadPath);
-
-            await _usageService.IncrementBlockedAsync(organization.Id, project.Id, events.Count);
+            await _usageService.CompleteEventIngestReservationAsync(reservation, organization, reservation.ProcessedCount);
+            if (!await RetryReservedEventsAsync(reservation, events, ep, entry, project, isInternalProject))
+            {
+                await AbandonEntryAsync(entry);
+                return JobResult.FailedWithMessage($"Unable to requeue failed events for EventPost '{entry.Id}'.");
+            }
 
-            await CompleteEntryAsync(entry, ep, _timeProvider.GetUtcNow().UtcDateTime);
+            await CompleteEntryAsync(entry, ep, createdUtc);
             return JobResult.Success;
         }
 
-        // Keep track of the original event payload size, we can save some processing for retries in the case it was a massive batch.
-        bool isSingleEvent = events.Count == 1;
-
-        // Discard any events over the plan limit.
-        if (eventsToProcess < events.Count)
-        {
-            int discarded = events.Count - eventsToProcess;
-            events = events.Take(eventsToProcess).ToList();
-
-            await _usageService.IncrementBlockedAsync(organization.Id, project.Id, discarded);
-        }
-
         int errorCount = 0;
+        bool reservationCompleted = false;
+        bool reservationCompletionStarted = false;
+        var submittedEvents = events;
         var eventsToRetry = new List<PersistentEvent>();
+        var retryIndexes = new List<int>();
         try
         {
-            var contexts = await _eventPipeline.RunAsync(events, organization, project, ep);
+            events = reservation.AcceptedIndexes.Select(index => events[index]).ToList();
+
+            if (events.Count == 0)
+            {
+                if (!isInternalProject)
+                    _logger.LogDebug("Unable to process EventPost {FilePath}: accepted 0/{SubmittedEventCount} events after usage budget evaluation", payloadPath, submittedEventCount);
+
+                reservationCompletionStarted = true;
+                await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 0);
+                reservationCompleted = true;
+                await CompleteEntryAsync(entry, ep, _timeProvider.GetUtcNow().UtcDateTime);
+                return JobResult.Success;
+            }
+
+            var pipelineContexts = events.Select(ev => new EventContext(ev, organization, project, ep)).ToArray();
+            var indexesByContext = pipelineContexts.Select((pipelineContext, index) => (pipelineContext, index))
+                .ToDictionary(pair => pair.pipelineContext, pair => reservation.AcceptedIndexes[pair.index]);
+            var contexts = await _eventPipeline.RunAsync(pipelineContexts);
             if (!isInternalProject && isDebugLogLevelEnabled)
             {
                 using (_logger.BeginScope(new ExceptionlessState().Value(contexts.Count)))
                     _logger.LogDebug("Ran {@Value} events through the pipeline: id={QueueEntryId} success={SuccessCount} error={ErrorCount}", contexts.Count, entry.Id, contexts.Count(r => r.IsProcessed), contexts.Count(r => r.HasError));
             }
 
-            // increment the plan usage counters (note: OverageHandler already incremented usage by 1)
             int processedEvents = contexts.Count(c => c.IsProcessed);
-            await _usageService.IncrementTotalAsync(organization.Id, project.Id, processedEvents);
-
-            int discardedEvents = contexts.Count(c => c.IsDiscarded);
-            await _usageService.IncrementDiscardedAsync(organization.Id, project.Id, discardedEvents);
-
             foreach (var ctx in contexts)
             {
                 if (ctx.IsCancelled)
@@ -222,12 +238,31 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
                 {
                     // Put this single event back into the queue so we can retry it separately.
                     eventsToRetry.Add(ctx.Event);
+                    retryIndexes.Add(indexesByContext[ctx]);
                 }
             }
+
+            // A failed single event retries under the same queue entry. Leave its reservation
+            // active so the finally block releases it before the queue entry is abandoned.
+            if (!isSingleEvent || errorCount == 0 || processedEvents > 0)
+            {
+                reservationCompletionStarted = true;
+                await _usageService.CompleteEventIngestReservationAsync(reservation, organization, processedEvents, retryIndexes,
+                    contexts.Count(c => c.IsDiscarded));
+                reservationCompleted = true;
+            }
         }
         catch (Exception ex)
         {
             if (!isInternalProject) _logger.LogError(ex, "Error processing EventPost {QueueEntryId} {FilePath}: {Message}", entry.Id, payloadPath, ex.Message);
+            if (reservationCompletionStarted)
+            {
+                // Completion is an idempotent transition keyed by this queue entry. Never fork new
+                // queue IDs after it starts: retry the original so it can observe Active vs Completed.
+                await AbandonEntryAsync(entry);
+                return JobResult.FailedWithMessage($"Unable to finalize usage for EventPost '{entry.Id}': {ex.Message}");
+            }
+
             if (ex is ArgumentException || ex is DocumentNotFoundException)
             {
                 await CompleteEntryAsync(entry, ep, createdUtc);
@@ -238,8 +273,21 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
             if (!isSingleEvent)
                 eventsToRetry.AddRange(events);
         }
+        finally
+        {
+            if (!reservationCompleted && !reservationCompletionStarted)
+                await _usageService.ReleaseEventIngestReservationAsync(reservation);
+        }
 
-        if (eventsToRetry.Count > 0)
+        if (reservation.IsTracked && reservationCompleted && retryIndexes.Count > 0)
+        {
+            if (!await RetryReservedEventsAsync(reservation, submittedEvents, ep, entry, project, isInternalProject))
+            {
+                await AbandonEntryAsync(entry);
+                return JobResult.FailedWithMessage($"Unable to requeue failed events for EventPost '{entry.Id}'.");
+            }
+        }
+        else if (eventsToRetry.Count > 0)
             await AppDiagnostics.PostsRetryTime.TimeAsync(() => RetryEventsAsync(eventsToRetry, ep, entry, project, isInternalProject));
 
         if (isSingleEvent && errorCount > 0)
@@ -250,6 +298,32 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
         return JobResult.Success;
     }
 
+    private static ulong GetStableEventHash(string queueEntryId, PersistentEvent persistentEvent, int index)
+    {
+        string value = $"{queueEntryId}:{index}:{persistentEvent.ReferenceId}";
+        const ulong offsetBasis = 14695981039346656037;
+        const ulong prime = 1099511628211;
+        ulong hash = offsetBasis;
+        foreach (char character in value)
+        {
+            hash ^= character;
+            hash *= prime;
+        }
+
+        return hash;
+    }
+
+    internal static bool IsSelectedForSmartThrottle(string queueEntryId, PersistentEvent persistentEvent, int index, double sampleRate = SmartThrottleResult.DefaultSampleRate)
+    {
+        int sampleThreshold = (int)(sampleRate * 10_000);
+        return IsHashSelected(GetStableEventHash(queueEntryId, persistentEvent, index), sampleThreshold);
+    }
+
+    private static bool IsHashSelected(ulong hash, int sampleThreshold)
+    {
+        return hash % 10_000 < (ulong)sampleThreshold;
+    }
+
     private List<PersistentEvent>? ParseEventPost(EventPostInfo ep, DateTime createdUtc, byte[] uncompressedData, string queueEntryId, bool isInternalProject)
     {
         using (_logger.BeginScope(new ExceptionlessState().Tag("parsing")))
@@ -298,8 +372,16 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
         }
     }
 
-    private async Task RetryEventsAsync(List<PersistentEvent> eventsToRetry, EventPostInfo ep, IQueueEntry<EventPost> queueEntry, Project project, bool isInternalProject)
+    private Task<bool> RetryReservedEventsAsync(EventIngestReservation reservation, IReadOnlyList<PersistentEvent> events, EventPostInfo ep,
+        IQueueEntry<EventPost> queueEntry, Project project, bool isInternalProject)
     {
+        return _usageService.RetryPendingEventIngestAsync(reservation,
+            index => RetryEventsAsync([events[index]], ep, queueEntry, project, isInternalProject));
+    }
+
+    private async Task<bool> RetryEventsAsync(List<PersistentEvent> eventsToRetry, EventPostInfo ep, IQueueEntry<EventPost> queueEntry, Project project, bool isInternalProject)
+    {
+        bool succeeded = true;
         AppDiagnostics.EventsRetryCount.Add(eventsToRetry.Count);
         foreach (var ev in eventsToRetry)
         {
@@ -308,7 +390,7 @@ private async Task RetryEventsAsync(List<PersistentEvent> eventsToRetry, EventPo
                 using var stream = new MemoryStream(ev.GetBytes(_serializer));
 
                 // Put this single event back into the queue so we can retry it separately.
-                await _eventPostService.EnqueueAsync(new EventPost(false)
+                string? retryId = await _eventPostService.EnqueueAsync(new EventPost(false)
                 {
                     ApiVersion = ep.ApiVersion,
                     CharSet = ep.CharSet,
@@ -320,6 +402,8 @@ await _eventPostService.EnqueueAsync(new EventPost(false)
                     ProjectId = ep.ProjectId ?? project.Id,
                     UserAgent = ep.UserAgent
                 }, stream);
+                if (String.IsNullOrEmpty(retryId))
+                    throw new InvalidOperationException("Unable to enqueue the failed event.");
             }
             catch (Exception ex)
             {
@@ -330,8 +414,11 @@ await _eventPostService.EnqueueAsync(new EventPost(false)
                 }
 
                 AppDiagnostics.EventsRetryErrors.Add(1);
+                succeeded = false;
             }
         }
+
+        return succeeded;
     }
 
     private Task AbandonEntryAsync(IQueueEntry<EventPost> queueEntry)
diff --git a/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs b/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs
new file mode 100644
index 0000000000..de4e01bc53
--- /dev/null
+++ b/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs
@@ -0,0 +1,159 @@
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.DateTimeExtensions;
+using Foundatio.Extensions.Hosting.Startup;
+using Foundatio.Jobs;
+using Foundatio.Lock;
+using Foundatio.Messaging;
+using Foundatio.Queues;
+using Foundatio.Repositories;
+using Microsoft.Extensions.Logging;
+
+namespace Exceptionless.Core.Jobs.WorkItemHandlers;
+
+public class EnqueueOrganizationBudgetAlertOnUsageThreshold : IStartupAction
+{
+    private readonly IQueue<WorkItemData> _workItemQueue;
+    private readonly IMessageSubscriber _subscriber;
+    private readonly TimeProvider _timeProvider;
+    private readonly ILogger _logger;
+
+    public EnqueueOrganizationBudgetAlertOnUsageThreshold(IQueue<WorkItemData> workItemQueue, IMessageSubscriber subscriber, TimeProvider timeProvider, ILoggerFactory loggerFactory)
+    {
+        _workItemQueue = workItemQueue;
+        _subscriber = subscriber;
+        _timeProvider = timeProvider;
+        _logger = loggerFactory.CreateLogger<EnqueueOrganizationBudgetAlertOnUsageThreshold>();
+    }
+
+    public Task RunAsync(CancellationToken shutdownToken = default)
+    {
+        return _subscriber.SubscribeAsync<OrganizationBudgetAlert>(async alert =>
+        {
+            _logger.LogInformation("Enqueueing budget alert work item for organization: {OrganizationId} Threshold: {Threshold}%", alert.OrganizationId, alert.Threshold);
+
+            await _workItemQueue.EnqueueAsync(new OrganizationBudgetAlertWorkItem
+            {
+                OrganizationId = alert.OrganizationId,
+                Threshold = alert.Threshold,
+                ThresholdEventCount = alert.ThresholdEventCount,
+                CurrentEventCount = alert.CurrentEventCount,
+                EventLimit = alert.EventLimit,
+                UsagePeriod = alert.UsagePeriod > 0 ? alert.UsagePeriod : _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+            });
+        }, shutdownToken);
+    }
+}
+
+public class OrganizationBudgetAlertWorkItemHandler : WorkItemHandlerBase
+{
+    private readonly IOrganizationRepository _organizationRepository;
+    private readonly IUserRepository _userRepository;
+    private readonly IMailer _mailer;
+    private readonly UsageService _usageService;
+    private readonly NotificationService _notificationService;
+    private readonly TimeProvider _timeProvider;
+
+    public OrganizationBudgetAlertWorkItemHandler(IOrganizationRepository organizationRepository, IUserRepository userRepository, IMailer mailer, UsageService usageService,
+        NotificationService notificationService, TimeProvider timeProvider, ILoggerFactory loggerFactory) : base(loggerFactory)
+    {
+        _organizationRepository = organizationRepository;
+        _userRepository = userRepository;
+        _mailer = mailer;
+        _usageService = usageService;
+        _notificationService = notificationService;
+        _timeProvider = timeProvider;
+    }
+
+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = default)
+    {
+        var wi = (OrganizationBudgetAlertWorkItem)workItem;
+        int currentUsagePeriod = _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch();
+        return _notificationService.TryAcquireUsageNotificationLockAsync(wi.GetUniqueIdentifier(currentUsagePeriod));
+    }
+
+    public override async Task HandleItemAsync(WorkItemContext context)
+    {
+        var wi = context.GetData<OrganizationBudgetAlertWorkItem>()!;
+        Log.LogInformation("Received budget alert work item for organization: {OrganizationId} Threshold: {Threshold}%", wi.OrganizationId, wi.Threshold);
+
+        int usagePeriod = wi.UsagePeriod > 0 ? wi.UsagePeriod : _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch();
+        string notificationIdentifier = wi.GetUniqueIdentifier(usagePeriod);
+        if (usagePeriod != _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch())
+        {
+            Log.LogInformation("Budget alert period {UsagePeriod} is stale for organization {OrganizationId}, skipping", wi.UsagePeriod, wi.OrganizationId);
+            return;
+        }
+
+        var organization = await _organizationRepository.GetByIdAsync(wi.OrganizationId, o => o.Cache());
+        if (organization is null)
+        {
+            Log.LogWarning("Organization {OrganizationId} not found, skipping budget alert", wi.OrganizationId);
+            return;
+        }
+
+        // Re-check that budget alerts are still enabled and the threshold is still configured
+        if (organization.BudgetAlertSettings is not { Enabled: true, Thresholds: not null } || !organization.BudgetAlertSettings.Thresholds.Contains(wi.Threshold))
+        {
+            Log.LogInformation("Budget alerts disabled or threshold {Threshold}% removed for organization: {OrganizationId}, skipping", wi.Threshold, wi.OrganizationId);
+            return;
+        }
+
+        int eventLimit = await _usageService.GetMaxEventsPerMonthAsync(organization.Id);
+        if (eventLimit <= 0)
+        {
+            Log.LogInformation("Organization {OrganizationId} no longer has a finite event allowance, skipping budget alert", wi.OrganizationId);
+            return;
+        }
+
+        int thresholdEventCount = UsageService.GetBudgetThresholdEventCount(eventLimit, wi.Threshold);
+        int currentEventCount = (await _usageService.GetUsageAsync(organization.Id)).CurrentUsage.Total;
+        if (currentEventCount < thresholdEventCount)
+        {
+            Log.LogInformation("Organization {OrganizationId} usage is now below budget threshold {Threshold}%, skipping", wi.OrganizationId, wi.Threshold);
+            return;
+        }
+
+        context.CancellationToken.ThrowIfCancellationRequested();
+
+        var results = await _userRepository.GetByOrganizationIdAsync(organization.Id, options => options.SearchAfterPaging());
+        do
+        {
+            foreach (var user in results.Documents)
+            {
+                context.CancellationToken.ThrowIfCancellationRequested();
+
+                if (!user.IsEmailAddressVerified)
+                {
+                    Log.LogInformation("User {UserId} with email address {EmailAddress} has not been verified, skipping budget alert", user.Id, user.EmailAddress);
+                    continue;
+                }
+
+                if (!user.EmailNotificationsEnabled)
+                {
+                    Log.LogInformation("User {UserId} with email address {EmailAddress} has email notifications disabled, skipping budget alert", user.Id, user.EmailAddress);
+                    continue;
+                }
+
+                if (await _notificationService.IsUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id))
+                    continue;
+
+                await using var recipientLock = await _notificationService.TryAcquireUsageNotificationRecipientLockAsync(notificationIdentifier, user.Id);
+                if (recipientLock is null || await _notificationService.IsUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id))
+                    continue;
+
+                Log.LogTrace("Sending budget alert email to {EmailAddress}...", user.EmailAddress);
+                await _mailer.SendOrganizationBudgetAlertAsync(user, organization, wi.Threshold, thresholdEventCount, currentEventCount, eventLimit);
+                await _notificationService.MarkUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id, usagePeriod);
+            }
+        } while (!context.CancellationToken.IsCancellationRequested && await results.NextPageAsync());
+
+        context.CancellationToken.ThrowIfCancellationRequested();
+
+        Log.LogTrace("Done sending budget alert emails");
+    }
+}
diff --git a/src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectSmartThrottleWorkItemHandler.cs b/src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectSmartThrottleWorkItemHandler.cs
new file mode 100644
index 0000000000..163ddd2b7e
--- /dev/null
+++ b/src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectSmartThrottleWorkItemHandler.cs
@@ -0,0 +1,163 @@
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.DateTimeExtensions;
+using Foundatio.Extensions.Hosting.Startup;
+using Foundatio.Jobs;
+using Foundatio.Lock;
+using Foundatio.Messaging;
+using Foundatio.Queues;
+using Foundatio.Repositories;
+using Microsoft.Extensions.Logging;
+
+namespace Exceptionless.Core.Jobs.WorkItemHandlers;
+
+public class EnqueueProjectSmartThrottleOnThrottleApplied : IStartupAction
+{
+    private readonly IQueue<WorkItemData> _workItemQueue;
+    private readonly IMessageSubscriber _subscriber;
+    private readonly TimeProvider _timeProvider;
+    private readonly ILogger _logger;
+
+    public EnqueueProjectSmartThrottleOnThrottleApplied(IQueue<WorkItemData> workItemQueue, IMessageSubscriber subscriber, TimeProvider timeProvider, ILoggerFactory loggerFactory)
+    {
+        _workItemQueue = workItemQueue;
+        _subscriber = subscriber;
+        _timeProvider = timeProvider;
+        _logger = loggerFactory.CreateLogger<EnqueueProjectSmartThrottleOnThrottleApplied>();
+    }
+
+    public Task RunAsync(CancellationToken shutdownToken = default)
+    {
+        return _subscriber.SubscribeAsync<ProjectSmartThrottleApplied>(async throttle =>
+        {
+            _logger.LogInformation("Enqueueing smart throttle notification for project: {ProjectId} in organization: {OrganizationId}", throttle.ProjectId, throttle.OrganizationId);
+
+            await _workItemQueue.EnqueueAsync(new ProjectSmartThrottleWorkItem
+            {
+                OrganizationId = throttle.OrganizationId,
+                ProjectId = throttle.ProjectId,
+                SampleRate = throttle.SampleRate,
+                CurrentEventCount = throttle.CurrentEventCount,
+                EventLimit = throttle.EventLimit,
+                UsagePeriod = throttle.UsagePeriod > 0 ? throttle.UsagePeriod : _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+            });
+        }, shutdownToken);
+    }
+}
+
+public class ProjectSmartThrottleWorkItemHandler : WorkItemHandlerBase
+{
+    private readonly IOrganizationRepository _organizationRepository;
+    private readonly IProjectRepository _projectRepository;
+    private readonly IUserRepository _userRepository;
+    private readonly IMailer _mailer;
+    private readonly UsageService _usageService;
+    private readonly NotificationService _notificationService;
+    private readonly TimeProvider _timeProvider;
+
+    public ProjectSmartThrottleWorkItemHandler(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IUserRepository userRepository, IMailer mailer, UsageService usageService,
+        NotificationService notificationService, TimeProvider timeProvider, ILoggerFactory loggerFactory) : base(loggerFactory)
+    {
+        _organizationRepository = organizationRepository;
+        _projectRepository = projectRepository;
+        _userRepository = userRepository;
+        _mailer = mailer;
+        _usageService = usageService;
+        _notificationService = notificationService;
+        _timeProvider = timeProvider;
+    }
+
+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = default)
+    {
+        var wi = (ProjectSmartThrottleWorkItem)workItem;
+        int currentUsagePeriod = _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch();
+        return _notificationService.TryAcquireUsageNotificationLockAsync(wi.GetUniqueIdentifier(currentUsagePeriod));
+    }
+
+    public override async Task HandleItemAsync(WorkItemContext context)
+    {
+        var wi = context.GetData<ProjectSmartThrottleWorkItem>()!;
+        Log.LogInformation("Received smart throttle notification for project: {ProjectId} in organization: {OrganizationId}", wi.ProjectId, wi.OrganizationId);
+
+        int usagePeriod = wi.UsagePeriod > 0 ? wi.UsagePeriod : _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch();
+        string notificationIdentifier = wi.GetUniqueIdentifier(usagePeriod);
+        if (usagePeriod != _timeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch())
+        {
+            Log.LogInformation("Smart throttle period {UsagePeriod} is stale for project {ProjectId}, skipping", wi.UsagePeriod, wi.ProjectId);
+            return;
+        }
+
+        var organization = await _organizationRepository.GetByIdAsync(wi.OrganizationId, o => o.Cache());
+        if (organization is null)
+        {
+            Log.LogWarning("Organization {OrganizationId} not found, skipping smart throttle notification", wi.OrganizationId);
+            return;
+        }
+
+        var project = await _projectRepository.GetByIdAsync(wi.ProjectId, o => o.Cache());
+        if (project is null)
+        {
+            Log.LogWarning("Project {ProjectId} not found, skipping smart throttle notification", wi.ProjectId);
+            return;
+        }
+
+        if (!String.Equals(project.OrganizationId, organization.Id, StringComparison.Ordinal) ||
+            !await _usageService.IsProjectSmartThrottledAsync(organization.Id, project.Id))
+        {
+            Log.LogInformation("Project {ProjectId} is no longer smart throttled, skipping notification", wi.ProjectId);
+            return;
+        }
+
+        var allowance = await _usageService.GetEventIngestAllowanceAsync(organization, project);
+        if (!allowance.SmartThrottle.IsThrottled)
+        {
+            Log.LogInformation("Project {ProjectId} is no longer smart throttled, skipping notification", wi.ProjectId);
+            return;
+        }
+
+        context.CancellationToken.ThrowIfCancellationRequested();
+
+        var results = await _userRepository.GetByOrganizationIdAsync(organization.Id, options => options.SearchAfterPaging());
+        do
+        {
+            foreach (var user in results.Documents)
+            {
+                context.CancellationToken.ThrowIfCancellationRequested();
+
+                if (!user.IsEmailAddressVerified)
+                {
+                    Log.LogInformation("User {UserId} with email address {EmailAddress} has not been verified, skipping throttle notification", user.Id, user.EmailAddress);
+                    continue;
+                }
+
+                if (!user.EmailNotificationsEnabled)
+                {
+                    Log.LogInformation("User {UserId} with email address {EmailAddress} has email notifications disabled, skipping throttle notification", user.Id, user.EmailAddress);
+                    continue;
+                }
+
+                if (await _notificationService.IsUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id))
+                    continue;
+
+                await using var recipientLock = await _notificationService.TryAcquireUsageNotificationRecipientLockAsync(notificationIdentifier, user.Id);
+                if (recipientLock is null || await _notificationService.IsUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id))
+                    continue;
+
+                Log.LogTrace("Sending smart throttle email to {EmailAddress}...", user.EmailAddress);
+                await _mailer.SendProjectThrottledNoticeAsync(user, organization, project,
+                    allowance.SmartThrottle.SampleRate,
+                    allowance.SmartThrottle.CurrentProjectUsage,
+                    allowance.SmartThrottle.FairShareLimit);
+                await _notificationService.MarkUsageNotificationRecipientSentAsync(notificationIdentifier, user.Id, usagePeriod);
+            }
+        } while (!context.CancellationToken.IsCancellationRequested && await results.NextPageAsync());
+
+        context.CancellationToken.ThrowIfCancellationRequested();
+
+        Log.LogTrace("Done sending smart throttle emails");
+    }
+}
diff --git a/src/Exceptionless.Core/Mail/IMailer.cs b/src/Exceptionless.Core/Mail/IMailer.cs
index 6e8905cab5..7a121864ed 100644
--- a/src/Exceptionless.Core/Mail/IMailer.cs
+++ b/src/Exceptionless.Core/Mail/IMailer.cs
@@ -11,6 +11,8 @@ public interface IMailer
     Task SendOrganizationNoticeAsync(User user, Organization organization, bool isOverMonthlyLimit, bool isOverHourlyLimit);
     Task SendOrganizationPaymentFailedAsync(User owner, Organization organization);
     Task SendProjectDailySummaryAsync(User user, Project project, IEnumerable<Stack>? mostFrequent, IEnumerable<Stack>? newest, DateTime startDate, bool hasSubmittedEvents, double count, double uniqueCount, double newCount, double fixedCount, int blockedCount, int tooBigCount, bool isFreePlan);
+    Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit);
+    Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit);
     Task SendUserEmailVerifyAsync(User user);
     Task SendUserPasswordResetAsync(User user);
 }
diff --git a/src/Exceptionless.Core/Mail/Mailer.cs b/src/Exceptionless.Core/Mail/Mailer.cs
index 85933fb25a..7d25919967 100644
--- a/src/Exceptionless.Core/Mail/Mailer.cs
+++ b/src/Exceptionless.Core/Mail/Mailer.cs
@@ -248,6 +248,51 @@ await QueueMessageAsync(new MailMessage
         }, template);
     }
 
+    public async Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit)
+    {
+        const string template = "organization-budget-alert";
+        string subject = $"[{organization.Name}] Budget Alert: {threshold}% of monthly event allowance used";
+        var message = new OrganizationBudgetAlertEmail(
+            subject,
+            organization.Name,
+            threshold,
+            thresholdEventCount,
+            currentEventCount,
+            eventLimit,
+            Math.Max(0, eventLimit - currentEventCount),
+            _appUrls.OrganizationUsage(organization.Id),
+            _appUrls.AccountNotifications());
+
+        await QueueMessageAsync(new MailMessage
+        {
+            To = user.EmailAddress,
+            Subject = subject,
+            Body = await _templateRenderer.RenderAsync(message)
+        }, template);
+    }
+
+    public async Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit)
+    {
+        const string template = "project-smart-throttle";
+        string subject = $"[{organization.Name}] Smart Throttling Active: {project.Name}";
+        var message = new ProjectSmartThrottleEmail(
+            subject,
+            organization.Name,
+            project.Name,
+            (int)(sampleRate * 100),
+            currentEventCount,
+            eventLimit,
+            _appUrls.ProjectUsage(project.Id),
+            _appUrls.AccountNotifications());
+
+        await QueueMessageAsync(new MailMessage
+        {
+            To = user.EmailAddress,
+            Subject = subject,
+            Body = await _templateRenderer.RenderAsync(message)
+        }, template);
+    }
+
     public async Task SendProjectDailySummaryAsync(User user, Project project, IEnumerable<Stack>? mostFrequent, IEnumerable<Stack>? newest, DateTime startDate, bool hasSubmittedEvents, double count, double uniqueCount, double newCount, double fixedCount, int blockedCount, int tooBigCount, bool isFreePlan)
     {
         const string template = "project-daily-summary";
diff --git a/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs b/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs
new file mode 100644
index 0000000000..b7c5ae07f9
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs
@@ -0,0 +1,11 @@
+namespace Exceptionless.Core.Messaging.Models;
+
+public record OrganizationBudgetAlert
+{
+    public required string OrganizationId { get; init; }
+    public required int Threshold { get; init; }
+    public required int ThresholdEventCount { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+    public int UsagePeriod { get; init; }
+}
diff --git a/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs b/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs
new file mode 100644
index 0000000000..b184414611
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs
@@ -0,0 +1,11 @@
+namespace Exceptionless.Core.Messaging.Models;
+
+public record ProjectSmartThrottleApplied
+{
+    public required string OrganizationId { get; init; }
+    public required string ProjectId { get; init; }
+    public required double SampleRate { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+    public int UsagePeriod { get; init; }
+}
diff --git a/src/Exceptionless.Core/Models/Organization.cs b/src/Exceptionless.Core/Models/Organization.cs
index 4cfa22dac8..bab0df92c7 100644
--- a/src/Exceptionless.Core/Models/Organization.cs
+++ b/src/Exceptionless.Core/Models/Organization.cs
@@ -197,6 +197,11 @@ public Organization()
     /// </summary>
     public DataDictionary? Data { get; set; }
 
+    /// <summary>
+    /// Budget alert settings for this organization. Null means disabled.
+    /// </summary>
+    public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
+
     public DateTime CreatedUtc { get; set; }
     public DateTime UpdatedUtc { get; set; }
     public bool IsDeleted { get; set; }
@@ -291,6 +296,19 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
                     [nameof(SuspendedByUserId)]);
             }
         }
+
+        if (BudgetAlertSettings is not null)
+        {
+            if (BudgetAlertSettings.Enabled && BudgetAlertSettings.Thresholds is not { Count: > 0 })
+            {
+                yield return new ValidationResult("At least one threshold is required when budget alerts are enabled.",
+                    [nameof(BudgetAlertSettings)]);
+            }
+
+            if (BudgetAlertSettings.Thresholds?.Any(t => t <= 0 || t >= 100) is true)
+                yield return new ValidationResult("Budget alert thresholds must be between 1 and 99.",
+                    [nameof(BudgetAlertSettings)]);
+        }
     }
 }
 
diff --git a/src/Exceptionless.Core/Models/OrganizationBudgetAlertSettings.cs b/src/Exceptionless.Core/Models/OrganizationBudgetAlertSettings.cs
new file mode 100644
index 0000000000..e8d55eccb2
--- /dev/null
+++ b/src/Exceptionless.Core/Models/OrganizationBudgetAlertSettings.cs
@@ -0,0 +1,12 @@
+namespace Exceptionless.Core.Models;
+
+public class OrganizationBudgetAlertSettings
+{
+    public bool Enabled { get; set; }
+
+    /// <summary>
+    /// Percentage thresholds of the organization's effective monthly event allowance.
+    /// Example: [50, 80, 90].
+    /// </summary>
+    public SortedSet<int> Thresholds { get; set; } = [];
+}
diff --git a/src/Exceptionless.Core/Models/Project.cs b/src/Exceptionless.Core/Models/Project.cs
index 4ac783e893..5b07d6089a 100644
--- a/src/Exceptionless.Core/Models/Project.cs
+++ b/src/Exceptionless.Core/Models/Project.cs
@@ -63,6 +63,11 @@ public Project()
 
     public bool DeleteBotDataEnabled { get; set; }
 
+    /// <summary>
+    /// Optional project-level event budget configuration. Null means no project-specific cap.
+    /// </summary>
+    public ProjectIngestLimit? IngestLimit { get; set; }
+
     /// <summary>
     /// The tick count that represents the next time the daily summary job should run. This time is set to midnight of the
     /// projects local time.
@@ -90,5 +95,24 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
             yield return new ValidationResult("Please specify a valid next summary end of day ticks.",
                 [nameof(NextSummaryEndOfDayTicks)]);
         }
+
+        if (IngestLimit is null)
+            yield break;
+
+        if (!Enum.IsDefined(IngestLimit.Type))
+        {
+            yield return new ValidationResult("Please specify a valid project ingest limit type.", [nameof(IngestLimit)]);
+            yield break;
+        }
+
+        if (IngestLimit.Type is ProjectIngestLimitType.Fixed && IngestLimit.FixedLimit is null or <= 0)
+            yield return new ValidationResult("The fixed project ingest limit must be greater than 0.", [nameof(IngestLimit)]);
+
+        if (IngestLimit.Type is ProjectIngestLimitType.PercentOfOrganizationLimit && IngestLimit.PercentOfOrganizationLimit is null or <= 0 or > 100)
+            yield return new ValidationResult("The project ingest percentage must be greater than 0 and no more than 100.", [nameof(IngestLimit)]);
+
+        if (IngestLimit.Type is ProjectIngestLimitType.PercentOfOrganizationLimit &&
+            IngestLimit.PercentOfOrganizationLimit is { } percentage && percentage != Decimal.Round(percentage, 4))
+            yield return new ValidationResult("The project ingest percentage can have no more than 4 decimal places.", [nameof(IngestLimit)]);
     }
 }
diff --git a/src/Exceptionless.Core/Models/ProjectIngestLimit.cs b/src/Exceptionless.Core/Models/ProjectIngestLimit.cs
new file mode 100644
index 0000000000..67704e9de6
--- /dev/null
+++ b/src/Exceptionless.Core/Models/ProjectIngestLimit.cs
@@ -0,0 +1,14 @@
+namespace Exceptionless.Core.Models;
+
+public class ProjectIngestLimit
+{
+    public ProjectIngestLimitType Type { get; set; }
+    public int? FixedLimit { get; set; }
+    public decimal? PercentOfOrganizationLimit { get; set; }
+}
+
+public enum ProjectIngestLimitType
+{
+    Fixed = 0,
+    PercentOfOrganizationLimit = 1
+}
diff --git a/src/Exceptionless.Core/Models/WorkItems/OrganizationBudgetAlertWorkItem.cs b/src/Exceptionless.Core/Models/WorkItems/OrganizationBudgetAlertWorkItem.cs
new file mode 100644
index 0000000000..db8394f7c2
--- /dev/null
+++ b/src/Exceptionless.Core/Models/WorkItems/OrganizationBudgetAlertWorkItem.cs
@@ -0,0 +1,16 @@
+using Foundatio.Queues;
+
+namespace Exceptionless.Core.Models.WorkItems;
+
+public record OrganizationBudgetAlertWorkItem : IHaveUniqueIdentifier
+{
+    public required string OrganizationId { get; init; }
+    public required int Threshold { get; init; }
+    public required int ThresholdEventCount { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+    public int UsagePeriod { get; init; }
+
+    public string UniqueIdentifier => $"BudgetAlert:{UsagePeriod}:{OrganizationId}:{Threshold}";
+    public string GetUniqueIdentifier(int fallbackUsagePeriod) => $"BudgetAlert:{(UsagePeriod > 0 ? UsagePeriod : fallbackUsagePeriod)}:{OrganizationId}:{Threshold}";
+}
diff --git a/src/Exceptionless.Core/Models/WorkItems/ProjectSmartThrottleWorkItem.cs b/src/Exceptionless.Core/Models/WorkItems/ProjectSmartThrottleWorkItem.cs
new file mode 100644
index 0000000000..55e05c9ec1
--- /dev/null
+++ b/src/Exceptionless.Core/Models/WorkItems/ProjectSmartThrottleWorkItem.cs
@@ -0,0 +1,16 @@
+using Foundatio.Queues;
+
+namespace Exceptionless.Core.Models.WorkItems;
+
+public record ProjectSmartThrottleWorkItem : IHaveUniqueIdentifier
+{
+    public required string OrganizationId { get; init; }
+    public required string ProjectId { get; init; }
+    public required double SampleRate { get; init; }
+    public required int CurrentEventCount { get; init; }
+    public required int EventLimit { get; init; }
+    public int UsagePeriod { get; init; }
+
+    public string UniqueIdentifier => $"SmartThrottle:{UsagePeriod}:{OrganizationId}:{ProjectId}";
+    public string GetUniqueIdentifier(int fallbackUsagePeriod) => $"SmartThrottle:{(UsagePeriod > 0 ? UsagePeriod : fallbackUsagePeriod)}:{OrganizationId}:{ProjectId}";
+}
diff --git a/src/Exceptionless.Core/Services/IAtomicCacheBatch.cs b/src/Exceptionless.Core/Services/IAtomicCacheBatch.cs
new file mode 100644
index 0000000000..05acdb1b07
--- /dev/null
+++ b/src/Exceptionless.Core/Services/IAtomicCacheBatch.cs
@@ -0,0 +1,68 @@
+using Foundatio.Caching;
+
+namespace Exceptionless.Core.Services;
+
+public readonly record struct AtomicCacheValue(string Value, TimeSpan ExpiresIn);
+
+public interface IAtomicCacheBatch
+{
+    Task<bool> TrySetAllAsync(IReadOnlyDictionary<string, string?> expectedValues, IReadOnlyDictionary<string, AtomicCacheValue> values,
+        IReadOnlyDictionary<string, string>? listValues = null, TimeSpan? listExpiresIn = null);
+}
+
+internal sealed class InMemoryAtomicCacheBatch(ICacheClient cacheClient) : IAtomicCacheBatch
+{
+    public async Task<bool> TrySetAllAsync(IReadOnlyDictionary<string, string?> expectedValues, IReadOnlyDictionary<string, AtomicCacheValue> values,
+        IReadOnlyDictionary<string, string>? listValues = null, TimeSpan? listExpiresIn = null)
+    {
+        AtomicCacheBatch.ValidateArguments(expectedValues, values, listValues, listExpiresIn);
+
+        // The in-memory provider has no remote partial-failure boundary. Callers hold the
+        // organization reservation lock while applying this batch.
+        var currentValues = await cacheClient.GetAllAsync<string>(expectedValues.Keys);
+        foreach (var expected in expectedValues)
+        {
+            string? current = currentValues.TryGetValue(expected.Key, out var value) && value.HasValue ? value.Value : null;
+            if (!String.Equals(current, expected.Value, StringComparison.Ordinal))
+                return false;
+        }
+
+        foreach (var expirationGroup in values.GroupBy(entry => entry.Value.ExpiresIn))
+        {
+            var updates = expirationGroup.ToDictionary(entry => entry.Key, entry => entry.Value.Value);
+            if (await cacheClient.SetAllAsync(updates, expirationGroup.Key) != updates.Count)
+                return false;
+        }
+
+        if (listValues is not null)
+        {
+            foreach (var entry in listValues)
+                await cacheClient.ListAddAsync(entry.Key, entry.Value, listExpiresIn);
+        }
+
+        return true;
+    }
+}
+
+internal static class AtomicCacheBatch
+{
+    public static void ValidateArguments(IReadOnlyDictionary<string, string?> expectedValues, IReadOnlyDictionary<string, AtomicCacheValue> values,
+        IReadOnlyDictionary<string, string>? listValues, TimeSpan? listExpiresIn)
+    {
+        ArgumentNullException.ThrowIfNull(expectedValues);
+        ArgumentNullException.ThrowIfNull(values);
+        if (values.Count == 0)
+            throw new ArgumentException("Atomic cache batches must contain at least one scalar update.", nameof(values));
+        if (expectedValues.Count != values.Count || expectedValues.Keys.Any(key => !values.ContainsKey(key)))
+            throw new ArgumentException("Expected and updated cache batches must contain the same keys.", nameof(expectedValues));
+        if (values.Any(entry => entry.Value.ExpiresIn < TimeSpan.FromMilliseconds(1)))
+            throw new ArgumentOutOfRangeException(nameof(values), "Atomic cache update expirations must be at least one millisecond.");
+
+        if (listValues is not { Count: > 0 })
+            return;
+        if (listExpiresIn is null || listExpiresIn < TimeSpan.FromMilliseconds(1))
+            throw new ArgumentOutOfRangeException(nameof(listExpiresIn), "Atomic cache list expirations must be at least one millisecond.");
+        if (listValues.Keys.Any(values.ContainsKey))
+            throw new ArgumentException("Scalar and list cache updates must use different keys.", nameof(listValues));
+    }
+}
diff --git a/src/Exceptionless.Core/Services/NotificationService.cs b/src/Exceptionless.Core/Services/NotificationService.cs
index 64f28d1289..763b577f84 100644
--- a/src/Exceptionless.Core/Services/NotificationService.cs
+++ b/src/Exceptionless.Core/Services/NotificationService.cs
@@ -103,6 +103,43 @@ public Task<bool> IsOrganizationNotificationLockedAsync(string organizationId, b
         return lockProvider.IsLockedAsync(GetOrganizationNotificationLockKey(organizationId, isOverMonthlyLimit));
     }
 
+    public Task<ILock?> TryAcquireUsageNotificationLockAsync(string notificationIdentifier)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(notificationIdentifier);
+        return lockProvider.TryAcquireAsync($"{notificationIdentifier}-lock", OrganizationNotificationLockTimeout, TimeSpan.Zero);
+    }
+
+    public Task<ILock?> TryAcquireUsageNotificationRecipientLockAsync(string notificationIdentifier, string userId)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(notificationIdentifier);
+        ArgumentException.ThrowIfNullOrEmpty(userId);
+
+        return lockProvider.TryAcquireAsync($"{GetUsageNotificationRecipientKey(notificationIdentifier, userId)}-lock", OrganizationNotificationLockTimeout, TimeSpan.Zero);
+    }
+
+    public Task<bool> IsUsageNotificationRecipientSentAsync(string notificationIdentifier, string userId)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(notificationIdentifier);
+        ArgumentException.ThrowIfNullOrEmpty(userId);
+        return cacheClient.ExistsAsync(GetUsageNotificationRecipientKey(notificationIdentifier, userId));
+    }
+
+    public Task MarkUsageNotificationRecipientSentAsync(string notificationIdentifier, string userId, int usagePeriod)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(notificationIdentifier);
+        ArgumentException.ThrowIfNullOrEmpty(userId);
+
+        var utcNow = timeProvider.GetUtcNow().UtcDateTime;
+        if (usagePeriod <= 0)
+            usagePeriod = utcNow.StartOfMonth().ToEpoch();
+        var periodStartUtc = DateTimeOffset.FromUnixTimeSeconds(usagePeriod).UtcDateTime;
+        var expiresIn = periodStartUtc.AddMonths(1).AddDays(1) - utcNow;
+        if (expiresIn < CacheClientExtensions.MinimumExpiration)
+            expiresIn = CacheClientExtensions.MinimumExpiration;
+
+        return cacheClient.SetAsync(GetUsageNotificationRecipientKey(notificationIdentifier, userId), true, expiresIn);
+    }
+
     private static string GetOrganizationNotificationLockKey(string organizationId, bool isOverMonthlyLimit)
     {
         return $"{OrganizationNotificationWorkItem.GetNotificationKey(organizationId, isOverMonthlyLimit)}-lock";
@@ -113,6 +150,11 @@ private static string GetOrganizationNotificationSentKey(string organizationId,
         return $"{OrganizationNotificationWorkItem.GetNotificationKey(organizationId, isOverMonthlyLimit)}-sent";
     }
 
+    private static string GetUsageNotificationRecipientKey(string notificationIdentifier, string userId)
+    {
+        return $"{notificationIdentifier}:{userId}-sent";
+    }
+
     private DateTime GetOrganizationNotificationSentExpiresAtUtc()
     {
         var utcNow = timeProvider.GetUtcNow().UtcDateTime;
diff --git a/src/Exceptionless.Core/Services/UsageService.Budgets.cs b/src/Exceptionless.Core/Services/UsageService.Budgets.cs
new file mode 100644
index 0000000000..31fcbfbcfb
--- /dev/null
+++ b/src/Exceptionless.Core/Services/UsageService.Budgets.cs
@@ -0,0 +1,400 @@
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.DateTimeExtensions;
+using Foundatio.Caching;
+using Foundatio.Messaging;
+using Foundatio.Repositories;
+using Microsoft.Extensions.Logging;
+
+namespace Exceptionless.Core.Services;
+
+public partial class UsageService
+{
+    private const int MinimumColdBucketSmartThrottleBatchSize = 100;
+
+    /// <summary>
+    /// Calculates the complete organization, explicit project, and automatic smart-throttle allowance
+    /// from the models already loaded by the ingestion job.
+    /// </summary>
+    public async Task<EventIngestAllowance> GetEventIngestAllowanceAsync(Organization organization, Project project)
+    {
+        ArgumentNullException.ThrowIfNull(organization);
+        ArgumentNullException.ThrowIfNull(project);
+        if (!String.Equals(project.OrganizationId, organization.Id, StringComparison.Ordinal))
+            throw new ArgumentException("The project does not belong to the organization.", nameof(project));
+
+        int maxEventsPerMonth = organization.GetMaxEventsPerMonthWithBonus(_timeProvider);
+        int effectiveProjectLimit = GetEffectiveProjectLimit(project, maxEventsPerMonth);
+
+        // This is the common self-hosted/unlimited path: no cache or repository reads are needed.
+        if (maxEventsPerMonth < 0 && effectiveProjectLimit < 0)
+            return EventIngestAllowance.Unlimited;
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        var totals = await GetAcceptedUsageTotalsAsync(utcNow, organization, project);
+
+        return await CalculateEventIngestAllowanceAsync(utcNow, organization, project, maxEventsPerMonth, effectiveProjectLimit, totals, 0, true);
+    }
+
+    private async Task<EventIngestAllowance> CalculateEventIngestAllowanceAsync(DateTime utcNow, Organization organization, Project project,
+        int maxEventsPerMonth, int effectiveProjectLimit, AcceptedUsageTotals totals, int submittedEventCount, bool activateSmartThrottle)
+    {
+
+        int organizationEventsLeft = GetOrganizationEventsLeft(maxEventsPerMonth, totals.OrganizationTotal, totals.OrganizationCurrentBucket);
+        if (organizationEventsLeft <= 0)
+        {
+            return new EventIngestAllowance
+            {
+                EventsLeft = 0,
+                IsOverOrganizationLimit = true,
+                EffectiveProjectLimit = effectiveProjectLimit
+            };
+        }
+
+        int projectEventsLeft = effectiveProjectLimit < 0
+            ? Int32.MaxValue
+            : Math.Max(0, effectiveProjectLimit - totals.ProjectTotal);
+        if (projectEventsLeft <= 0)
+        {
+            return new EventIngestAllowance
+            {
+                EventsLeft = 0,
+                IsOverProjectLimit = true,
+                EffectiveProjectLimit = effectiveProjectLimit
+            };
+        }
+
+        var smartThrottle = await GetSmartThrottleResultAsync(utcNow, organization, maxEventsPerMonth, totals, submittedEventCount);
+        if (activateSmartThrottle && smartThrottle.IsThrottled)
+            await ActivateSmartThrottleAsync(utcNow, organization, project, smartThrottle);
+
+        return new EventIngestAllowance
+        {
+            EventsLeft = Math.Min(organizationEventsLeft, projectEventsLeft),
+            EffectiveProjectLimit = effectiveProjectLimit,
+            SmartThrottle = smartThrottle
+        };
+    }
+
+    public async Task<EventIngestAllowance> GetEventIngestAllowanceAsync(string organizationId, string projectId)
+    {
+        var organizationTask = _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+        var projectTask = _projectRepository.GetByIdAsync(projectId, o => o.Cache());
+        await Task.WhenAll(organizationTask, projectTask);
+
+        var organization = await organizationTask ?? throw new UsageServiceException($"Organization '{organizationId}' not found.");
+        var project = await projectTask ?? throw new UsageServiceException($"Project '{projectId}' not found.");
+        return await GetEventIngestAllowanceAsync(organization, project);
+    }
+
+    public async Task<SmartThrottleResult> GetSmartThrottleRateAsync(string organizationId, string projectId)
+    {
+        var organizationTask = _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+        var projectTask = _projectRepository.GetByIdAsync(projectId, o => o.Cache());
+        await Task.WhenAll(organizationTask, projectTask);
+
+        var organization = await organizationTask;
+        var project = await projectTask;
+        if (organization is null || project is null)
+            return SmartThrottleResult.NoThrottle;
+
+        return (await GetEventIngestAllowanceAsync(organization, project)).SmartThrottle;
+    }
+
+    public int GetEffectiveProjectLimit(Project project, Organization organization)
+    {
+        ArgumentNullException.ThrowIfNull(project);
+        ArgumentNullException.ThrowIfNull(organization);
+        return GetEffectiveProjectLimit(project.IngestLimit, organization.GetMaxEventsPerMonthWithBonus(_timeProvider));
+    }
+
+    public int GetEffectiveProjectLimit(ProjectIngestLimit? ingestLimit, Organization organization)
+    {
+        ArgumentNullException.ThrowIfNull(organization);
+        return GetEffectiveProjectLimit(ingestLimit, organization.GetMaxEventsPerMonthWithBonus(_timeProvider));
+    }
+
+    private static int GetEffectiveProjectLimit(Project project, int maxEventsPerMonth)
+    {
+        return GetEffectiveProjectLimit(project.IngestLimit, maxEventsPerMonth);
+    }
+
+    private static int GetEffectiveProjectLimit(ProjectIngestLimit? ingestLimit, int maxEventsPerMonth)
+    {
+        if (ingestLimit is null)
+            return -1;
+
+        if (ingestLimit.Type is ProjectIngestLimitType.Fixed)
+        {
+            if (ingestLimit.FixedLimit is not > 0)
+                return -1;
+
+            return maxEventsPerMonth < 0
+                ? ingestLimit.FixedLimit.Value
+                : Math.Min(ingestLimit.FixedLimit.Value, maxEventsPerMonth);
+        }
+
+        if (ingestLimit.Type is not ProjectIngestLimitType.PercentOfOrganizationLimit ||
+            ingestLimit.PercentOfOrganizationLimit is not > 0 or > 100 ||
+            maxEventsPerMonth < 0)
+            return -1;
+
+        return Math.Min(maxEventsPerMonth, decimal.ToInt32(decimal.Ceiling(maxEventsPerMonth * ingestLimit.PercentOfOrganizationLimit.Value / 100m)));
+    }
+
+    private async Task<AcceptedUsageTotals> GetAcceptedUsageTotalsAsync(DateTime utcNow, Organization organization, Project project)
+    {
+        string organizationTotalKey = GetTotalCacheKey(utcNow, organization.Id);
+        string projectTotalKey = GetTotalCacheKey(utcNow, organization.Id, project.Id);
+        string organizationCurrentKey = GetBucketTotalCacheKey(utcNow, organization.Id);
+        string projectCurrentKey = GetBucketTotalCacheKey(utcNow, organization.Id, project.Id);
+        string organizationPreviousKey = GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organization.Id);
+        string projectPreviousKey = GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organization.Id, project.Id);
+
+        var values = await _cache.GetAllAsync<int>([
+            organizationTotalKey,
+            projectTotalKey,
+            organizationCurrentKey,
+            projectCurrentKey,
+            organizationPreviousKey,
+            projectPreviousKey
+        ]);
+
+        int organizationCurrent = GetCachedValue(values, organizationCurrentKey);
+        int projectCurrent = GetCachedValue(values, projectCurrentKey);
+        bool includePreviousBucket = GetTotalBucket(utcNow) == GetTotalBucket(utcNow.Subtract(_bucketSize));
+        int organizationTotal = GetCachedValue(values, organizationTotalKey, organization.GetCurrentUsage(_timeProvider).Total)
+            + organizationCurrent
+            + (includePreviousBucket ? GetCachedValue(values, organizationPreviousKey) : 0);
+        int projectTotal = GetCachedValue(values, projectTotalKey, project.GetCurrentUsage(_timeProvider).Total)
+            + projectCurrent
+            + (includePreviousBucket ? GetCachedValue(values, projectPreviousKey) : 0);
+
+        return new AcceptedUsageTotals(organizationTotal, projectTotal, organizationCurrent, projectCurrent);
+    }
+
+    private static int GetCachedValue(IDictionary<string, CacheValue<int>> values, string key, int defaultValue = 0)
+    {
+        return values.TryGetValue(key, out var value) && value.HasValue ? value.Value : defaultValue;
+    }
+
+    private int GetOrganizationEventsLeft(int maxEventsPerMonth, int currentTotal, int currentBucketTotal)
+    {
+        if (maxEventsPerMonth < 0)
+            return Int32.MaxValue;
+
+        int monthlyEventsLeft = Math.Max(0, maxEventsPerMonth - currentTotal);
+        int bucketEventsLeft = Math.Max(0, GetBucketEventLimit(maxEventsPerMonth) - currentBucketTotal);
+        return Math.Min(monthlyEventsLeft, bucketEventsLeft);
+    }
+
+    private async Task<SmartThrottleResult> GetSmartThrottleResultAsync(DateTime utcNow, Organization organization, int maxEventsPerMonth, AcceptedUsageTotals totals, int submittedEventCount)
+    {
+        if (!_appOptions.EnableSmartProjectThrottling || maxEventsPerMonth <= 0)
+            return SmartThrottleResult.NoThrottle;
+
+        int remainingAllowance = Math.Max(0, maxEventsPerMonth - totals.OrganizationTotal);
+        if (remainingAllowance <= 0)
+            return SmartThrottleResult.NoThrottle;
+
+        double windowsLeft = Math.Max(1, Math.Ceiling((utcNow.EndOfMonth() - utcNow).TotalMinutes / _bucketSize.TotalMinutes));
+        double sustainableWindowAllowance = remainingAllowance / windowsLeft * 10;
+        bool isColdBucket = totals.OrganizationCurrentBucket == 0 && totals.ProjectCurrentBucket == 0;
+        // Do not turn a normal small first post into a 5% sample merely because it belongs to one
+        // project. The explicit organization/project allowance still caps it; smart throttling is
+        // reserved for meaningfully noisy cold-bucket batches.
+        if (isColdBucket && submittedEventCount < MinimumColdBucketSmartThrottleBatchSize)
+            return SmartThrottleResult.NoThrottle;
+
+        int projectedOrganizationCurrentBucket = checked(totals.OrganizationCurrentBucket + submittedEventCount);
+        int projectedProjectCurrentBucket = checked(totals.ProjectCurrentBucket + submittedEventCount);
+        if (projectedOrganizationCurrentBucket < sustainableWindowAllowance * 0.8 || projectedProjectCurrentBucket <= 0)
+            return SmartThrottleResult.NoThrottle;
+
+        int projectCount = (int)Math.Max(1, (await _projectRepository.GetCountByOrganizationIdAsync(organization.Id)).Total);
+        if (projectCount <= 1)
+            return SmartThrottleResult.NoThrottle;
+
+        double fairShareWindowAllowance = sustainableWindowAllowance / projectCount;
+        double fairShareRatio = fairShareWindowAllowance > 0 ? projectedProjectCurrentBucket / fairShareWindowAllowance : Double.PositiveInfinity;
+        if (fairShareRatio <= 2)
+            return SmartThrottleResult.NoThrottle;
+
+        var result = new SmartThrottleResult
+        {
+            IsThrottled = true,
+            SampleRate = SmartThrottleResult.DefaultSampleRate,
+            ProjectShare = (double)(totals.ProjectTotal + submittedEventCount) / Math.Max(1, totals.OrganizationTotal + submittedEventCount),
+            FairShareRatio = fairShareRatio,
+            CurrentProjectUsage = totals.ProjectTotal + submittedEventCount,
+            FairShareLimit = maxEventsPerMonth / projectCount
+        };
+        return result;
+    }
+
+    private async Task ActivateSmartThrottleAsync(DateTime utcNow, Organization organization, Project project, SmartThrottleResult result)
+    {
+        string stateKey = GetProjectSmartThrottleKey(utcNow, organization.Id, project.Id);
+        bool isNewTransition;
+        try
+        {
+            isNewTransition = await _cache.AddAsync(stateKey, result, _bucketSize + TimeSpan.FromMinutes(1));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to record smart throttle state for project {ProjectId}: {Message}", project.Id, ex.Message);
+            return;
+        }
+
+        if (isNewTransition)
+        {
+            _logger.LogInformation("Smart project throttling activated for {OrganizationId}/{ProjectId} at {SampleRate:P0}; project usage {ProjectUsage}, fair-share limit {FairShareLimit}",
+                organization.Id, project.Id, result.SampleRate, result.CurrentProjectUsage, result.FairShareLimit);
+        }
+
+        string notificationKey = GetSmartThrottleNotificationKey(utcNow, organization.Id, project.Id);
+        bool notificationClaimed = false;
+        try
+        {
+            var notificationTtl = utcNow.EndOfMonth() - utcNow + TimeSpan.FromDays(1);
+            notificationClaimed = await _cache.AddAsync(notificationKey, true, notificationTtl);
+            if (!notificationClaimed)
+                return;
+
+            await _messagePublisher.PublishAsync(new ProjectSmartThrottleApplied
+            {
+                OrganizationId = organization.Id,
+                ProjectId = project.Id,
+                SampleRate = result.SampleRate,
+                CurrentEventCount = result.CurrentProjectUsage,
+                EventLimit = result.FairShareLimit,
+                UsagePeriod = GetTotalBucket(utcNow)
+            });
+        }
+        catch (Exception ex)
+        {
+            if (notificationClaimed)
+            {
+                try
+                {
+                    await _cache.RemoveAsync(notificationKey);
+                }
+                catch (Exception cleanupException)
+                {
+                    _logger.LogWarning(cleanupException, "Failed to release smart throttle notification claim for project {ProjectId}", project.Id);
+                }
+            }
+
+            _logger.LogError(ex, "Failed to publish smart throttle notification for project {ProjectId}: {Message}", project.Id, ex.Message);
+        }
+    }
+
+    public async Task<IReadOnlyDictionary<string, SmartThrottleResult>> GetProjectSmartThrottleStatesAsync(IReadOnlyCollection<(string OrganizationId, string ProjectId)> projects)
+    {
+        if (!_appOptions.EnableSmartProjectThrottling || projects.Count == 0)
+            return new Dictionary<string, SmartThrottleResult>();
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        var keysByProjectId = projects.ToDictionary(
+            project => project.ProjectId,
+            project => GetProjectSmartThrottleKey(utcNow, project.OrganizationId, project.ProjectId));
+        var values = await _cache.GetAllAsync<SmartThrottleResult>(keysByProjectId.Values);
+
+        return keysByProjectId
+            .Where(pair => values.TryGetValue(pair.Value, out var value) && value.HasValue && value.Value.IsThrottled)
+            .ToDictionary(pair => pair.Key, pair => values[pair.Value].Value);
+    }
+
+    public async Task<bool> IsProjectSmartThrottledAsync(string organizationId, string projectId)
+    {
+        if (!_appOptions.EnableSmartProjectThrottling)
+            return false;
+
+        var state = await _cache.GetAsync<SmartThrottleResult>(GetProjectSmartThrottleKey(_timeProvider.GetUtcNow().UtcDateTime, organizationId, projectId));
+        return state is { HasValue: true, Value.IsThrottled: true };
+    }
+
+    public async Task EvaluateBudgetAlertsAfterSettingsChangeAsync(Organization organization, IReadOnlyCollection<int> thresholds)
+    {
+        if (organization.BudgetAlertSettings is not { Enabled: true } || thresholds.Count == 0)
+            return;
+
+        int maxEventsPerMonth = organization.GetMaxEventsPerMonthWithBonus(_timeProvider);
+        if (maxEventsPerMonth <= 0)
+            return;
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        string totalKey = GetTotalCacheKey(utcNow, organization.Id);
+        string currentKey = GetBucketTotalCacheKey(utcNow, organization.Id);
+        string previousKey = GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organization.Id);
+        var values = await _cache.GetAllAsync<int>([totalKey, currentKey, previousKey]);
+        bool includePreviousBucket = GetTotalBucket(utcNow) == GetTotalBucket(utcNow.Subtract(_bucketSize));
+        int currentTotal = GetCachedValue(values, totalKey, organization.GetCurrentUsage(_timeProvider).Total)
+            + GetCachedValue(values, currentKey)
+            + (includePreviousBucket ? GetCachedValue(values, previousKey) : 0);
+
+        await PublishCrossedBudgetAlertsAsync(organization, 0, currentTotal, maxEventsPerMonth, thresholds);
+    }
+
+    private async Task PublishCrossedBudgetAlertsAsync(Organization organization, int previousTotal, int currentTotal, int maxEventsPerMonth, IReadOnlyCollection<int>? thresholds = null)
+    {
+        if (organization.BudgetAlertSettings is not { Enabled: true, Thresholds: not null } || maxEventsPerMonth <= 0)
+            return;
+
+        thresholds ??= organization.BudgetAlertSettings.Thresholds;
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        foreach (int threshold in thresholds.Order())
+        {
+            if (threshold is <= 0 or >= 100)
+                continue;
+
+            int thresholdEventCount = GetBudgetThresholdEventCount(maxEventsPerMonth, threshold);
+            if (previousTotal >= thresholdEventCount || currentTotal < thresholdEventCount)
+                continue;
+
+            string alertSentKey = GetBudgetAlertSentKey(utcNow, organization.Id, threshold);
+            bool alertClaimed = false;
+            try
+            {
+                var alertTtl = utcNow.EndOfMonth() - utcNow + TimeSpan.FromDays(1);
+                alertClaimed = await _cache.AddAsync(alertSentKey, true, alertTtl);
+                if (!alertClaimed)
+                    continue;
+
+                await _messagePublisher.PublishAsync(new OrganizationBudgetAlert
+                {
+                    OrganizationId = organization.Id,
+                    Threshold = threshold,
+                    ThresholdEventCount = thresholdEventCount,
+                    CurrentEventCount = currentTotal,
+                    EventLimit = maxEventsPerMonth,
+                    UsagePeriod = GetTotalBucket(utcNow)
+                });
+            }
+            catch (Exception ex)
+            {
+                if (alertClaimed)
+                {
+                    try
+                    {
+                        await _cache.RemoveAsync(alertSentKey);
+                    }
+                    catch (Exception cleanupException)
+                    {
+                        _logger.LogWarning(cleanupException, "Failed to release budget alert {Threshold}% claim for organization {OrganizationId}: {Message}", threshold, organization.Id, ex.Message);
+                    }
+                }
+
+                _logger.LogError(ex, "Failed to publish budget alert {Threshold}% for organization {OrganizationId}: {Message}", threshold, organization.Id, ex.Message);
+            }
+        }
+    }
+
+    internal static int GetBudgetThresholdEventCount(int eventLimit, int threshold)
+    {
+        return checked((int)((threshold * (long)eventLimit + 99) / 100));
+    }
+
+    private sealed record AcceptedUsageTotals(int OrganizationTotal, int ProjectTotal, int OrganizationCurrentBucket, int ProjectCurrentBucket);
+}
diff --git a/src/Exceptionless.Core/Services/UsageService.Reservations.cs b/src/Exceptionless.Core/Services/UsageService.Reservations.cs
new file mode 100644
index 0000000000..6b61c2ea19
--- /dev/null
+++ b/src/Exceptionless.Core/Services/UsageService.Reservations.cs
@@ -0,0 +1,594 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text.Json;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Models;
+using Exceptionless.DateTimeExtensions;
+using Foundatio.Lock;
+
+namespace Exceptionless.Core.Services;
+
+public partial class UsageService
+{
+    private static readonly TimeSpan IngestReservationLockLifetime = TimeSpan.FromSeconds(30);
+    private static readonly TimeSpan IngestReservationRetention = TimeSpan.FromDays(35);
+
+    internal async Task<EventIngestReservation> ReserveEventIngestAsync(Organization organization, Project project, string reservationId,
+        IReadOnlyCollection<EventIngestCandidate> candidates, CancellationToken cancellationToken = default, bool isRedelivery = false)
+    {
+        using var reservationTimer = AppDiagnostics.IngestReservationReserveTime.StartTimer();
+        ArgumentNullException.ThrowIfNull(organization);
+        ArgumentNullException.ThrowIfNull(project);
+        ArgumentException.ThrowIfNullOrEmpty(reservationId);
+        if (!String.Equals(project.OrganizationId, organization.Id, StringComparison.Ordinal))
+            throw new ArgumentException("The project does not belong to the organization.", nameof(project));
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        int maxEventsPerMonth = organization.GetMaxEventsPerMonthWithBonus(_timeProvider);
+        int effectiveProjectLimit = GetEffectiveProjectLimit(project, maxEventsPerMonth);
+
+        // New unlimited posts need no cache or organization lock. A redelivery must finish any
+        // tracked reservation created before the plan or project cap changed.
+        if (maxEventsPerMonth < 0 && effectiveProjectLimit < 0 &&
+            (!isRedelivery || !await _cache.ExistsAsync(GetIngestReservationKey(organization.Id, reservationId))))
+            return EventIngestReservation.Unlimited(reservationId, organization.Id, project.Id, GetTotalBucket(utcNow), utcNow.Floor(_bucketSize), candidates);
+
+        SmartThrottleResult? smartThrottleToActivate = null;
+        EventIngestReservation reservation;
+        int newlyBlockedCount = 0;
+        int newlySmartThrottleBlockedCount = 0;
+        var lockWait = Stopwatch.StartNew();
+        await using (await _lockProvider.AcquireAsync(GetIngestReservationLockKey(organization.Id), IngestReservationLockLifetime, cancellationToken))
+        {
+            AppDiagnostics.IngestReservationLockWait.Record(lockWait.Elapsed.TotalMilliseconds);
+            string reservationKey = GetIngestReservationKey(organization.Id, reservationId);
+            var existingValue = await _cache.GetAsync<string>(reservationKey);
+            EventIngestReservationRecord? existing = existingValue.HasValue
+                ? DeserializeReservation(existingValue.Value, candidates.Count)
+                : null;
+            if (existing is not null && existing.SubmittedCount != candidates.Count)
+                throw new UsageServiceException($"Ingest reservation '{reservationId}' was retried with a different event count.");
+
+            if (existing?.State is EventIngestReservationState.Active or EventIngestReservationState.Completed)
+            {
+                reservation = existing.ToReservation();
+                if (existing.State is EventIngestReservationState.Active && existing.SmartThrottle.IsThrottled)
+                    smartThrottleToActivate = existing.SmartThrottle;
+            }
+            else
+            {
+                var creation = await CreateTrackedReservationAsync(
+                    utcNow,
+                    organization,
+                    project,
+                    reservationId,
+                    candidates,
+                    maxEventsPerMonth,
+                    effectiveProjectLimit,
+                    reservationKey,
+                    existingValue.HasValue ? existingValue.Value : null,
+                    existing);
+                reservation = creation.Record.ToReservation();
+                newlyBlockedCount = creation.NewlyBlockedCount;
+                newlySmartThrottleBlockedCount = creation.NewlySmartThrottleBlockedCount;
+                if (creation.Record.SmartThrottle.IsThrottled)
+                    smartThrottleToActivate = creation.Record.SmartThrottle;
+            }
+        }
+
+        if (newlyBlockedCount > 0)
+            AppDiagnostics.EventsBlocked.Add(newlyBlockedCount);
+        if (newlySmartThrottleBlockedCount > 0)
+            AppDiagnostics.EventsSmartThrottled.Add(newlySmartThrottleBlockedCount);
+        if (smartThrottleToActivate is not null)
+            await ActivateSmartThrottleAsync(utcNow, organization, project, smartThrottleToActivate);
+
+        return reservation;
+    }
+
+    private async Task<ReservationCreationResult> CreateTrackedReservationAsync(
+        DateTime utcNow,
+        Organization organization,
+        Project project,
+        string reservationId,
+        IReadOnlyCollection<EventIngestCandidate> candidates,
+        int maxEventsPerMonth,
+        int effectiveProjectLimit,
+        string reservationKey,
+        string? existingReservationValue,
+        EventIngestReservationRecord? previous)
+    {
+        IReadOnlyCollection<EventIngestCandidate> eligibleCandidates = candidates;
+        int previousBlockedCount = 0;
+        if (previous is not null)
+        {
+            if (previous.State is not EventIngestReservationState.Released)
+                throw new UsageServiceException($"Ingest reservation '{reservationId}' has an invalid state.");
+            if (previous.SubmittedCount != candidates.Count)
+                throw new UsageServiceException($"Ingest reservation '{reservationId}' was retried with a different event count.");
+
+            var previouslyAcceptedIndexes = previous.AcceptedIndexes.ToHashSet();
+            eligibleCandidates = candidates.Where(candidate => previouslyAcceptedIndexes.Contains(candidate.Index)).ToArray();
+            previousBlockedCount = previous.BlockedCount;
+        }
+
+        int[] recentUsagePeriods = GetRecentUsagePeriods(utcNow);
+        string[] organizationReservedKeys = recentUsagePeriods.Select(period => GetIngestReservedKey(period, organization.Id)).ToArray();
+        string[] projectReservedKeys = recentUsagePeriods.Select(period => GetIngestReservedKey(period, organization.Id, project.Id)).ToArray();
+        string organizationBlockedKey = GetBucketBlockedCacheKey(utcNow, organization.Id);
+        string projectBlockedKey = GetBucketBlockedCacheKey(utcNow, organization.Id, project.Id);
+        string[] ledgerKeys = organizationReservedKeys
+            .Concat(projectReservedKeys)
+            .Append(organizationBlockedKey)
+            .Append(projectBlockedKey)
+            .ToArray();
+        var ledgerValues = await _cache.GetAllAsync<string>(ledgerKeys);
+        int organizationReserved = organizationReservedKeys.Sum(key => GetLedgerInt(ledgerValues, key));
+        int projectReserved = projectReservedKeys.Sum(key => GetLedgerInt(ledgerValues, key));
+        string organizationReservedKey = organizationReservedKeys[0];
+        string projectReservedKey = projectReservedKeys[0];
+        int currentOrganizationReserved = GetLedgerInt(ledgerValues, organizationReservedKey);
+        int currentProjectReserved = GetLedgerInt(ledgerValues, projectReservedKey);
+        var totals = await GetAcceptedUsageTotalsAsync(utcNow, organization, project);
+        totals = totals with
+        {
+            OrganizationTotal = checked(totals.OrganizationTotal + organizationReserved),
+            ProjectTotal = checked(totals.ProjectTotal + projectReserved),
+            // Every outstanding reservation counts against the active bucket. This is deliberately
+            // conservative and closes both five-minute and monthly rollover races.
+            OrganizationCurrentBucket = checked(totals.OrganizationCurrentBucket + organizationReserved),
+            ProjectCurrentBucket = checked(totals.ProjectCurrentBucket + projectReserved)
+        };
+
+        var allowance = await CalculateEventIngestAllowanceAsync(utcNow, organization, project, maxEventsPerMonth,
+            effectiveProjectLimit, totals, eligibleCandidates.Count, false);
+        var selectedCandidates = eligibleCandidates;
+        int smartThrottleBlockedCount = 0;
+        if (allowance.SmartThrottle.IsThrottled)
+        {
+            int sampleThreshold = (int)(allowance.SmartThrottle.SampleRate * 10_000);
+            selectedCandidates = eligibleCandidates.Where(candidate => candidate.Hash % 10_000 < (ulong)sampleThreshold).ToArray();
+            smartThrottleBlockedCount = eligibleCandidates.Count - selectedCandidates.Count;
+        }
+
+        if (selectedCandidates.Count > allowance.EventsLeft)
+            selectedCandidates = selectedCandidates.OrderBy(candidate => candidate.Hash).Take(allowance.EventsLeft).ToArray();
+
+        int[] acceptedIndexes = selectedCandidates.OrderBy(candidate => candidate.Index).Select(candidate => candidate.Index).ToArray();
+        var smartThrottle = allowance.SmartThrottle.IsThrottled
+            ? new SmartThrottleResult
+            {
+                IsThrottled = true,
+                SampleRate = allowance.SmartThrottle.SampleRate,
+                ProjectShare = (double)(totals.ProjectTotal + acceptedIndexes.Length) / Math.Max(1, totals.OrganizationTotal + acceptedIndexes.Length),
+                FairShareRatio = allowance.SmartThrottle.FairShareRatio,
+                CurrentProjectUsage = totals.ProjectTotal + acceptedIndexes.Length,
+                FairShareLimit = allowance.SmartThrottle.FairShareLimit
+            }
+            : SmartThrottleResult.NoThrottle;
+
+        var record = new EventIngestReservationRecord(
+            reservationId,
+            Guid.NewGuid(),
+            organization.Id,
+            project.Id,
+            GetTotalBucket(utcNow),
+            utcNow.Floor(_bucketSize),
+            candidates.Count,
+            acceptedIndexes,
+            smartThrottle,
+            EventIngestReservationState.Active,
+            0,
+            null,
+            0);
+        int newlyBlockedCount = checked(record.BlockedCount - previousBlockedCount);
+        if (newlyBlockedCount < 0)
+            throw new UsageServiceException($"Ingest reservation '{reservationId}' cannot accept events that were previously blocked.");
+
+        string serializedRecord = JsonSerializer.Serialize(record);
+        AppDiagnostics.IngestReservationRecordSize.Record(serializedRecord.Length);
+        var updatedValues = new Dictionary<string, AtomicCacheValue>
+        {
+            [reservationKey] = new(serializedRecord, IngestReservationRetention),
+            [organizationReservedKey] = new(FormatInt(checked(currentOrganizationReserved + record.ReservedCount)), IngestReservationRetention),
+            [projectReservedKey] = new(FormatInt(checked(currentProjectReserved + record.ReservedCount)), IngestReservationRetention)
+        };
+        var expectedValues = new Dictionary<string, string?>
+        {
+            [reservationKey] = existingReservationValue,
+            [organizationReservedKey] = GetCachedString(ledgerValues, organizationReservedKey),
+            [projectReservedKey] = GetCachedString(ledgerValues, projectReservedKey)
+        };
+        Dictionary<string, string>? usageSetMembers = null;
+        if (newlyBlockedCount > 0)
+        {
+            updatedValues[organizationBlockedKey] = new(
+                FormatInt(checked(GetLedgerInt(ledgerValues, organizationBlockedKey) + newlyBlockedCount)),
+                TimeSpan.FromHours(8));
+            updatedValues[projectBlockedKey] = new(
+                FormatInt(checked(GetLedgerInt(ledgerValues, projectBlockedKey) + newlyBlockedCount)),
+                TimeSpan.FromHours(8));
+            expectedValues[organizationBlockedKey] = GetCachedString(ledgerValues, organizationBlockedKey);
+            expectedValues[projectBlockedKey] = GetCachedString(ledgerValues, projectBlockedKey);
+            usageSetMembers = new Dictionary<string, string>
+            {
+                [GetOrganizationSetKey(utcNow)] = organization.Id,
+                [GetProjectSetKey(utcNow)] = project.Id
+            };
+        }
+
+        if (!await _atomicCacheBatch.TrySetAllAsync(expectedValues, updatedValues, usageSetMembers, TimeSpan.FromHours(8)))
+        {
+            AppDiagnostics.IngestReservationCasConflicts.Add(1);
+            throw new UsageServiceException($"Ingest reservation '{reservationId}' changed while it was being reserved; retry the queue entry.");
+        }
+
+        return new ReservationCreationResult(record, newlyBlockedCount, smartThrottleBlockedCount);
+    }
+
+    internal async Task CompleteEventIngestReservationAsync(EventIngestReservation reservation, Organization organization, int processedCount,
+        IReadOnlyCollection<int>? retryIndexes = null, int discardedCount = 0)
+    {
+        using var reservationTimer = AppDiagnostics.IngestReservationCompleteTime.StartTimer();
+        ArgumentNullException.ThrowIfNull(reservation);
+        ArgumentNullException.ThrowIfNull(organization);
+        if (discardedCount is < 0 || discardedCount > reservation.ReservedCount)
+            throw new ArgumentOutOfRangeException(nameof(discardedCount));
+        if (!reservation.IsTracked)
+        {
+            if (!String.Equals(reservation.OrganizationId, organization.Id, StringComparison.Ordinal))
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' does not belong to organization '{organization.Id}'.");
+            if (processedCount is < 0 || processedCount > reservation.ReservedCount)
+                throw new ArgumentOutOfRangeException(nameof(processedCount));
+            await IncrementTotalAsync(organization, reservation.ProjectId, processedCount);
+            await IncrementDiscardedAsync(organization.Id, reservation.ProjectId, discardedCount);
+            return;
+        }
+
+        DateTime completionBucketUtc;
+        long organizationBucketTotal;
+        int committedCount;
+        string projectId;
+        var lockWait = Stopwatch.StartNew();
+        await using (await _lockProvider.AcquireAsync(GetIngestReservationLockKey(reservation.OrganizationId), IngestReservationLockLifetime, CancellationToken.None))
+        {
+            AppDiagnostics.IngestReservationLockWait.Record(lockWait.Elapsed.TotalMilliseconds);
+            string reservationKey = GetIngestReservationKey(reservation.OrganizationId, reservation.Id);
+            var recordValue = await _cache.GetAsync<string>(reservationKey);
+            if (!recordValue.HasValue)
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' is missing and cannot be completed safely.");
+
+            var record = DeserializeReservation(recordValue.Value);
+            ValidateReservationIdentity(record, reservation, organization.Id);
+            projectId = record.ProjectId;
+            if (record.State is EventIngestReservationState.Completed)
+            {
+                completionBucketUtc = record.CompletionBucketUtc ?? throw new UsageServiceException($"Completed ingest reservation '{reservation.Id}' is missing its completion bucket.");
+                organizationBucketTotal = record.CompletionOrganizationBucketTotal;
+                committedCount = record.ProcessedCount;
+            }
+            else
+            {
+                if (record.State is not EventIngestReservationState.Active)
+                    throw new UsageServiceException($"Ingest reservation '{reservation.Id}' is not active and cannot be completed.");
+                if (processedCount is < 0 || processedCount > record.ReservedCount)
+                    throw new ArgumentOutOfRangeException(nameof(processedCount));
+                int[] pendingRetries = retryIndexes?.Distinct().Order().ToArray() ?? [];
+                if (pendingRetries.Any(index => !record.AcceptedIndexes.Contains(index)) || processedCount + pendingRetries.Length > record.ReservedCount)
+                    throw new ArgumentOutOfRangeException(nameof(retryIndexes));
+
+                completionBucketUtc = _timeProvider.GetUtcNow().UtcDateTime.Floor(_bucketSize);
+                string organizationReservedKey = GetIngestReservedKey(record.UsagePeriod, record.OrganizationId);
+                string projectReservedKey = GetIngestReservedKey(record.UsagePeriod, record.OrganizationId, record.ProjectId);
+                string organizationBucketKey = GetBucketTotalCacheKey(completionBucketUtc, record.OrganizationId);
+                string projectBucketKey = GetBucketTotalCacheKey(completionBucketUtc, record.OrganizationId, record.ProjectId);
+                string organizationDiscardedKey = GetBucketDiscardedCacheKey(completionBucketUtc, record.OrganizationId);
+                string projectDiscardedKey = GetBucketDiscardedCacheKey(completionBucketUtc, record.OrganizationId, record.ProjectId);
+                var keys = new List<string> { reservationKey, organizationReservedKey, projectReservedKey, organizationBucketKey, projectBucketKey };
+                if (discardedCount > 0)
+                    keys.AddRange([organizationDiscardedKey, projectDiscardedKey]);
+                var values = await _cache.GetAllAsync<string>(keys);
+                int organizationReserved = GetLedgerInt(values, organizationReservedKey);
+                int projectReserved = GetLedgerInt(values, projectReservedKey);
+                if (organizationReserved < record.ReservedCount || projectReserved < record.ReservedCount)
+                    throw new UsageServiceException($"Ingest reservation '{reservation.Id}' counters are lower than its reserved event count.");
+
+                organizationBucketTotal = checked(GetLedgerInt(values, organizationBucketKey) + processedCount);
+                record = record with
+                {
+                    State = EventIngestReservationState.Completed,
+                    ProcessedCount = processedCount,
+                    RetryIndexes = pendingRetries,
+                    CompletionBucketUtc = completionBucketUtc,
+                    CompletionOrganizationBucketTotal = organizationBucketTotal
+                };
+                string serializedRecord = JsonSerializer.Serialize(record);
+                AppDiagnostics.IngestReservationRecordSize.Record(serializedRecord.Length);
+                var updatedValues = new Dictionary<string, AtomicCacheValue>
+                {
+                    [reservationKey] = new(serializedRecord, IngestReservationRetention),
+                    [organizationReservedKey] = new(FormatInt(organizationReserved - record.ReservedCount), IngestReservationRetention),
+                    [projectReservedKey] = new(FormatInt(projectReserved - record.ReservedCount), IngestReservationRetention),
+                    [organizationBucketKey] = new(FormatInt(organizationBucketTotal), TimeSpan.FromHours(8)),
+                    [projectBucketKey] = new(FormatInt(checked(GetLedgerInt(values, projectBucketKey) + processedCount)), TimeSpan.FromHours(8))
+                };
+                var usageSetMembers = new Dictionary<string, string>
+                {
+                    [GetOrganizationSetKey(completionBucketUtc)] = record.OrganizationId,
+                    [GetProjectSetKey(completionBucketUtc)] = record.ProjectId
+                };
+                if (discardedCount > 0)
+                {
+                    updatedValues[organizationDiscardedKey] = new(FormatInt(checked(GetLedgerInt(values, organizationDiscardedKey) + discardedCount)), TimeSpan.FromHours(8));
+                    updatedValues[projectDiscardedKey] = new(FormatInt(checked(GetLedgerInt(values, projectDiscardedKey) + discardedCount)), TimeSpan.FromHours(8));
+                }
+                if (!await _atomicCacheBatch.TrySetAllAsync(GetExpectedValues(values, keys), updatedValues, usageSetMembers, TimeSpan.FromHours(8)))
+                {
+                    AppDiagnostics.IngestReservationCasConflicts.Add(1);
+                    throw new UsageServiceException($"Ingest reservation '{reservation.Id}' changed while it was being completed; retry the queue entry.");
+                }
+
+                committedCount = processedCount;
+                if (discardedCount > 0)
+                    AppDiagnostics.EventsDiscarded.Add(discardedCount);
+            }
+        }
+
+        if (committedCount > 0)
+            await PublishUsageIncrementNotificationsAsync(organization, projectId, committedCount, completionBucketUtc, organizationBucketTotal);
+    }
+
+    internal async Task<bool> RetryPendingEventIngestAsync(EventIngestReservation reservation, Func<int, Task<bool>> enqueueRetry)
+    {
+        // Serialize retry dispatch for duplicate deliveries of this completed post. This lock
+        // is separate from the organization allowance lock and is used only for failed events.
+        await using var retryLock = await _lockProvider.AcquireAsync(
+            $"usage:ingest-retries:{reservation.OrganizationId}:{reservation.Id}", TimeSpan.FromMinutes(5), CancellationToken.None);
+        string key = GetIngestReservationKey(reservation.OrganizationId, reservation.Id);
+        var value = await _cache.GetAsync<string>(key);
+        if (!value.HasValue)
+            throw new UsageServiceException($"Ingest reservation '{reservation.Id}' is missing while dispatching retries.");
+
+        var record = DeserializeReservation(value.Value);
+        ValidateReservationIdentity(record, reservation);
+        if (record.State is not EventIngestReservationState.Completed)
+            throw new UsageServiceException($"Ingest reservation '{reservation.Id}' must be completed before dispatching retries.");
+
+        foreach (int index in record.RetryIndexes)
+        {
+            if (!await enqueueRetry(index))
+                return false;
+
+            // A failed acknowledgement keeps the event pending for at-least-once delivery.
+            await AcknowledgeEventIngestRetryAsync(reservation, index);
+            await retryLock.RenewAsync();
+        }
+
+        return true;
+    }
+
+    private async Task AcknowledgeEventIngestRetryAsync(EventIngestReservation reservation, int index)
+    {
+        await using (await _lockProvider.AcquireAsync(GetIngestReservationLockKey(reservation.OrganizationId), IngestReservationLockLifetime, CancellationToken.None))
+        {
+            string key = GetIngestReservationKey(reservation.OrganizationId, reservation.Id);
+            var value = await _cache.GetAsync<string>(key);
+            if (!value.HasValue)
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' is missing while acknowledging a retry.");
+
+            var record = DeserializeReservation(value.Value);
+            ValidateReservationIdentity(record, reservation);
+            if (record.State is not EventIngestReservationState.Completed)
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' must be completed before acknowledging a retry.");
+            if (!record.RetryIndexes.Contains(index))
+                return;
+
+            record = record with { RetryIndexes = record.RetryIndexes.Where(pending => pending != index).ToArray() };
+            if (!await _atomicCacheBatch.TrySetAllAsync(
+                new Dictionary<string, string?> { [key] = value.Value },
+                new Dictionary<string, AtomicCacheValue> { [key] = new(JsonSerializer.Serialize(record), IngestReservationRetention) }))
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' changed while acknowledging a retry.");
+        }
+    }
+
+    internal async Task ReleaseEventIngestReservationAsync(EventIngestReservation reservation)
+    {
+        using var reservationTimer = AppDiagnostics.IngestReservationReleaseTime.StartTimer();
+        ArgumentNullException.ThrowIfNull(reservation);
+        if (!reservation.IsTracked)
+            return;
+
+        var lockWait = Stopwatch.StartNew();
+        await using (await _lockProvider.AcquireAsync(GetIngestReservationLockKey(reservation.OrganizationId), IngestReservationLockLifetime, CancellationToken.None))
+        {
+            AppDiagnostics.IngestReservationLockWait.Record(lockWait.Elapsed.TotalMilliseconds);
+            string reservationKey = GetIngestReservationKey(reservation.OrganizationId, reservation.Id);
+            var recordValue = await _cache.GetAsync<string>(reservationKey);
+            if (!recordValue.HasValue)
+                return;
+
+            var record = DeserializeReservation(recordValue.Value);
+            ValidateReservationIdentity(record, reservation);
+            if (record.State is EventIngestReservationState.Released or EventIngestReservationState.Completed)
+                return;
+            if (record.State is not EventIngestReservationState.Active)
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' is not active and cannot be released.");
+
+            string organizationReservedKey = GetIngestReservedKey(record.UsagePeriod, record.OrganizationId);
+            string projectReservedKey = GetIngestReservedKey(record.UsagePeriod, record.OrganizationId, record.ProjectId);
+            string[] keys = [reservationKey, organizationReservedKey, projectReservedKey];
+            var values = await _cache.GetAllAsync<string>(keys);
+            int organizationReserved = GetLedgerInt(values, organizationReservedKey);
+            int projectReserved = GetLedgerInt(values, projectReservedKey);
+            if (organizationReserved < record.ReservedCount || projectReserved < record.ReservedCount)
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' counters are lower than its reserved event count.");
+
+            string serializedRecord = JsonSerializer.Serialize(record with { State = EventIngestReservationState.Released });
+            AppDiagnostics.IngestReservationRecordSize.Record(serializedRecord.Length);
+            var updatedValues = new Dictionary<string, AtomicCacheValue>
+            {
+                [reservationKey] = new(serializedRecord, IngestReservationRetention),
+                [organizationReservedKey] = new(FormatInt(organizationReserved - record.ReservedCount), IngestReservationRetention),
+                [projectReservedKey] = new(FormatInt(projectReserved - record.ReservedCount), IngestReservationRetention)
+            };
+            if (!await _atomicCacheBatch.TrySetAllAsync(GetExpectedValues(values, keys), updatedValues))
+            {
+                AppDiagnostics.IngestReservationCasConflicts.Add(1);
+                throw new UsageServiceException($"Ingest reservation '{reservation.Id}' changed while it was being released; retry the queue entry.");
+            }
+        }
+    }
+
+    private static EventIngestReservationRecord DeserializeReservation(string value, int? submittedCount = null)
+    {
+        var record = JsonSerializer.Deserialize<EventIngestReservationRecord>(value) ?? throw new UsageServiceException("Invalid ingest reservation state.");
+        if (record.AcceptedIndexes is null || record.SmartThrottle is null || record.RetryIndexes is null)
+            throw new UsageServiceException($"Ingest reservation '{record.Id}' contains invalid state.");
+
+        int normalizedSubmittedCount = record.SubmittedCount;
+        if (normalizedSubmittedCount == 0 && submittedCount.HasValue)
+            normalizedSubmittedCount = submittedCount.Value;
+        else if (normalizedSubmittedCount == 0 && record.AcceptedIndexes.Length > 0)
+            normalizedSubmittedCount = checked(record.AcceptedIndexes.Max() + 1);
+        if (normalizedSubmittedCount != record.SubmittedCount)
+            record = record with { SubmittedCount = normalizedSubmittedCount };
+
+        if (String.IsNullOrEmpty(record.Id) || String.IsNullOrEmpty(record.OrganizationId) || String.IsNullOrEmpty(record.ProjectId))
+            throw new UsageServiceException("Ingest reservation identity is invalid.");
+        if (record.SubmittedCount < 0
+            || record.AcceptedIndexes.Any(index => index < 0 || index >= record.SubmittedCount)
+            || !record.AcceptedIndexes.SequenceEqual(record.AcceptedIndexes.Distinct().Order()))
+            throw new UsageServiceException($"Ingest reservation '{record.Id}' contains invalid accepted indexes.");
+        if (!Enum.IsDefined(record.State)
+            || record.ProcessedCount < 0
+            || record.ProcessedCount > record.ReservedCount
+            || record.RetryIndexes.Any(index => !record.AcceptedIndexes.Contains(index))
+            || !record.RetryIndexes.SequenceEqual(record.RetryIndexes.Distinct().Order())
+            || record.ProcessedCount + record.RetryIndexes.Length > record.ReservedCount
+            || record.CompletionOrganizationBucketTotal < 0)
+            throw new UsageServiceException($"Ingest reservation '{record.Id}' contains invalid transition state.");
+        if (record.State is EventIngestReservationState.Completed && record.CompletionBucketUtc is null)
+            throw new UsageServiceException($"Completed ingest reservation '{record.Id}' is missing its completion bucket.");
+
+        return record;
+    }
+
+    private static int GetLedgerInt(IDictionary<string, Foundatio.Caching.CacheValue<string>> values, string key)
+    {
+        if (!values.TryGetValue(key, out var value) || !value.HasValue)
+            return 0;
+        if (!Int32.TryParse(value.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out int result) || result < 0)
+            throw new UsageServiceException($"Usage ledger counter '{key}' is invalid.");
+
+        return result;
+    }
+
+    private static void ValidateReservationIdentity(EventIngestReservationRecord record, EventIngestReservation reservation, string? organizationId = null)
+    {
+        if (!String.Equals(record.Id, reservation.Id, StringComparison.Ordinal)
+            || !String.Equals(record.OrganizationId, reservation.OrganizationId, StringComparison.Ordinal)
+            || !String.Equals(record.ProjectId, reservation.ProjectId, StringComparison.Ordinal)
+            || record.UsagePeriod != reservation.UsagePeriod
+            || record.GenerationId != reservation.GenerationId)
+            throw new UsageServiceException($"Ingest reservation '{reservation.Id}' no longer matches its persisted generation.");
+        if (organizationId is not null && !String.Equals(record.OrganizationId, organizationId, StringComparison.Ordinal))
+            throw new UsageServiceException($"Ingest reservation '{reservation.Id}' does not belong to organization '{organizationId}'.");
+    }
+
+    private static string? GetCachedString(IDictionary<string, Foundatio.Caching.CacheValue<string>> values, string key) =>
+        values.TryGetValue(key, out var value) && value.HasValue ? value.Value : null;
+
+    private static Dictionary<string, string?> GetExpectedValues(IDictionary<string, Foundatio.Caching.CacheValue<string>> values, IEnumerable<string> keys) =>
+        keys.ToDictionary(key => key, key => GetCachedString(values, key));
+
+    private static string FormatInt(long value) => value.ToString(CultureInfo.InvariantCulture);
+    private static int[] GetRecentUsagePeriods(DateTime utcNow)
+    {
+        var periodStart = utcNow.StartOfMonth();
+        return [periodStart.ToEpoch(), periodStart.AddMonths(-1).ToEpoch(), periodStart.AddMonths(-2).ToEpoch()];
+    }
+
+    private static string GetIngestReservedKey(int usagePeriod, string organizationId, string? projectId = null) =>
+        String.IsNullOrEmpty(projectId) ? $"usage:reserved:{{{organizationId}}}:{usagePeriod}:total" : $"usage:reserved:{{{organizationId}}}:{usagePeriod}:{projectId}:total";
+    private static string GetIngestReservationKey(string organizationId, string reservationId) => $"usage:ingest-reservation:{{{organizationId}}}:{reservationId}";
+    private static string GetIngestReservationLockKey(string organizationId) => $"usage:ingest-reservation-lock:{organizationId}";
+
+    private sealed record EventIngestReservationRecord(
+        string Id,
+        Guid GenerationId,
+        string OrganizationId,
+        string ProjectId,
+        int UsagePeriod,
+        DateTime BucketUtc,
+        int SubmittedCount,
+        int[] AcceptedIndexes,
+        SmartThrottleResult SmartThrottle,
+        EventIngestReservationState State,
+        int ProcessedCount,
+        DateTime? CompletionBucketUtc,
+        long CompletionOrganizationBucketTotal)
+    {
+        // Older reservation records have no pending retry indexes.
+        public int[] RetryIndexes { get; init; } = [];
+        public int ReservedCount => AcceptedIndexes.Length;
+        public int BlockedCount => SubmittedCount - ReservedCount;
+
+        public EventIngestReservation ToReservation() => new(
+            Id,
+            GenerationId,
+            OrganizationId,
+            ProjectId,
+            UsagePeriod,
+            BucketUtc,
+            AcceptedIndexes.ToImmutableArray(),
+            SmartThrottle,
+            true,
+            State is EventIngestReservationState.Completed,
+            ProcessedCount,
+            CompletionBucketUtc);
+    }
+
+    private sealed record ReservationCreationResult(EventIngestReservationRecord Record, int NewlyBlockedCount, int NewlySmartThrottleBlockedCount);
+
+    private enum EventIngestReservationState
+    {
+        Active,
+        Completed,
+        Released
+    }
+}
+
+internal readonly record struct EventIngestCandidate(int Index, ulong Hash);
+
+internal sealed record EventIngestReservation(
+    string Id,
+    Guid GenerationId,
+    string OrganizationId,
+    string ProjectId,
+    int UsagePeriod,
+    DateTime BucketUtc,
+    ImmutableArray<int> AcceptedIndexes,
+    SmartThrottleResult SmartThrottle,
+    bool IsTracked,
+    bool IsCompleted,
+    int ProcessedCount,
+    DateTime? CompletionBucketUtc)
+{
+    public int ReservedCount => AcceptedIndexes.Length;
+
+    public static EventIngestReservation Unlimited(string id, string organizationId, string projectId, int usagePeriod, DateTime bucketUtc,
+        IReadOnlyCollection<EventIngestCandidate> candidates) => new(
+        id,
+        Guid.Empty,
+        organizationId,
+        projectId,
+        usagePeriod,
+        bucketUtc,
+        candidates.OrderBy(candidate => candidate.Index).Select(candidate => candidate.Index).ToImmutableArray(),
+        SmartThrottleResult.NoThrottle,
+        false,
+        false,
+        0,
+        null);
+}
diff --git a/src/Exceptionless.Core/Services/UsageService.cs b/src/Exceptionless.Core/Services/UsageService.cs
index 7d1fa31ab8..b1454b38ff 100644
--- a/src/Exceptionless.Core/Services/UsageService.cs
+++ b/src/Exceptionless.Core/Services/UsageService.cs
@@ -1,16 +1,18 @@
-using Exceptionless.Core.Extensions;
+using Exceptionless.Core;
+using Exceptionless.Core.Extensions;
 using Exceptionless.Core.Messaging.Models;
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Repositories;
 using Exceptionless.DateTimeExtensions;
 using Foundatio.Caching;
+using Foundatio.Lock;
 using Foundatio.Messaging;
 using Foundatio.Repositories;
 using Microsoft.Extensions.Logging;
 
 namespace Exceptionless.Core.Services;
 
-public class UsageService : IAssistantUsageRecorder
+public partial class UsageService : IAssistantUsageRecorder
 {
     private static class AssistantUsageMetrics
     {
@@ -49,22 +51,29 @@ private static class AssistantUsageMetrics
     private readonly IOrganizationRepository _organizationRepository;
     private readonly IProjectRepository _projectRepository;
     private readonly ICacheClient _cache;
+    private readonly ILockProvider _lockProvider;
+    private readonly IAtomicCacheBatch _atomicCacheBatch;
     private readonly IMessagePublisher _messagePublisher;
     private readonly NotificationService _notificationService;
+    private readonly AppOptions _appOptions;
     private readonly TimeProvider _timeProvider;
     private readonly ILogger _logger;
     private readonly TimeSpan _bucketSize = TimeSpan.FromMinutes(5);
 
-    public UsageService(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, ICacheClient cache, IMessagePublisher messagePublisher,
+    public UsageService(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, ICacheClient cache, ILockProvider lockProvider, IAtomicCacheBatch atomicCacheBatch, IMessagePublisher messagePublisher,
         NotificationService notificationService,
+        AppOptions appOptions,
         TimeProvider timeProvider,
         ILoggerFactory loggerFactory)
     {
         _organizationRepository = organizationRepository;
         _projectRepository = projectRepository;
         _cache = cache;
+        _lockProvider = lockProvider;
+        _atomicCacheBatch = atomicCacheBatch;
         _messagePublisher = messagePublisher;
         _notificationService = notificationService;
+        _appOptions = appOptions;
         _timeProvider = timeProvider;
         _logger = loggerFactory.CreateLogger<UsageService>();
     }
@@ -462,6 +471,9 @@ public async Task<UsageInfoResponse> GetUsageAsync(string organizationId, string
 
         var bucketUtc = lastUsageSave;
         var currentBucketUtc = utcNow.Floor(_bucketSize);
+        var currentMonthUtc = utcNow.StartOfMonth();
+        if (bucketUtc < currentMonthUtc)
+            bucketUtc = currentMonthUtc;
         var isThrottled = await _cache.GetAsync<bool>(GetThrottledKey(currentBucketUtc, organizationId));
 
         UsageInfoResponse usage;
@@ -564,8 +576,11 @@ public async Task<int> GetEventsLeftAsync(string organizationId)
             currentTotal += bucketTotal.Value;
 
         // get previous bucket counter and add it to total since it might not be saved yet
-        var previousBucketTotal = await _cache.GetAsync<int>(GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organizationId));
-        if (previousBucketTotal.HasValue)
+        var previousBucketUtc = utcNow.Subtract(_bucketSize);
+        var previousBucketTotal = GetTotalBucket(previousBucketUtc) == GetTotalBucket(utcNow)
+            ? await _cache.GetAsync<int>(GetBucketTotalCacheKey(previousBucketUtc, organizationId))
+            : default;
+        if (previousBucketTotal is { HasValue: true })
             currentTotal += previousBucketTotal.Value;
 
         // check to see if adding this bucket puts the org over the limit
@@ -579,31 +594,65 @@ public async Task<int> GetEventsLeftAsync(string organizationId)
         return Math.Max(eventsLeftInBucket, 0);
     }
 
-    public async Task IncrementTotalAsync(string organizationId, string projectId, int eventCount = 1)
+    public Task IncrementTotalAsync(string organizationId, string projectId, int eventCount = 1)
+    {
+        return IncrementTotalAsync(null, organizationId, projectId, eventCount);
+    }
+
+    public Task IncrementTotalAsync(Organization organization, string projectId, int eventCount = 1)
+    {
+        ArgumentNullException.ThrowIfNull(organization);
+        return IncrementTotalAsync(organization, organization.Id, projectId, eventCount);
+    }
+
+    private async Task IncrementTotalAsync(Organization? organization, string organizationId, string projectId, int eventCount)
     {
         if (eventCount <= 0)
             return;
 
         var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
-
         long bucketTotal = await _cache.IncrementAsync(GetBucketTotalCacheKey(utcNow, organizationId), eventCount, TimeSpan.FromHours(8));
-        await _cache.IncrementAsync(GetBucketTotalCacheKey(utcNow, organizationId, projectId), eventCount, TimeSpan.FromHours(8));
 
-        await _cache.ListAddAsync(GetOrganizationSetKey(utcNow), organizationId, TimeSpan.FromHours(8));
-        await _cache.ListAddAsync(GetProjectSetKey(utcNow), projectId, TimeSpan.FromHours(8));
+        await Task.WhenAll(
+            _cache.IncrementAsync(GetBucketTotalCacheKey(utcNow, organizationId, projectId), eventCount, TimeSpan.FromHours(8)),
+            _cache.ListAddAsync(GetOrganizationSetKey(utcNow), organizationId, TimeSpan.FromHours(8)),
+            _cache.ListAddAsync(GetProjectSetKey(utcNow), projectId, TimeSpan.FromHours(8))
+        );
+
+        await PublishUsageIncrementNotificationsAsync(organization, projectId, eventCount, utcNow, bucketTotal, organizationId);
+    }
+
+    private async Task PublishUsageIncrementNotificationsAsync(Organization? organization, string projectId, int eventCount, DateTime utcNow, long bucketTotal, string? organizationId = null)
+    {
+        organizationId ??= organization?.Id ?? throw new ArgumentNullException(nameof(organization));
 
-        int maxEventsPerMonth = await GetMaxEventsPerMonthAsync(organizationId);
+        int maxEventsPerMonth = organization?.GetMaxEventsPerMonthWithBonus(_timeProvider) ?? await GetMaxEventsPerMonthAsync(organizationId);
         int bucketLimit = GetBucketEventLimit(maxEventsPerMonth);
 
-        var currentTotalCache = await _cache.GetAsync<int>(GetTotalCacheKey(utcNow, organizationId));
-        if (currentTotalCache.HasValue)
+        if (maxEventsPerMonth > 0)
         {
-            long monthTotal = currentTotalCache.Value + bucketTotal;
-            if (monthTotal >= maxEventsPerMonth && monthTotal - maxEventsPerMonth < eventCount)
+            organization ??= await _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+            int persistedTotal = organization?.GetCurrentUsage(_timeProvider).Total ?? 0;
+            var totals = await _cache.GetAllAsync<int>([
+                GetTotalCacheKey(utcNow, organizationId),
+                GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organizationId)
+            ]);
+
+            int baseTotal = GetCachedValue(totals, GetTotalCacheKey(utcNow, organizationId), persistedTotal);
+            int previousBucketTotal = GetTotalBucket(utcNow.Subtract(_bucketSize)) == GetTotalBucket(utcNow)
+                ? GetCachedValue(totals, GetBucketTotalCacheKey(utcNow.Subtract(_bucketSize), organizationId))
+                : 0;
+            int currentTotal = checked(baseTotal + previousBucketTotal + (int)bucketTotal);
+            int previousTotal = Math.Max(0, currentTotal - eventCount);
+
+            if (previousTotal < maxEventsPerMonth && currentTotal >= maxEventsPerMonth)
                 await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = organizationId });
+
+            if (organization is not null)
+                await PublishCrossedBudgetAlertsAsync(organization, previousTotal, currentTotal, maxEventsPerMonth);
         }
 
-        if (bucketTotal >= bucketLimit && bucketTotal - bucketLimit < eventCount)
+        if (bucketLimit >= 0 && bucketTotal >= bucketLimit && bucketTotal - bucketLimit < eventCount)
         {
             // org will be throttled during the current bucket of time
             await _cache.SetAsync(GetThrottledKey(utcNow, organizationId), true, TimeSpan.FromMinutes(5));
@@ -883,6 +932,49 @@ private string GetProjectSetKey(DateTime utcTime)
         return $"usage:{bucket}:projects";
     }
 
+    private string GetBudgetAlertSentKey(DateTime utcTime, string organizationId, int threshold)
+    {
+        int monthBucket = GetTotalBucket(utcTime);
+        return $"usage:budget-alert:{monthBucket}:{organizationId}:{threshold}";
+    }
+
+    private string GetProjectSmartThrottleKey(DateTime utcTime, string organizationId, string projectId)
+    {
+        int bucket = GetCurrentBucket(utcTime);
+        return $"usage:{bucket}:{organizationId}:{projectId}:smart-throttle";
+    }
+
+    private string GetSmartThrottleNotificationKey(DateTime utcTime, string organizationId, string projectId)
+    {
+        int monthBucket = GetTotalBucket(utcTime);
+        return $"usage:smart-throttle-notified:{monthBucket}:{organizationId}:{projectId}";
+    }
+
     private int GetCurrentBucket(DateTime utcTime) => utcTime.Floor(_bucketSize).ToEpoch();
     private int GetTotalBucket(DateTime utcTime) => utcTime.StartOfMonth().ToEpoch();
 }
+
+public class EventIngestAllowance
+{
+    public static readonly EventIngestAllowance Unlimited = new() { EventsLeft = Int32.MaxValue };
+
+    public int EventsLeft { get; init; }
+    public bool IsOverOrganizationLimit { get; init; }
+    public bool IsOverProjectLimit { get; init; }
+    public int EffectiveProjectLimit { get; init; } = -1;
+    public SmartThrottleResult SmartThrottle { get; init; } = SmartThrottleResult.NoThrottle;
+    public double SampleRate => SmartThrottle.SampleRate;
+}
+
+public class SmartThrottleResult
+{
+    public const double DefaultSampleRate = 0.05;
+    public static readonly SmartThrottleResult NoThrottle = new() { SampleRate = 1.0 };
+
+    public double SampleRate { get; init; } = 1.0;
+    public bool IsThrottled { get; init; }
+    public double ProjectShare { get; init; }
+    public double FairShareRatio { get; init; }
+    public int CurrentProjectUsage { get; init; }
+    public int FairShareLimit { get; init; }
+}
diff --git a/src/Exceptionless.Core/Utility/AppDiagnostics.cs b/src/Exceptionless.Core/Utility/AppDiagnostics.cs
index e274b701c6..1cfb97fac4 100644
--- a/src/Exceptionless.Core/Utility/AppDiagnostics.cs
+++ b/src/Exceptionless.Core/Utility/AppDiagnostics.cs
@@ -108,11 +108,18 @@ public GaugeInfo(Meter meter, string name)
     internal static readonly Counter<int> EventsProcessErrors = Meter.CreateCounter<int>("ex.events.processing.errors", description: "Errors processing events");
     internal static readonly Counter<int> EventsDiscarded = Meter.CreateCounter<int>("ex.events.discarded", description: "Events that were discarded");
     internal static readonly Counter<int> EventsBlocked = Meter.CreateCounter<int>("ex.events.blocked", description: "Events that were blocked");
+    internal static readonly Counter<int> EventsSmartThrottled = Meter.CreateCounter<int>("ex.events.smart_throttled", description: "Events blocked by automatic project throttling");
     internal static readonly Counter<int> EventsProcessCancelled = Meter.CreateCounter<int>("ex.events.processing.cancelled", description: "Events that started processing and were cancelled");
     internal static readonly Counter<int> EventsDeleted = Meter.CreateCounter<int>("ex.events.deleted", description: "Events that were deleted");
     internal static readonly Counter<int> EventsRetryCount = Meter.CreateCounter<int>("ex.events.retry.count", description: "Events where processing was retried");
     internal static readonly Counter<int> EventsRetryErrors = Meter.CreateCounter<int>("ex.events.retry.errors", description: "Events where retry processing got an error");
     internal static readonly Histogram<double> EventsFieldCount = Meter.CreateHistogram<double>("ex.events.field.count", description: "Number of fields per event");
+    internal static readonly Histogram<double> IngestReservationReserveTime = Meter.CreateHistogram<double>("ex.usage.ingest_reservation.reserve_time", unit: "ms", description: "Time to reserve event ingest capacity");
+    internal static readonly Histogram<double> IngestReservationCompleteTime = Meter.CreateHistogram<double>("ex.usage.ingest_reservation.complete_time", unit: "ms", description: "Time to complete an event ingest reservation");
+    internal static readonly Histogram<double> IngestReservationReleaseTime = Meter.CreateHistogram<double>("ex.usage.ingest_reservation.release_time", unit: "ms", description: "Time to release an event ingest reservation");
+    internal static readonly Histogram<double> IngestReservationLockWait = Meter.CreateHistogram<double>("ex.usage.ingest_reservation.lock_wait", unit: "ms", description: "Time spent waiting for the ingest reservation lock");
+    internal static readonly Histogram<int> IngestReservationRecordSize = Meter.CreateHistogram<int>("ex.usage.ingest_reservation.record_size", unit: "characters", description: "Serialized ingest reservation record length");
+    internal static readonly Counter<int> IngestReservationCasConflicts = Meter.CreateCounter<int>("ex.usage.ingest_reservation.cas_conflicts", description: "Ingest reservation compare-and-set conflicts");
 
     internal static readonly Counter<int> PostsParsed = Meter.CreateCounter<int>("ex.posts.parsed", description: "Post batch submission parsed");
     internal static readonly Histogram<double> PostsEventCount = Meter.CreateHistogram<double>("ex.posts.eventcount", description: "Number of events in post batch submission");
diff --git a/src/Exceptionless.Core/Utility/AppUrlBuilder.cs b/src/Exceptionless.Core/Utility/AppUrlBuilder.cs
index 3affcaed67..c718f03eec 100644
--- a/src/Exceptionless.Core/Utility/AppUrlBuilder.cs
+++ b/src/Exceptionless.Core/Utility/AppUrlBuilder.cs
@@ -38,12 +38,16 @@ public AppUrlBuilder(string baseUrl)
 
     public string OrganizationManage(string organizationId) => Build($"organization/{organizationId}/usage");
 
+    public string OrganizationUsage(string organizationId) => Build($"organization/{organizationId}/usage");
+
     public string OrganizationBilling(string organizationId) => Build($"organization/{organizationId}/billing");
 
     public string ProjectTimeline(string projectId) => Build($"project/{projectId}/dashboard?type=error");
 
     public string ProjectConfigure(string projectId) => Build($"project/{projectId}/configure");
 
+    public string ProjectUsage(string projectId) => Build($"project/{projectId}/usage");
+
     public string ProjectMostFrequent(string projectId) => Build($"project/{projectId}/dashboard?type=error&view=stacks");
 
     public string ProjectNewest(string projectId) => Build($"project/{projectId}/dashboard?type=error&view=stacks");
diff --git a/src/Exceptionless.EmailTemplates/Models/EmailTemplate.cs b/src/Exceptionless.EmailTemplates/Models/EmailTemplate.cs
index b0e97c481e..937fc9aa50 100644
--- a/src/Exceptionless.EmailTemplates/Models/EmailTemplate.cs
+++ b/src/Exceptionless.EmailTemplates/Models/EmailTemplate.cs
@@ -53,6 +53,18 @@ public sealed record OrganizationPaymentFailedEmail(
     string BillingUrl)
     : EmailTemplate(Subject, new EmailAction("Update Billing Information", BillingUrl));
 
+public sealed record OrganizationBudgetAlertEmail(
+    string Subject,
+    string OrganizationName,
+    int Threshold,
+    int ThresholdEventCount,
+    int CurrentEventCount,
+    int EventLimit,
+    int RemainingEventCount,
+    string UsageUrl,
+    string NotificationSettingsUrl)
+    : EmailTemplate(Subject, new EmailAction("View Usage", UsageUrl));
+
 public sealed record ProjectDailySummaryEmail(
     string Subject,
     string ProjectName,
@@ -76,6 +88,17 @@ public sealed record ProjectDailySummaryEmail(
         Subject,
         HasSubmittedEvents ? new EmailAction("View Timeline", TimelineUrl) : new EmailAction("Configure Project", ConfigureUrl));
 
+public sealed record ProjectSmartThrottleEmail(
+    string Subject,
+    string OrganizationName,
+    string ProjectName,
+    int SamplePercent,
+    int CurrentEventCount,
+    int EventLimit,
+    string UsageUrl,
+    string NotificationSettingsUrl)
+    : EmailTemplate(Subject, new EmailAction("View Project Usage", UsageUrl));
+
 public sealed record StackSummary(string Title, string? TypeName, bool IsRegressed, string Url);
 
 public sealed record UserEmailVerifyEmail(string Subject, string UserFullName, EmailAction Action)
diff --git a/src/Exceptionless.EmailTemplates/RazorEmailTemplateRenderer.cs b/src/Exceptionless.EmailTemplates/RazorEmailTemplateRenderer.cs
index 17312bde78..fbc174ec74 100644
--- a/src/Exceptionless.EmailTemplates/RazorEmailTemplateRenderer.cs
+++ b/src/Exceptionless.EmailTemplates/RazorEmailTemplateRenderer.cs
@@ -34,7 +34,9 @@ public Task<string> RenderAsync(EmailTemplate template, CancellationToken cancel
             OrganizationInvitedEmail value => RenderComponentAsync<OrganizationInvited, OrganizationInvitedEmail>(value),
             OrganizationNoticeEmail value => RenderComponentAsync<OrganizationNotice, OrganizationNoticeEmail>(value),
             OrganizationPaymentFailedEmail value => RenderComponentAsync<OrganizationPaymentFailed, OrganizationPaymentFailedEmail>(value),
+            OrganizationBudgetAlertEmail value => RenderComponentAsync<OrganizationBudgetAlert, OrganizationBudgetAlertEmail>(value),
             ProjectDailySummaryEmail value => RenderComponentAsync<ProjectDailySummary, ProjectDailySummaryEmail>(value),
+            ProjectSmartThrottleEmail value => RenderComponentAsync<ProjectSmartThrottle, ProjectSmartThrottleEmail>(value),
             UserEmailVerifyEmail value => RenderComponentAsync<UserEmailVerify, UserEmailVerifyEmail>(value),
             UserPasswordResetEmail value => RenderComponentAsync<UserPasswordReset, UserPasswordResetEmail>(value),
             _ => throw new NotSupportedException($"No Razor component is registered for {template.GetType().Name}.")
diff --git a/src/Exceptionless.EmailTemplates/Templates/OrganizationBudgetAlert.razor b/src/Exceptionless.EmailTemplates/Templates/OrganizationBudgetAlert.razor
new file mode 100644
index 0000000000..2fcdae5041
--- /dev/null
+++ b/src/Exceptionless.EmailTemplates/Templates/OrganizationBudgetAlert.razor
@@ -0,0 +1,16 @@
+@namespace Exceptionless.EmailTemplates.Templates
+@inherits EmailTemplateComponent<OrganizationBudgetAlertEmail>
+
+<EmailLayout Model="Model">
+    <EmailSection>
+        <p style="@EmailStyles.Lead">@Model.OrganizationName has reached @Model.Threshold% of its monthly event allowance.</p>
+        <p style="@EmailStyles.Paragraph">The organization has accepted @Model.CurrentEventCount events. The @Model.Threshold% alert is @Model.ThresholdEventCount events, the current allowance is @Model.EventLimit, and @Model.RemainingEventCount events remain.</p>
+        <EmailButton Url="@Model.Action!.Url">View Usage</EmailButton>
+    </EmailSection>
+    <ActionsFooter Links="NotificationLinks" />
+</EmailLayout>
+
+@code {
+    private IReadOnlyCollection<EmailLink> NotificationLinks =>
+        [new("Change your notification settings", Model.NotificationSettingsUrl)];
+}
diff --git a/src/Exceptionless.EmailTemplates/Templates/ProjectSmartThrottle.razor b/src/Exceptionless.EmailTemplates/Templates/ProjectSmartThrottle.razor
new file mode 100644
index 0000000000..c7e97e0e46
--- /dev/null
+++ b/src/Exceptionless.EmailTemplates/Templates/ProjectSmartThrottle.razor
@@ -0,0 +1,18 @@
+@namespace Exceptionless.EmailTemplates.Templates
+@inherits EmailTemplateComponent<ProjectSmartThrottleEmail>
+
+<EmailLayout Model="Model">
+    <EmailSection>
+        <p style="@EmailStyles.Lead">Smart throttling is active for <strong>@Model.ProjectName</strong> in <strong>@Model.OrganizationName</strong>.</p>
+        <p style="@EmailStyles.Paragraph">This project's recent event rate is consuming more than its share of the organization's remaining allowance. Exceptionless is accepting a stable @Model.SamplePercent% sample from this project. Events outside that sample are counted as blocked.</p>
+        <p style="@EmailStyles.Paragraph">The project has accepted @Model.CurrentEventCount events this month. Its monthly fair-share allowance is @Model.EventLimit events.</p>
+        <p style="@EmailStyles.Paragraph">Other projects are unaffected unless they independently meet the same smart-throttling criteria.</p>
+        <EmailButton Url="@Model.Action!.Url">View Project Usage</EmailButton>
+    </EmailSection>
+    <ActionsFooter Links="NotificationLinks" />
+</EmailLayout>
+
+@code {
+    private IReadOnlyCollection<EmailLink> NotificationLinks =>
+        [new("Change your notification settings", Model.NotificationSettingsUrl)];
+}
diff --git a/src/Exceptionless.Insulation/Bootstrapper.cs b/src/Exceptionless.Insulation/Bootstrapper.cs
index 5ce4f4f7b3..67f14254bc 100644
--- a/src/Exceptionless.Insulation/Bootstrapper.cs
+++ b/src/Exceptionless.Insulation/Bootstrapper.cs
@@ -9,6 +9,7 @@
 using Exceptionless.Core.Jobs.Elastic;
 using Exceptionless.Core.Mail;
 using Exceptionless.Core.Queues.Models;
+using Exceptionless.Core.Services;
 using Exceptionless.Core.Utility;
 using Exceptionless.Insulation.Geo;
 using Exceptionless.Insulation.HealthChecks;
@@ -110,6 +111,7 @@ private static void RegisterCache(IServiceCollection container, CacheOptions opt
                 container.ReplaceSingleton<ICacheClient>(s => new ScopedCacheClient(CreateRedisCacheClient(s), options.Scope));
             else
                 container.ReplaceSingleton<ICacheClient>(CreateRedisCacheClient);
+            container.ReplaceSingleton<IAtomicCacheBatch>(s => new RedisAtomicCacheBatch(s.GetRequiredService<IConnectionMultiplexer>(), options, s.GetRequiredService<TimeProvider>()));
 
             container.ReplaceSingleton<IConnectionMapping, RedisConnectionMapping>();
         }
diff --git a/src/Exceptionless.Insulation/Redis/RedisAtomicCacheBatch.cs b/src/Exceptionless.Insulation/Redis/RedisAtomicCacheBatch.cs
new file mode 100644
index 0000000000..1600d68f43
--- /dev/null
+++ b/src/Exceptionless.Insulation/Redis/RedisAtomicCacheBatch.cs
@@ -0,0 +1,91 @@
+using Exceptionless.Core.Configuration;
+using Exceptionless.Core.Services;
+using StackExchange.Redis;
+
+namespace Exceptionless.Insulation.Redis;
+
+public sealed class RedisAtomicCacheBatch : IAtomicCacheBatch
+{
+    private const string CompareAndSetAllScript = """
+        local valueCount = tonumber(ARGV[1])
+        local listExpiresAt = ARGV[2]
+        for index = valueCount + 1, #KEYS do
+            local keyType = redis.call('TYPE', KEYS[index])
+            if type(keyType) == 'table' then keyType = keyType.ok end
+            if keyType ~= 'none' and keyType ~= 'zset' then
+                return redis.error_reply('Atomic cache list key has an incompatible Redis type')
+            end
+        end
+        for index = 1, valueCount do
+            local current = redis.call('GET', KEYS[index])
+            local argumentIndex = 2 + ((index - 1) * 4)
+            local expectedExists = ARGV[argumentIndex + 1]
+            local expected = ARGV[argumentIndex + 2]
+            if expectedExists == '0' then
+                if current then return 0 end
+            elseif current ~= expected then
+                return 0
+            end
+        end
+        for index = 1, valueCount do
+            local argumentIndex = 2 + ((index - 1) * 4)
+            redis.call('SET', KEYS[index], ARGV[argumentIndex + 3], 'PX', ARGV[argumentIndex + 4])
+        end
+        local listArgumentIndex = 2 + (valueCount * 4)
+        for index = valueCount + 1, #KEYS do
+            listArgumentIndex = listArgumentIndex + 1
+            redis.call('ZADD', KEYS[index], listExpiresAt, ARGV[listArgumentIndex])
+        end
+        return 1
+        """;
+
+    private readonly IConnectionMultiplexer _connectionMultiplexer;
+    private readonly CacheOptions _cacheOptions;
+    private readonly TimeProvider _timeProvider;
+
+    public RedisAtomicCacheBatch(IConnectionMultiplexer connectionMultiplexer, CacheOptions cacheOptions, TimeProvider timeProvider)
+    {
+        _connectionMultiplexer = connectionMultiplexer;
+        _cacheOptions = cacheOptions;
+        _timeProvider = timeProvider;
+
+        if (connectionMultiplexer.GetServers().Any(server => server.ServerType == ServerType.Cluster))
+            throw new NotSupportedException("Atomic usage reservations require a single Redis endpoint; Redis Cluster is not supported.");
+    }
+
+    public async Task<bool> TrySetAllAsync(IReadOnlyDictionary<string, string?> expectedValues, IReadOnlyDictionary<string, AtomicCacheValue> values,
+        IReadOnlyDictionary<string, string>? listValues = null, TimeSpan? listExpiresIn = null)
+    {
+        AtomicCacheBatch.ValidateArguments(expectedValues, values, listValues, listExpiresIn);
+
+        string prefix = String.IsNullOrEmpty(_cacheOptions.Scope) ? String.Empty : $"{_cacheOptions.Scope}:";
+        listValues ??= new Dictionary<string, string>();
+        var keys = values.Keys.Concat(listValues.Keys).Select(key => (RedisKey)$"{prefix}{key}").ToArray();
+        var arguments = new RedisValue[(values.Count * 4) + listValues.Count + 2];
+        arguments[0] = values.Count;
+        arguments[1] = listValues.Count > 0
+            ? _timeProvider.GetUtcNow().Add(listExpiresIn!.Value).ToUnixTimeMilliseconds()
+            : 0;
+        int index = 2;
+        foreach (var entry in values)
+        {
+            string? expected = expectedValues[entry.Key];
+            arguments[index++] = expected is null ? 0 : 1;
+            arguments[index++] = expected ?? String.Empty;
+            arguments[index++] = entry.Value.Value;
+            arguments[index++] = checked((long)entry.Value.ExpiresIn.TotalMilliseconds);
+        }
+        foreach (string value in listValues.Values)
+            arguments[index++] = value;
+
+        try
+        {
+            var result = await _connectionMultiplexer.GetDatabase().ScriptEvaluateAsync(CompareAndSetAllScript, keys, arguments);
+            return (int)result == 1;
+        }
+        catch (RedisServerException ex) when (ex.Message.Contains("CROSSSLOT", StringComparison.OrdinalIgnoreCase))
+        {
+            throw new NotSupportedException("Atomic usage reservations require a single Redis endpoint; Redis Cluster hash-slot splitting is not supported.", ex);
+        }
+    }
+}
diff --git a/src/Exceptionless.Web/Api/Endpoints/OrganizationEndpoints.cs b/src/Exceptionless.Web/Api/Endpoints/OrganizationEndpoints.cs
index 5cd02efbe3..d8dfd0f984 100644
--- a/src/Exceptionless.Web/Api/Endpoints/OrganizationEndpoints.cs
+++ b/src/Exceptionless.Web/Api/Endpoints/OrganizationEndpoints.cs
@@ -85,14 +85,14 @@ public static IEndpointRouteBuilder MapOrganizationEndpoints(this IEndpointRoute
             }
         });
 
-        group.MapPatch("organizations/{id:objectid}", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] Delta<NewOrganization>? changes) =>
+        group.MapPatch("organizations/{id:objectid}", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] Delta<UpdateOrganization>? changes) =>
         {
             if (changes is null)
                 return ApiValidation.MissingRequestBody();
 
             return (await mediator.InvokeAsync<Result<ViewOrganization>>(new OrganizationMessages.UpdateOrganizationMessage(id, changes, httpContext))).ToHttpResult(resultMapper);
         })
-        .Accepts<Delta<NewOrganization>>("application/json", "application/*+json")
+        .Accepts<Delta<UpdateOrganization>>("application/json", "application/*+json")
         .Produces<ViewOrganization>()
         .ProducesProblem(StatusCodes.Status400BadRequest)
         .ProducesProblem(StatusCodes.Status404NotFound)
@@ -110,14 +110,14 @@ public static IEndpointRouteBuilder MapOrganizationEndpoints(this IEndpointRoute
             }
         });
 
-        group.MapPut("organizations/{id:objectid}", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] Delta<NewOrganization>? changes) =>
+        group.MapPut("organizations/{id:objectid}", async (string id, HttpContext httpContext, IMediator mediator, IMediatorResultMapper<HttpIResult> resultMapper, [FromBody] Delta<UpdateOrganization>? changes) =>
         {
             if (changes is null)
                 return ApiValidation.MissingRequestBody();
 
             return (await mediator.InvokeAsync<Result<ViewOrganization>>(new OrganizationMessages.UpdateOrganizationMessage(id, changes, httpContext))).ToHttpResult(resultMapper);
         })
-        .Accepts<Delta<NewOrganization>>("application/json", "application/*+json")
+        .Accepts<Delta<UpdateOrganization>>("application/json", "application/*+json")
         .Produces<ViewOrganization>()
         .ProducesProblem(StatusCodes.Status400BadRequest)
         .ProducesProblem(StatusCodes.Status404NotFound)
diff --git a/src/Exceptionless.Web/Api/Handlers/OAuthApplicationHandler.cs b/src/Exceptionless.Web/Api/Handlers/OAuthApplicationHandler.cs
index 5846cb3630..8b1cbbec7a 100644
--- a/src/Exceptionless.Web/Api/Handlers/OAuthApplicationHandler.cs
+++ b/src/Exceptionless.Web/Api/Handlers/OAuthApplicationHandler.cs
@@ -1,7 +1,6 @@
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Repositories;
 using Exceptionless.Core.Services;
-using Exceptionless.Core.Extensions;
 using Exceptionless.Core.Validation;
 using Exceptionless.Web.Api.Messages;
 using Exceptionless.Web.Api.Infrastructure;
@@ -71,7 +70,7 @@ public async Task<Result<ViewOAuthApplication>> Handle(CreateOAuthApplicationMes
         }
         catch (MiniValidatorException ex)
         {
-            return ValidationResult<ViewOAuthApplication>(ex);
+            return ex.ToValidationResult<ViewOAuthApplication>();
         }
 
         await oauthService.ClearAccessTokenClientValidityCacheAsync(application.ClientId);
@@ -104,7 +103,7 @@ public async Task<Result<ViewOAuthApplication>> Handle(UpdateOAuthApplicationMes
         }
         catch (MiniValidatorException ex)
         {
-            return ValidationResult<ViewOAuthApplication>(ex);
+            return ex.ToValidationResult<ViewOAuthApplication>();
         }
 
         await oauthService.ClearAccessTokenClientValidityCacheAsync(previousClientId);
@@ -181,10 +180,4 @@ private static string[] NormalizeScopes(IEnumerable<string> scopes)
             .Distinct(StringComparer.Ordinal)
             .ToArray();
     }
-
-    private static Result<T> ValidationResult<T>(MiniValidatorException ex)
-    {
-        return Result<T>.FromResult(Result.Invalid(ex.Errors.SelectMany(error =>
-            error.Value.Select(message => ValidationError.Create(error.Key.ToLowerUnderscoredWords(), message)))));
-    }
 }
diff --git a/src/Exceptionless.Web/Api/Handlers/OrganizationHandler.cs b/src/Exceptionless.Web/Api/Handlers/OrganizationHandler.cs
index 574c7cb899..c4ea5524a1 100644
--- a/src/Exceptionless.Web/Api/Handlers/OrganizationHandler.cs
+++ b/src/Exceptionless.Web/Api/Handlers/OrganizationHandler.cs
@@ -9,6 +9,7 @@
 using Exceptionless.Core.Repositories;
 using Exceptionless.Core.Repositories.Queries;
 using Exceptionless.Core.Services;
+using Exceptionless.Core.Validation;
 using Exceptionless.Web.Api.Infrastructure;
 using Exceptionless.Web.Api.Messages;
 using Exceptionless.Web.Api.Results;
@@ -131,13 +132,49 @@ public async Task<Result<ViewOrganization>> Handle(UpdateOrganizationMessage mes
         if (!message.Changes.GetChangedPropertyNames().Any())
             return await MapToViewAsync(original);
 
-        var error = CanUpdate(message.Changes);
+        var error = await CanUpdateAsync(original, message.Changes, message.Context);
         if (error is not null)
             return error;
 
+        var changed = message.Changes.GetEntity();
+        bool budgetSettingsChanged = message.Changes.ContainsChangedProperty(p => p.BudgetAlertSettings!);
+        bool wereAlertsEnabled = original.BudgetAlertSettings is { Enabled: true };
+        var previousThresholds = original.BudgetAlertSettings?.Thresholds?.ToHashSet() ?? [];
+
         message.Changes.Patch(original);
-        await repository.SaveAsync(original, o => o.Cache());
-        return await MapToViewAsync(original);
+        if (budgetSettingsChanged)
+            original.BudgetAlertSettings = changed.BudgetAlertSettings;
+
+        Organization saved;
+        try
+        {
+            saved = await repository.SaveAsync(original, o => o.Cache());
+        }
+        catch (MiniValidatorException ex)
+        {
+            return ex.ToValidationResult<ViewOrganization>();
+        }
+
+        if (budgetSettingsChanged && saved.BudgetAlertSettings is { Enabled: true, Thresholds: not null })
+        {
+            int[] thresholdsToEvaluate = wereAlertsEnabled
+                ? saved.BudgetAlertSettings.Thresholds.Except(previousThresholds).ToArray()
+                : saved.BudgetAlertSettings.Thresholds.ToArray();
+
+            if (thresholdsToEvaluate.Length > 0)
+            {
+                try
+                {
+                    await usageService.EvaluateBudgetAlertsAfterSettingsChangeAsync(saved, thresholdsToEvaluate);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Failed to evaluate newly enabled budget alerts for organization {OrganizationId}", saved.Id);
+                }
+            }
+        }
+
+        return await MapToViewAsync(saved);
     }
 
     public async Task<Result<ProfileImageUpdate<ViewOrganization>>> Handle(SetOrganizationIcon message)
@@ -850,11 +887,20 @@ await messagePublisher.PublishAsync(new UserMembershipChanged
         return organization;
     }
 
-    private static Result<ViewOrganization>? CanUpdate(Delta<NewOrganization> changes)
+    private async Task<Result<ViewOrganization>?> CanUpdateAsync(Organization original, Delta<UpdateOrganization> changes, HttpContext httpContext)
     {
-        if (changes.ContainsChangedProperty(p => p.Name) && String.IsNullOrEmpty(changes.GetEntity().Name))
+        var changed = changes.GetEntity();
+        if (changes.ContainsChangedProperty(p => p.Name) && String.IsNullOrEmpty(changed.Name))
             return Result.BadRequest("Organization name is required.");
 
+        if (changes.ContainsChangedProperty(p => p.Name) && !await IsOrganizationNameAvailableInternalAsync(changed.Name, httpContext, original.Id))
+            return Result.BadRequest("A organization with this name already exists.");
+
+        if (changes.ContainsChangedProperty(p => p.BudgetAlertSettings!) &&
+            changed.BudgetAlertSettings is { Enabled: true } &&
+            original.GetMaxEventsPerMonthWithBonus(timeProvider) < 0)
+            return Result.BadRequest("Budget alerts cannot be enabled for an organization with an unlimited event allowance.");
+
         if (changes.GetChangedPropertyNames().Contains("OrganizationId"))
             return Result.BadRequest("OrganizationId cannot be modified.");
 
@@ -1021,6 +1067,16 @@ private async Task<List<ViewOrganization>> PopulateOrganizationStatsAsync(List<V
         return viewOrganizations;
     }
 
+    private async Task<bool> IsOrganizationNameAvailableInternalAsync(string? name, HttpContext httpContext, string? excludeOrganizationId = null)
+    {
+        if (String.IsNullOrWhiteSpace(name))
+            return false;
+
+        string decodedName = Uri.UnescapeDataString(name).Trim().ToLowerInvariant();
+        var results = await repository.GetByIdsAsync(httpContext.Request.GetAssociatedOrganizationIds().ToArray(), o => o.Cache());
+        return !results.Any(o => o.Id != excludeOrganizationId && String.Equals(o.Name.Trim().ToLowerInvariant(), decodedName, StringComparison.OrdinalIgnoreCase));
+    }
+
     private static Result PermissionToResult(PermissionResult permission)
     {
         if (permission.StatusCode == StatusCodes.Status404NotFound)
@@ -1034,7 +1090,6 @@ private static Result PermissionToResult(PermissionResult permission)
 
         return Result.Forbidden(permission.Message ?? "Access denied.");
     }
-
     private static User GetCurrentUser(HttpContext httpContext) => httpContext.Request.GetUser();
     private static bool IsStatsMode(string? mode) => !String.IsNullOrEmpty(mode) && String.Equals(mode, "stats", StringComparison.OrdinalIgnoreCase);
     private static bool messageIsGlobalAdmin(HttpContext httpContext) => httpContext.Request.IsGlobalAdmin();
diff --git a/src/Exceptionless.Web/Api/Handlers/ProjectHandler.cs b/src/Exceptionless.Web/Api/Handlers/ProjectHandler.cs
index 3705100472..652fb9e185 100644
--- a/src/Exceptionless.Web/Api/Handlers/ProjectHandler.cs
+++ b/src/Exceptionless.Web/Api/Handlers/ProjectHandler.cs
@@ -8,6 +8,7 @@
 using Exceptionless.Core.Repositories.Queries;
 using Exceptionless.Core.Services;
 using Exceptionless.Core.Utility;
+using Exceptionless.Core.Validation;
 using Exceptionless.Web.Api.Infrastructure;
 using Exceptionless.Web.Api.Messages;
 using Exceptionless.Web.Api.Results;
@@ -134,11 +135,33 @@ public async Task<Result<ViewProject>> Handle(UpdateProjectMessage message)
         if (error is not null)
             return error;
 
+        var changed = message.Changes.GetEntity();
+        bool ingestLimitChanged = message.Changes.ContainsChangedProperty(p => p.IngestLimit!);
+
         message.Changes.Patch(original);
+        if (ingestLimitChanged)
+            original.IngestLimit = changed.IngestLimit;
+
         if (message.Changes.ContainsChangedProperty(p => p.PromotedTabs!))
             original.PromotedTabs = NormalizePromotedTabs(original.PromotedTabs);
 
-        await repository.SaveAsync(original, o => o.Cache());
+        if (ingestLimitChanged && original.IngestLimit is not null)
+        {
+            if (original.IngestLimit.Type is ProjectIngestLimitType.Fixed)
+                original.IngestLimit.PercentOfOrganizationLimit = null;
+            else if (original.IngestLimit.Type is ProjectIngestLimitType.PercentOfOrganizationLimit)
+                original.IngestLimit.FixedLimit = null;
+        }
+
+        try
+        {
+            await repository.SaveAsync(original, o => o.Cache());
+        }
+        catch (MiniValidatorException ex)
+        {
+            return ex.ToValidationResult<ViewProject>();
+        }
+
         return await MapToViewAsync(original);
     }
 
@@ -496,7 +519,13 @@ private async Task AfterResultMapAsync<TDestination>(ICollection<TDestination> m
         if (viewProjects.Count == 0)
             return;
 
-        var organizations = await organizationRepository.GetByIdsAsync(viewProjects.Select(p => p.OrganizationId).Distinct().ToArray(), o => o.Cache());
+        var organizationsTask = organizationRepository.GetByIdsAsync(viewProjects.Select(p => p.OrganizationId).Distinct().ToArray(), o => o.Cache());
+        var throttleStatesTask = usageService.GetProjectSmartThrottleStatesAsync(
+            viewProjects.Select(project => (project.OrganizationId, project.Id)).ToArray());
+        await Task.WhenAll(organizationsTask, throttleStatesTask);
+
+        var organizations = await organizationsTask;
+        var throttleStates = await throttleStatesTask;
         foreach (var viewProject in viewProjects)
         {
             if (!viewProject.IsConfigured.HasValue)
@@ -530,6 +559,18 @@ private async Task AfterResultMapAsync<TDestination>(ICollection<TDestination> m
             currentHourUsage.Discarded = realTimeUsage.CurrentHourUsage.Discarded;
             currentHourUsage.TooBig = realTimeUsage.CurrentHourUsage.TooBig;
             currentHourUsage.Deleted = realTimeUsage.CurrentHourUsage.Deleted;
+
+            if (viewProject.IngestLimit is not null)
+            {
+                int effectiveLimit = usageService.GetEffectiveProjectLimit(viewProject.IngestLimit, organization);
+                viewProject.EffectiveIngestLimit = effectiveLimit > 0 ? effectiveLimit : null;
+            }
+
+            if (throttleStates.TryGetValue(viewProject.Id, out var throttleState))
+            {
+                viewProject.IsSmartThrottled = true;
+                viewProject.SmartThrottleSampleRate = throttleState.SampleRate;
+            }
         }
     }
 
@@ -570,6 +611,13 @@ private Task<Project> AddModelAsync(Project value, HttpContext httpContext)
         if (changes.ContainsChangedProperty(p => p.Name) && !await IsProjectNameAvailableInternalAsync(original.OrganizationId, changed.Name, original.Id, httpContext))
             return Result.BadRequest("A project with this name already exists.");
 
+        if (changes.ContainsChangedProperty(p => p.IngestLimit!) && changed.IngestLimit?.Type is ProjectIngestLimitType.PercentOfOrganizationLimit)
+        {
+            var organization = await organizationRepository.GetByIdAsync(original.OrganizationId, o => o.Cache());
+            if (organization?.GetMaxEventsPerMonthWithBonus(timeProvider) < 0)
+                return Result.BadRequest("A percentage project ingest limit cannot be used with an unlimited organization allowance.");
+        }
+
         if (changes.GetChangedPropertyNames().Contains(nameof(Project.OrganizationId)))
             return Result.BadRequest("OrganizationId cannot be modified.");
 
@@ -732,7 +780,6 @@ private static Result PermissionToResult(PermissionResult permission)
 
         return Result.Forbidden(permission.Message ?? "Access denied.");
     }
-
     private static User GetCurrentUser(HttpContext httpContext) => httpContext.Request.GetUser();
     private static string GetCurrentUserId(HttpContext httpContext) => GetCurrentUser(httpContext).Id;
     private static bool IsStatsMode(string? mode) => !String.IsNullOrEmpty(mode) && String.Equals(mode, "stats", StringComparison.OrdinalIgnoreCase);
diff --git a/src/Exceptionless.Web/Api/Messages/OrganizationMessages.cs b/src/Exceptionless.Web/Api/Messages/OrganizationMessages.cs
index fd344fde48..15a50afd3f 100644
--- a/src/Exceptionless.Web/Api/Messages/OrganizationMessages.cs
+++ b/src/Exceptionless.Web/Api/Messages/OrganizationMessages.cs
@@ -11,7 +11,7 @@ public record GetAdminOrganizations(string? Criteria, bool? Paid, bool? Suspende
 public record GetOrganizationPlanStats(HttpContext Context);
 public record GetOrganizationById(string Id, string? Mode, HttpContext Context);
 public record CreateOrganization(NewOrganization Organization, HttpContext Context);
-public record UpdateOrganizationMessage(string Id, Delta<NewOrganization> Changes, HttpContext Context);
+public record UpdateOrganizationMessage(string Id, Delta<UpdateOrganization> Changes, HttpContext Context);
 public record SetOrganizationIcon(string Id, string FileName, HttpContext Context);
 public record DeleteOrganizationIcon(string Id, HttpContext Context);
 public record DeleteOrganizations(string[] Ids, HttpContext Context);
diff --git a/src/Exceptionless.Web/Api/Results/ValidationResultExtensions.cs b/src/Exceptionless.Web/Api/Results/ValidationResultExtensions.cs
new file mode 100644
index 0000000000..39111f9f0c
--- /dev/null
+++ b/src/Exceptionless.Web/Api/Results/ValidationResultExtensions.cs
@@ -0,0 +1,14 @@
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Validation;
+using Foundatio.Mediator;
+
+namespace Exceptionless.Web.Api.Results;
+
+public static class ValidationResultExtensions
+{
+    public static Result<T> ToValidationResult<T>(this MiniValidatorException exception)
+    {
+        return Result<T>.FromResult(Result.Invalid(exception.Errors.SelectMany(error =>
+            error.Value.Select(message => ValidationError.Create(error.Key.ToLowerUnderscoredWords(), message)))));
+    }
+}
diff --git a/src/Exceptionless.Web/Bootstrapper.cs b/src/Exceptionless.Web/Bootstrapper.cs
index 721feeb4ea..b27bfef33f 100644
--- a/src/Exceptionless.Web/Bootstrapper.cs
+++ b/src/Exceptionless.Web/Bootstrapper.cs
@@ -41,5 +41,11 @@ public static void RegisterServices(IServiceCollection services, AppOptions appO
 
         services.AddSingleton<EnqueueOrganizationNotificationOnPlanOverage>();
         services.AddStartupAction<EnqueueOrganizationNotificationOnPlanOverage>();
+
+        services.AddSingleton<EnqueueOrganizationBudgetAlertOnUsageThreshold>();
+        services.AddStartupAction<EnqueueOrganizationBudgetAlertOnUsageThreshold>();
+
+        services.AddSingleton<EnqueueProjectSmartThrottleOnThrottleApplied>();
+        services.AddStartupAction<EnqueueProjectSmartThrottleOnThrottleApplied>();
     }
 }
diff --git a/src/Exceptionless.Web/ClientApp/api-templates/schemas.ejs b/src/Exceptionless.Web/ClientApp/api-templates/schemas.ejs
index 58935cf119..6180e71431 100644
--- a/src/Exceptionless.Web/ClientApp/api-templates/schemas.ejs
+++ b/src/Exceptionless.Web/ClientApp/api-templates/schemas.ejs
@@ -61,7 +61,7 @@ const typeToZod = (rawType, isRequired, nullable, field) => {
     // but outputs "X | null" for nullable arrays fixed via generate-api.mjs workaround.
     if (type.startsWith('null | ')) {
         let innerType = type.replace('null | ', '');
-        if (innerType.startsWith('(') && innerType.endsWith(')') && !innerType.endsWith('[]')) {
+        if (innerType.startsWith('(') && innerType.endsWith(')')) {
             innerType = innerType.slice(1, -1);
         }
         return `${typeToZod(innerType, true, false, field)}.nullable()`;
@@ -69,13 +69,13 @@ const typeToZod = (rawType, isRequired, nullable, field) => {
 
     if (type.endsWith(' | null')) {
         let innerType = type.replace(' | null', '');
-        if (innerType.startsWith('(') && innerType.endsWith(')') && !innerType.endsWith('[]')) {
+        if (innerType.startsWith('(') && innerType.endsWith(')')) {
             innerType = innerType.slice(1, -1);
         }
         return `${typeToZod(innerType, true, false, field)}.nullable()`;
     }
 
-    if (type.startsWith('(') && type.endsWith(')') && !type.includes('[]')) {
+    if (type.startsWith('(') && type.endsWith(')')) {
         type = type.slice(1, -1);
     }
 
@@ -191,7 +191,9 @@ const typeToZod = (rawType, isRequired, nullable, field) => {
 };
 
 const buildZodField = (field) => {
-    const rawType = field.value || 'unknown';
+    const hasNullableOneOf = Array.isArray(field.oneOf) && field.oneOf.some((alternative) => alternative.type === 'null');
+    const nonNullAlternative = hasNullableOneOf ? field.oneOf.find((alternative) => alternative.type !== 'null') : undefined;
+    const rawType = nonNullAlternative?.$parsed?.content || field.value || 'unknown';
     const type = rawType.replace(/\bany\b/g, 'unknown');
     const cleanedType = cleanType(type);
     const readableName = toReadableName(field.name);
@@ -210,13 +212,15 @@ const buildZodField = (field) => {
     const isUuidField = field.format === 'uuid' || fieldNameLower.endsWith('_uuid');
 
     // Check if this is a nullable union type (e.g., "null | string" or "string | null")
-    const isNullableUnion = cleanedType.startsWith('null | ') || cleanedType.endsWith(' | null');
+    const unwrappedType = cleanedType.startsWith('(') && cleanedType.endsWith(')') ? cleanedType.slice(1, -1) : cleanedType;
+    const isNullableUnion = unwrappedType.startsWith('null | ') || unwrappedType.endsWith(' | null');
+    const isFieldNullable = field.nullable || field.isNullable || hasNullableOneOf || isNullableUnion;
 
     // Get the base type (without null union)
-    let baseType = cleanedType;
+    let baseType = unwrappedType;
     if (isNullableUnion) {
         baseType = cleanedType.replace('null | ', '').replace(' | null', '');
-        if (baseType.startsWith('(') && baseType.endsWith(')') && !baseType.endsWith('[]')) {
+        if (baseType.startsWith('(') && baseType.endsWith(')')) {
             baseType = baseType.slice(1, -1);
         }
     }
@@ -344,12 +348,12 @@ const buildZodField = (field) => {
     }
 
     // Handle nullable (adds .nullable())
-    if (isNullableUnion && !zodType.includes('.nullable()')) {
+    if (isFieldNullable && !zodType.includes('.nullable()')) {
         zodType = zodType + '.nullable()';
     }
 
     // Handle optional (non-required fields and nullable fields are optional)
-    if (field.nullable || !field.isRequired) {
+    if (isFieldNullable || !field.isRequired) {
         zodType = zodType + '.optional()';
     }
 
diff --git a/src/Exceptionless.Web/ClientApp/e2e/tests/usage-budget-controls.e2e.ts b/src/Exceptionless.Web/ClientApp/e2e/tests/usage-budget-controls.e2e.ts
new file mode 100644
index 0000000000..b29131cfdd
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/e2e/tests/usage-budget-controls.e2e.ts
@@ -0,0 +1,137 @@
+import { expect, test } from '@playwright/test';
+
+const ORGANIZATION_ID = '000000000000000000000001';
+const PROJECT_ID = '000000000000000000000003';
+
+for (const width of [1280, 390]) {
+    test.describe(`usage budget controls at ${width}px`, () => {
+        test.use({ viewport: { height: 900, width } });
+        test.setTimeout(30_000);
+
+        for (const resource of ['organization', 'project'] as const) {
+            test(`${resource} budget validates, saves, and clears settings`, async ({ page }, testInfo) => {
+                const organization = {
+                    budget_alert_settings: { enabled: true, thresholds: [50, 80] },
+                    features: [],
+                    id: ORGANIZATION_ID,
+                    max_events_per_month: 1000,
+                    name: 'Budget Organization',
+                    plan_id: 'EX_FREE',
+                    plan_name: 'Free',
+                    usage: []
+                };
+                const project = {
+                    effective_ingest_limit: 100,
+                    id: PROJECT_ID,
+                    ingest_limit: { fixed_limit: 100, type: 0 },
+                    name: 'Budget Project',
+                    organization_id: ORGANIZATION_ID,
+                    usage: []
+                };
+                const errors: string[] = [];
+                const updates: unknown[] = [];
+                let rejectUpdate = true;
+                page.on('pageerror', (error) => errors.push(error.message));
+                await page.addInitScript((organizationId) => {
+                    localStorage.setItem('satellizer_token', 'usage-budget-test-token');
+                    localStorage.setItem('organization', JSON.stringify(organizationId));
+                }, ORGANIZATION_ID);
+                await page.route('**/health', (route) => route.fulfill({ body: 'OK' }));
+                await page.routeWebSocket('**/api/v2/push**', () => {});
+                await page.route('**/api/v2/**', async (route) => {
+                    const path = new URL(route.request().url()).pathname;
+                    if (route.request().method() === 'PATCH') {
+                        const update = route.request().postDataJSON();
+                        updates.push(update);
+                        if (!rejectUpdate) {
+                            const model = resource === 'project' ? project : organization;
+                            Object.assign(model, update);
+                            await route.fulfill({ json: model });
+                            return;
+                        }
+
+                        await route.fulfill({
+                            contentType: 'application/problem+json',
+                            json: {
+                                errors: { [resource === 'project' ? 'ingest_limit' : 'budget_alert_settings']: ['Budget settings were rejected.'] },
+                                status: 422,
+                                title: 'Validation failed'
+                            },
+                            status: 422
+                        });
+                        return;
+                    }
+
+                    if (path === '/api/v2/users/me') {
+                        await route.fulfill({
+                            json: {
+                                email_address: 'budget@example.test',
+                                full_name: 'Budget Tester',
+                                id: '000000000000000000000002',
+                                is_active: true,
+                                is_email_address_verified: true,
+                                organization_ids: [ORGANIZATION_ID],
+                                organization_preferences: [],
+                                product_tours: { app_welcome: '2026-01-01T00:00:00Z' },
+                                roles: []
+                            }
+                        });
+                    } else if (path === `/api/v2/organizations/${ORGANIZATION_ID}`) {
+                        await route.fulfill({ json: organization });
+                    } else if (path === `/api/v2/projects/${PROJECT_ID}`) {
+                        await route.fulfill({ json: project });
+                    } else if (path === '/api/v2/organizations') {
+                        await route.fulfill({ json: [organization] });
+                    } else if (path.endsWith('/projects')) {
+                        await route.fulfill({ json: [project] });
+                    } else if (path === '/api/v2/assistant/access') {
+                        await route.fulfill({ json: { enabled: false, has_access: false, upgrade_required: false } });
+                    } else {
+                        await route.fulfill({ json: [] });
+                    }
+                });
+
+                const id = resource === 'project' ? PROJECT_ID : ORGANIZATION_ID;
+                await page.goto(`/${resource}/${id}/usage`);
+                if (resource === 'project') {
+                    await expect(page.getByText('Current project limit', { exact: true })).toBeVisible({ timeout: 2000 });
+                }
+                const input = page.getByRole('textbox', { name: resource === 'project' ? 'Monthly event count' : 'Threshold percentages' });
+                const save = page.getByRole('button', { name: resource === 'project' ? 'Save project budget' : 'Save budget alerts' });
+                await input.fill(resource === 'project' ? '1.5' : '75.5');
+                await save.click();
+                await expect(input).toHaveAttribute('aria-invalid', 'true');
+                expect(updates).toEqual([]);
+
+                await input.fill(resource === 'project' ? '200' : '60, 90');
+                await save.click();
+                await expect(page.getByText('Budget settings were rejected.', { exact: true })).toBeVisible();
+                await expect(input).toHaveValue(resource === 'project' ? '200' : '60, 90');
+                await page.screenshot({ path: testInfo.outputPath('server-validation.png') });
+
+                rejectUpdate = false;
+                await save.click();
+                await expect(page.getByText(resource === 'project' ? 'Project event budget saved.' : 'Budget alert settings saved.')).toBeVisible();
+                expect(updates.at(-1)).toEqual(
+                    resource === 'project'
+                        ? { ingest_limit: { fixed_limit: 200, percent_of_organization_limit: null, type: 0 } }
+                        : { budget_alert_settings: { enabled: true, thresholds: [60, 90] } }
+                );
+
+                if (resource === 'project') {
+                    await page.getByRole('combobox', { exact: true, name: 'Limit type' }).click();
+                    await page.getByRole('option', { exact: true, name: 'No project limit' }).click();
+                    await save.click();
+                    await expect.poll(() => updates.at(-1)).toEqual({ ingest_limit: null });
+                } else {
+                    await page.getByRole('button', { name: 'Clear settings' }).click();
+                    await expect(page.getByText('Budget alert settings cleared.')).toBeVisible();
+                    expect(updates.at(-1)).toEqual({ budget_alert_settings: null });
+                }
+
+                expect(errors).toEqual([]);
+                expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
+            });
+        }
+    });
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts
index bf922258ce..4535f27620 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts
@@ -10,7 +10,7 @@ import { accessToken } from '#features/auth/index.svelte.ts';
 import { fetchApiJson } from '#features/shared/api/api.svelte.ts';
 import { queryKeys as userQueryKeys } from '#features/users/api.svelte.ts';
 
-import type { Invoice, InvoiceGridModel, NewOrganization, SuspensionCode, ViewOrganization } from './models';
+import type { Invoice, InvoiceGridModel, NewOrganization, SuspensionCode, UpdateOrganization, ViewOrganization } from './models';
 
 export async function invalidateOrganizationQueries(queryClient: QueryClient, message: WebSocketMessageValue<'OrganizationChanged'>) {
     const { id } = message;
@@ -526,9 +526,9 @@ export function getPlansQuery(request: GetPlansRequest) {
 export function patchOrganization(request: PatchOrganizationRequest) {
     const queryClient = useQueryClient();
 
-    return createMutation<ViewOrganization, ProblemDetails, NewOrganization>(() => ({
+    return createMutation<ViewOrganization, ProblemDetails, UpdateOrganization>(() => ({
         enabled: () => !!accessToken.current && !!request.route.id,
-        mutationFn: async (data: NewOrganization) => {
+        mutationFn: async (data: UpdateOrganization) => {
             const client = useFetchClient();
             const response = await client.patchJSON<ViewOrganization>(`organizations/${request.route.id}`, data);
             return response.data!;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.test.ts
new file mode 100644
index 0000000000..37b9f40a06
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { getBudgetThresholdEventCount, parseBudgetThresholds } from './budget-utils';
+import { BudgetAlertCardSchema } from './schemas';
+
+describe('organization budget controls', () => {
+    it('normalizes, sorts, and deduplicates threshold input', () => {
+        expect(parseBudgetThresholds('80, 50, 80, 90')).toEqual([50, 80, 90]);
+        expect(parseBudgetThresholds('')).toEqual([]);
+        expect(parseBudgetThresholds('  ,  ')).toEqual([]);
+    });
+
+    it('rejects decimals, out-of-range thresholds, and empty enabled settings', () => {
+        expect(BudgetAlertCardSchema.safeParse({ enabled: true, thresholds: '' }).success).toBe(false);
+        expect(BudgetAlertCardSchema.safeParse({ enabled: false, thresholds: '50.5' }).success).toBe(false);
+        expect(BudgetAlertCardSchema.safeParse({ enabled: false, thresholds: '100' }).success).toBe(false);
+    });
+
+    it('calculates threshold event counts and disables percentages for unlimited plans', () => {
+        expect(getBudgetThresholdEventCount(1001, 50)).toBe(501);
+        expect(getBudgetThresholdEventCount(-1, 50)).toBeNull();
+        expect(getBudgetThresholdEventCount(1001, 50.5)).toBeNull();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.ts
new file mode 100644
index 0000000000..310def613c
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/budget-utils.ts
@@ -0,0 +1,20 @@
+export function getBudgetThresholdEventCount(eventLimit: number, threshold: number): null | number {
+    if (!Number.isFinite(eventLimit) || !Number.isInteger(threshold) || eventLimit < 0 || threshold < 1 || threshold > 99) {
+        return null;
+    }
+
+    return Math.ceil((eventLimit * threshold) / 100);
+}
+
+export function parseBudgetThresholds(value: string): number[] {
+    return [
+        ...new Set(
+            value
+                .split(',')
+                .map((threshold) => threshold.trim())
+                .filter(Boolean)
+                .map(Number)
+                .filter(Number.isFinite)
+        )
+    ].sort((left, right) => left - right);
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/notifications/organization-notifications.stories.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/notifications/organization-notifications.stories.svelte
index a09d43ad55..d847ce6041 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/notifications/organization-notifications.stories.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/notifications/organization-notifications.stories.svelte
@@ -26,6 +26,7 @@
             has_slack_integration: false,
             id: '1',
             is_configured: false,
+            is_smart_throttled: false,
             name: 'Frontend App',
             organization_id: 'org1',
             organization_name: 'Test Org',
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/organization-budget-alert-card.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/organization-budget-alert-card.svelte
new file mode 100644
index 0000000000..44c0f82fa5
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/organization-budget-alert-card.svelte
@@ -0,0 +1,175 @@
+<script lang="ts">
+    import { createForm } from '@tanstack/svelte-form';
+    import { toast } from 'svelte-sonner';
+
+    import type { ViewOrganization } from '#features/organizations/models.ts';
+
+    import ErrorMessage from '#comp/error-message.svelte';
+    import NumberFormatter from '#comp/formatters/number.svelte';
+    import { Button } from '#comp/ui/button/index.ts';
+    import * as Card from '#comp/ui/card/index.ts';
+    import * as Field from '#comp/ui/field/index.ts';
+    import { Input } from '#comp/ui/input/index.ts';
+    import { Spinner } from '#comp/ui/spinner/index.ts';
+    import { Switch } from '#comp/ui/switch/index.ts';
+    import { patchOrganization } from '#features/organizations/api.svelte.ts';
+    import { getBudgetThresholdEventCount, parseBudgetThresholds } from '#features/organizations/budget-utils.ts';
+    import { type BudgetAlertCardFormData, BudgetAlertCardSchema } from '#features/organizations/schemas.ts';
+    import { getEffectiveEventLimit } from '#features/organizations/utils.ts';
+    import { ariaInvalid, getFormErrorMessages, getProblemMessage, mapFieldErrors } from '#features/shared/validation.ts';
+
+    let { organization }: { organization: ViewOrganization } = $props();
+
+    const update = patchOrganization({
+        route: {
+            get id() {
+                return organization.id;
+            }
+        }
+    });
+    const organizationLimit = $derived(getEffectiveEventLimit(organization));
+    const isUnlimited = $derived(organizationLimit < 0);
+
+    const form = createForm(() => ({
+        defaultValues: {
+            enabled: organization.budget_alert_settings?.enabled ?? false,
+            thresholds: organization.budget_alert_settings?.thresholds.join(', ') ?? '50, 80'
+        } as BudgetAlertCardFormData,
+        validators: {
+            onSubmit: BudgetAlertCardSchema,
+            onSubmitAsync: async ({ value }) => {
+                if (value.enabled && isUnlimited) {
+                    return {
+                        form: 'Budget alerts require a finite monthly event allowance.'
+                    };
+                }
+
+                const thresholds = parseBudgetThresholds(value.thresholds);
+
+                try {
+                    await update.mutateAsync({
+                        budget_alert_settings: {
+                            enabled: value.enabled,
+                            thresholds
+                        }
+                    });
+                    toast.success('Budget alert settings saved.');
+                    return null;
+                } catch (error: unknown) {
+                    toast.error('Unable to save budget alert settings.');
+                    return {
+                        form: getProblemMessage(error, 'An unexpected error occurred.')
+                    };
+                }
+            }
+        }
+    }));
+
+    async function clearSettings() {
+        try {
+            await update.mutateAsync({
+                budget_alert_settings: null
+            });
+            form.setFieldValue('enabled', false);
+            form.setFieldValue('thresholds', '50, 80');
+            toast.success('Budget alert settings cleared.');
+        } catch {
+            toast.error('Unable to clear budget alert settings.');
+        }
+    }
+</script>
+
+<Card.Root>
+    <Card.Header>
+        <Card.Title>Budget alerts</Card.Title>
+        <Card.Description>Receive an email when accepted organization usage crosses selected percentages of the monthly allowance.</Card.Description>
+    </Card.Header>
+    <form
+        onsubmit={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            form.handleSubmit();
+        }}
+    >
+        <Card.Content>
+            <form.Subscribe selector={(state) => state.errors}>
+                {#snippet children(errors)}
+                    <ErrorMessage message={getFormErrorMessages(errors)} />
+                {/snippet}
+            </form.Subscribe>
+
+            <Field.Group>
+                <form.Field name="enabled">
+                    {#snippet children(field)}
+                        <Field.Field orientation="horizontal">
+                            <Field.Content>
+                                <Field.Label for={field.name}>Enable budget alerts</Field.Label>
+                                <Field.Description>Alerts are sent once per threshold per monthly usage period.</Field.Description>
+                            </Field.Content>
+                            <Switch
+                                id={field.name}
+                                checked={field.state.value}
+                                onCheckedChange={(checked) => field.handleChange(checked)}
+                                disabled={update.isPending || isUnlimited}
+                            />
+                        </Field.Field>
+                    {/snippet}
+                </form.Field>
+
+                <form.Field name="thresholds">
+                    {#snippet children(field)}
+                        <Field.Field data-invalid={ariaInvalid(field)}>
+                            <Field.Label for={field.name}>Threshold percentages</Field.Label>
+                            <Input
+                                id={field.name}
+                                name={field.name}
+                                inputmode="numeric"
+                                placeholder="50, 80, 90"
+                                value={field.state.value}
+                                onblur={field.handleBlur}
+                                oninput={(event) => field.handleChange(event.currentTarget.value)}
+                                aria-invalid={ariaInvalid(field)}
+                                aria-describedby="budget-threshold-help"
+                                disabled={update.isPending}
+                            />
+                            <Field.Description id="budget-threshold-help">Comma-separated whole numbers from 1 to 99.</Field.Description>
+                            <Field.Error errors={mapFieldErrors(field.state.meta.errors)} />
+
+                            <p class="text-muted-foreground text-sm" aria-live="polite">
+                                Current allowance:
+                                {#if isUnlimited}
+                                    unlimited; percentage alerts are inactive.
+                                {:else}
+                                    <NumberFormatter value={organizationLimit} /> events.
+                                {/if}
+                            </p>
+                            {#if !isUnlimited}
+                                <ul class="text-muted-foreground grid gap-1 text-sm" aria-live="polite">
+                                    {#each parseBudgetThresholds(field.state.value).filter((threshold) => Number.isInteger(threshold) && threshold >= 1 && threshold <= 99) as threshold (threshold)}
+                                        <li>
+                                            {threshold}% =
+                                            <NumberFormatter value={getBudgetThresholdEventCount(organizationLimit, threshold)!} /> events
+                                        </li>
+                                    {/each}
+                                </ul>
+                            {/if}
+                        </Field.Field>
+                    {/snippet}
+                </form.Field>
+            </Field.Group>
+        </Card.Content>
+        <Card.Footer class="justify-between gap-3">
+            <Button type="button" variant="ghost" onclick={clearSettings} disabled={update.isPending || !organization.budget_alert_settings}
+                >Clear settings</Button
+            >
+            <form.Subscribe selector={(state) => state.isSubmitting}>
+                {#snippet children(isSubmitting)}
+                    <Button type="submit" disabled={isSubmitting || update.isPending}>
+                        {#if isSubmitting || update.isPending}<Spinner />{/if}
+                        Save budget alerts
+                    </Button>
+                {/snippet}
+            </form.Subscribe>
+        </Card.Footer>
+    </form>
+</Card.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/models.ts
index 9bae5f8eaf..e30a956195 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/models.ts
@@ -1,4 +1,6 @@
-export type { Invoice, InvoiceGridModel, NewOrganization, ViewOrganization } from '#generated/api.ts';
+import type { UpdateOrganization as GeneratedUpdateOrganization } from '#generated/api.ts';
+
+export type { Invoice, InvoiceGridModel, NewOrganization, OrganizationBudgetAlertSettings, ViewOrganization } from '#generated/api.ts';
 
 // TODO: This should be generated from the backend enum - investigate why it wasn't included in the generated API
 export enum SuspensionCode {
@@ -7,3 +9,5 @@ export enum SuspensionCode {
     Abuse = 2,
     Other = 100
 }
+
+export type UpdateOrganization = Partial<GeneratedUpdateOrganization>;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/schemas.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/schemas.ts
index 2983648a05..db2db17a0d 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/schemas.ts
@@ -1,9 +1,29 @@
-import { date, type infer as Infer, number, object, string, enum as zodEnum } from 'zod';
+import { boolean, date, type infer as Infer, number, object, string, enum as zodEnum } from 'zod';
 
 import { SuspensionCode } from './models';
 
 export { type NewOrganizationFormData, NewOrganizationSchema } from '#generated/schemas.ts';
 
+export const BudgetAlertCardSchema = object({
+    enabled: boolean(),
+    thresholds: string()
+}).superRefine((settings, context) => {
+    const values = settings.thresholds
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+
+    if (settings.enabled && values.length === 0) {
+        context.addIssue({ code: 'custom', message: 'Enter at least one threshold.', path: ['thresholds'] });
+        return;
+    }
+
+    if (values.some((value) => !/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 99)) {
+        context.addIssue({ code: 'custom', message: 'Use whole-number percentages from 1 to 99.', path: ['thresholds'] });
+    }
+});
+export type BudgetAlertCardFormData = Infer<typeof BudgetAlertCardSchema>;
+
 export const SetBonusOrganizationSchema = object({
     bonusEvents: number().int('Bonus events must be a whole number'),
     expires: date().optional()
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.test.ts
index 92ccda8eec..dd6b8995d6 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.test.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.test.ts
@@ -1,6 +1,34 @@
 import { describe, expect, it } from 'vitest';
 
-import { getUtcMonthKey } from './utils';
+import type { ViewOrganization } from './models';
+
+import { getEffectiveEventLimit, getUtcMonthKey } from './utils';
+
+function organization(overrides: Partial<ViewOrganization>): ViewOrganization {
+    return { bonus_events_per_month: 0, max_events_per_month: 1000, usage: [], ...overrides } as ViewOrganization;
+}
+
+describe('getEffectiveEventLimit', () => {
+    it('uses the current usage limit so active bonus events match backend enforcement', () => {
+        const now = new Date();
+        const usageDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+        const value = organization({
+            bonus_events_per_month: 250,
+            max_events_per_month: 1000,
+            usage: [{ blocked: 0, date: usageDate.toISOString(), deleted: 0, discarded: 0, limit: 1250, too_big: 0, total: 0 }]
+        });
+
+        expect(getEffectiveEventLimit(value)).toBe(1250);
+    });
+
+    it('preserves unlimited organizations', () => {
+        expect(getEffectiveEventLimit(organization({ max_events_per_month: -1 }))).toBe(-1);
+    });
+
+    it('treats legacy zero-limit organizations as unlimited', () => {
+        expect(getEffectiveEventLimit(organization({ max_events_per_month: 0 }))).toBe(-1);
+    });
+});
 
 describe('getUtcMonthKey', () => {
     it('changes only when the UTC month changes', () => {
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.ts
index 293208f74c..f2c9ebd5a7 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/utils.ts
@@ -2,6 +2,21 @@ import { isSameUtcMonth } from '#features/shared/dates.ts';
 
 import type { ViewOrganization } from './models';
 
+export function getEffectiveEventLimit(organization?: ViewOrganization): number {
+    if (organization?.max_events_per_month == null || organization.max_events_per_month <= 0) {
+        return -1;
+    }
+
+    const now = new Date();
+    const currentUsage = organization.usage?.[organization.usage.length - 1];
+    if (currentUsage && isSameUtcMonth(new Date(currentUsage.date), now)) {
+        return currentUsage.limit;
+    }
+
+    const bonusEvents = organization.bonus_expiration && new Date(organization.bonus_expiration) > now ? organization.bonus_events_per_month : 0;
+    return organization.max_events_per_month + bonusEvents;
+}
+
 export const ORGANIZATION_USAGE_REFETCH_INTERVAL_MS = 5 * 60 * 1000;
 export const ORGANIZATION_USAGE_ROLLOVER_CHECK_INTERVAL_MS = 60 * 1000;
 
@@ -15,23 +30,22 @@ export function getNextBillingDateUtc(organization?: ViewOrganization): Date {
 }
 
 export function getRemainingEventLimit(organization?: ViewOrganization): number {
-    if (!organization?.max_events_per_month) {
+    const eventLimit = getEffectiveEventLimit(organization);
+    if (eventLimit <= 0) {
         return 0;
     }
 
     const now = new Date();
-    const bonusEvents = organization.bonus_expiration && new Date(organization.bonus_expiration) > now ? organization.bonus_events_per_month : 0;
-
-    const usage = organization.usage && organization.usage[organization.usage.length - 1];
+    const usage = organization?.usage?.[organization.usage.length - 1];
     if (usage) {
         const usageDate = new Date(usage.date);
         if (isSameUtcMonth(usageDate, now)) {
-            const remaining = usage.limit - usage.total;
+            const remaining = eventLimit - usage.total;
             return remaining > 0 ? remaining : 0;
         }
     }
 
-    return organization.max_events_per_month + bonusEvents;
+    return eventLimit;
 }
 
 export function getUtcMonthKey(date = new Date()): number {
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/api.svelte.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/api.svelte.test.ts
index 7edc6537e6..9173ad165d 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/api.svelte.test.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/api.svelte.test.ts
@@ -28,6 +28,7 @@ describe('project read lifecycle', () => {
         has_premium_features: false,
         has_slack_integration: false,
         id: 'project-id',
+        is_smart_throttled: false,
         name: 'Example',
         organization_id: 'organization-id',
         organization_name: 'Example organization',
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.test.ts
new file mode 100644
index 0000000000..dea43b46c0
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import { createProjectIngestLimit, getEffectiveProjectLimit } from './budget-utils';
+import { ProjectBudgetCardSchema } from './schemas';
+
+describe('project budget controls', () => {
+    it('rejects truncated fixed decimals and out-of-range percentages', () => {
+        expect(ProjectBudgetCardSchema.safeParse({ type: 'fixed', value: '1.5' }).success).toBe(false);
+        expect(ProjectBudgetCardSchema.safeParse({ type: 'fixed', value: '10' }).success).toBe(true);
+        expect(ProjectBudgetCardSchema.safeParse({ type: 'percent', value: '100.1' }).success).toBe(false);
+        expect(ProjectBudgetCardSchema.safeParse({ type: 'percent', value: '0.0001' }).success).toBe(true);
+        expect(ProjectBudgetCardSchema.safeParse({ type: 'percent', value: '0.00001' }).success).toBe(false);
+    });
+
+    it('maps modes to additive API payloads', () => {
+        expect(createProjectIngestLimit('none', '')).toBeNull();
+        expect(createProjectIngestLimit('fixed', 'not-a-number')).toBeNull();
+        expect(createProjectIngestLimit('fixed', '20000')).toMatchObject({ fixed_limit: 20000, type: 0 });
+        expect(createProjectIngestLimit('percent', '25.5')).toMatchObject({ percent_of_organization_limit: 25.5, type: 1 });
+    });
+
+    it('calculates percentage caps and clamps fixed caps to finite organization allowance', () => {
+        expect(getEffectiveProjectLimit(1001, createProjectIngestLimit('percent', '50'))).toBe(501);
+        expect(getEffectiveProjectLimit(3000, createProjectIngestLimit('percent', '1.1'))).toBe(33);
+        expect(getEffectiveProjectLimit(1_000_000, createProjectIngestLimit('percent', '8.3'))).toBe(83_000);
+        expect(getEffectiveProjectLimit(1_000_000, createProjectIngestLimit('percent', '0.0001'))).toBe(1);
+        expect(getEffectiveProjectLimit(1000, createProjectIngestLimit('fixed', '2000'))).toBe(1000);
+        expect(getEffectiveProjectLimit(-1, createProjectIngestLimit('percent', '50'))).toBeNull();
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.ts
new file mode 100644
index 0000000000..3ac872386d
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/budget-utils.ts
@@ -0,0 +1,42 @@
+import { type ProjectIngestLimit, ProjectIngestLimitType } from './models';
+
+export type ProjectBudgetType = 'fixed' | 'none' | 'percent';
+
+export function createProjectIngestLimit(type: ProjectBudgetType, value: string): null | ProjectIngestLimit {
+    if (type === 'none') {
+        return null;
+    }
+
+    const numericValue = Number(value.trim());
+    if (!Number.isFinite(numericValue)) {
+        return null;
+    }
+
+    return type === 'fixed'
+        ? { fixed_limit: numericValue, percent_of_organization_limit: null, type: ProjectIngestLimitType.Fixed }
+        : { fixed_limit: null, percent_of_organization_limit: numericValue, type: ProjectIngestLimitType.PercentOfOrganizationLimit };
+}
+
+export function getEffectiveProjectLimit(organizationLimit: number, ingestLimit: null | ProjectIngestLimit): null | number {
+    if (!ingestLimit) {
+        return null;
+    }
+
+    if (ingestLimit.type === ProjectIngestLimitType.Fixed) {
+        if (!Number.isInteger(ingestLimit.fixed_limit) || (ingestLimit.fixed_limit ?? 0) <= 0) {
+            return null;
+        }
+
+        return organizationLimit < 0 ? ingestLimit.fixed_limit! : Math.min(ingestLimit.fixed_limit!, organizationLimit);
+    }
+
+    const percentage = ingestLimit.percent_of_organization_limit;
+    if (organizationLimit < 0 || percentage == null || !Number.isFinite(percentage) || percentage <= 0 || percentage > 100) {
+        return null;
+    }
+
+    // The API accepts at most 4 decimal places. Scaling both operands to integers keeps this preview
+    // aligned with the server's exact decimal ceiling without binary floating-point boundary errors.
+    const scaledPercentage = Math.round(percentage * 10_000);
+    return Math.min(organizationLimit, Math.ceil((organizationLimit * scaledPercentage) / 1_000_000));
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/components/project-ingest-limit-card.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/components/project-ingest-limit-card.svelte
new file mode 100644
index 0000000000..3825a6e347
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/components/project-ingest-limit-card.svelte
@@ -0,0 +1,202 @@
+<script lang="ts">
+    import { createForm } from '@tanstack/svelte-form';
+    import { untrack } from 'svelte';
+    import { toast } from 'svelte-sonner';
+
+    import ErrorMessage from '#comp/error-message.svelte';
+    import NumberFormatter from '#comp/formatters/number.svelte';
+    import * as Alert from '#comp/ui/alert/index.ts';
+    import { Badge } from '#comp/ui/badge/index.ts';
+    import { Button } from '#comp/ui/button/index.ts';
+    import * as Card from '#comp/ui/card/index.ts';
+    import * as Field from '#comp/ui/field/index.ts';
+    import { Input } from '#comp/ui/input/index.ts';
+    import * as Select from '#comp/ui/select/index.ts';
+    import { Spinner } from '#comp/ui/spinner/index.ts';
+    import { updateProject } from '#features/projects/api.svelte.ts';
+    import { createProjectIngestLimit, getEffectiveProjectLimit, type ProjectBudgetType } from '#features/projects/budget-utils.ts';
+    import { ProjectIngestLimitType, type ViewProject } from '#features/projects/models.ts';
+    import { type ProjectBudgetCardFormData, ProjectBudgetCardSchema } from '#features/projects/schemas.ts';
+    import { ariaInvalid, getFormErrorMessages, getProblemMessage, mapFieldErrors } from '#features/shared/validation.ts';
+
+    let { organizationLimit, project }: { organizationLimit: number; project: ViewProject } = $props();
+
+    const initialProject = untrack(() => project);
+    const initialType: ProjectBudgetType = !initialProject.ingest_limit
+        ? 'none'
+        : initialProject.ingest_limit.type === ProjectIngestLimitType.Fixed
+          ? 'fixed'
+          : 'percent';
+    const initialValue =
+        initialType === 'fixed'
+            ? (initialProject.ingest_limit?.fixed_limit?.toString() ?? '')
+            : initialType === 'percent'
+              ? (initialProject.ingest_limit?.percent_of_organization_limit?.toString() ?? '')
+              : '';
+
+    let selectedType = $state<ProjectBudgetType>(initialType);
+    const update = updateProject({
+        route: {
+            get id() {
+                return project.id;
+            }
+        }
+    });
+
+    const form = createForm(() => ({
+        defaultValues: {
+            type: initialType,
+            value: initialValue
+        } as ProjectBudgetCardFormData,
+        validators: {
+            onSubmit: ProjectBudgetCardSchema,
+            onSubmitAsync: async ({ value }) => {
+                if (value.type === 'percent' && organizationLimit < 0) {
+                    return {
+                        form: 'Percentage limits require a finite organization allowance.'
+                    };
+                }
+
+                const ingestLimit = createProjectIngestLimit(value.type, value.value);
+
+                try {
+                    await update.mutateAsync({
+                        ingest_limit: ingestLimit
+                    });
+                    toast.success('Project event budget saved.');
+                    return null;
+                } catch (error: unknown) {
+                    toast.error('Unable to save the project event budget.');
+                    return {
+                        form: getProblemMessage(error, 'An unexpected error occurred.')
+                    };
+                }
+            }
+        }
+    }));
+</script>
+
+<Card.Root>
+    <Card.Header>
+        <Card.Title>Project event budget</Card.Title>
+        <Card.Description>Optionally cap accepted events for this project without changing the organization allowance.</Card.Description>
+    </Card.Header>
+    <form
+        onsubmit={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            form.handleSubmit();
+        }}
+    >
+        <Card.Content>
+            <form.Subscribe selector={(state) => state.errors}>
+                {#snippet children(errors)}
+                    <ErrorMessage message={getFormErrorMessages(errors)} />
+                {/snippet}
+            </form.Subscribe>
+
+            <Field.Group>
+                <form.Field name="type">
+                    {#snippet children(field)}
+                        <Field.Field>
+                            <Field.Label for={field.name}>Limit type</Field.Label>
+                            <Select.Root
+                                type="single"
+                                value={field.state.value}
+                                onValueChange={(value) => {
+                                    const nextType = value as ProjectBudgetType;
+                                    selectedType = nextType;
+                                    field.handleChange(nextType);
+                                    if (nextType === 'none') {
+                                        form.setFieldValue('value', '');
+                                    }
+                                }}
+                                disabled={update.isPending}
+                            >
+                                <Select.Trigger id={field.name} class="w-full sm:w-64">
+                                    {selectedType === 'none'
+                                        ? 'No project limit'
+                                        : selectedType === 'fixed'
+                                          ? 'Fixed event count'
+                                          : 'Percentage of organization allowance'}
+                                </Select.Trigger>
+                                <Select.Content>
+                                    <Select.Group>
+                                        <Select.Item value="none">No project limit</Select.Item>
+                                        <Select.Item value="fixed">Fixed event count</Select.Item>
+                                        <Select.Item value="percent" disabled={organizationLimit < 0}>Percentage of organization allowance</Select.Item>
+                                    </Select.Group>
+                                </Select.Content>
+                            </Select.Root>
+                        </Field.Field>
+                    {/snippet}
+                </form.Field>
+
+                {#if selectedType !== 'none'}
+                    <form.Field name="value">
+                        {#snippet children(field)}
+                            <Field.Field data-invalid={ariaInvalid(field)}>
+                                <Field.Label for={field.name}>{selectedType === 'fixed' ? 'Monthly event count' : 'Percentage'}</Field.Label>
+                                <Input
+                                    id={field.name}
+                                    name={field.name}
+                                    inputmode={selectedType === 'fixed' ? 'numeric' : 'decimal'}
+                                    placeholder={selectedType === 'fixed' ? '100000' : '50'}
+                                    value={field.state.value}
+                                    onblur={field.handleBlur}
+                                    oninput={(event) => field.handleChange(event.currentTarget.value)}
+                                    aria-invalid={ariaInvalid(field)}
+                                    disabled={update.isPending}
+                                />
+                                <Field.Description>
+                                    {selectedType === 'fixed'
+                                        ? 'Use a whole number greater than 0. The effective cap cannot exceed a finite organization allowance.'
+                                        : 'Use a value greater than 0 and no more than 100.'}
+                                </Field.Description>
+                                <Field.Error errors={mapFieldErrors(field.state.meta.errors)} />
+                            </Field.Field>
+                        {/snippet}
+                    </form.Field>
+                {/if}
+
+                <form.Subscribe selector={(state) => state.values}>
+                    {#snippet children(values)}
+                        {@const draftLimit = createProjectIngestLimit(values.type, values.value)}
+                        {@const effectiveLimit = getEffectiveProjectLimit(organizationLimit, draftLimit)}
+                        <p class="text-muted-foreground text-sm" aria-live="polite">
+                            Effective project limit:
+                            {#if effectiveLimit == null}
+                                organization allowance
+                            {:else}
+                                <NumberFormatter value={effectiveLimit} /> events per month
+                            {/if}
+                        </p>
+                        {#if values.type === 'fixed' && organizationLimit >= 0 && (draftLimit?.fixed_limit ?? 0) > organizationLimit}
+                            <Alert.Root role="status">
+                                <Alert.Title>Fixed limit will be clamped</Alert.Title>
+                                <Alert.Description>The effective cap cannot exceed the organization's finite event allowance.</Alert.Description>
+                            </Alert.Root>
+                        {/if}
+                    {/snippet}
+                </form.Subscribe>
+
+                {#if project.is_smart_throttled}
+                    <Alert.Root role="status">
+                        <Alert.Title class="flex items-center gap-2">Smart throttling active <Badge variant="secondary">5% sample</Badge></Alert.Title>
+                        <Alert.Description>This project is being sampled independently; other projects remain unaffected.</Alert.Description>
+                    </Alert.Root>
+                {/if}
+            </Field.Group>
+        </Card.Content>
+        <Card.Footer class="justify-end">
+            <form.Subscribe selector={(state) => state.isSubmitting}>
+                {#snippet children(isSubmitting)}
+                    <Button type="submit" disabled={isSubmitting || update.isPending}>
+                        {#if isSubmitting || update.isPending}<Spinner />{/if}
+                        Save project budget
+                    </Button>
+                {/snippet}
+            </form.Subscribe>
+        </Card.Footer>
+    </form>
+</Card.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
index 32a7ec647e..4169857eb9 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
@@ -1,5 +1,7 @@
-export type { ClientConfiguration, NewProject, NotificationSettings, UpdateProject, ViewProject } from '#generated/api.ts';
+import type { UpdateProject as GeneratedUpdateProject } from '#generated/api.ts';
 
+export { ProjectIngestLimitType } from '#generated/api.ts';
+export type { ClientConfiguration, NewProject, NotificationSettings, ProjectIngestLimit, ViewProject } from '#generated/api.ts';
 export interface ClientConfigurationSetting {
     key: string;
     value: string;
@@ -15,3 +17,5 @@ export interface SourceMapArtifact {
     size: number;
     source_map_url?: string;
 }
+
+export type UpdateProject = Partial<GeneratedUpdateProject>;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts
index 05315abf68..e8607b537d 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts
@@ -1,4 +1,4 @@
-import { custom, type infer as Infer, object, string } from 'zod';
+import { custom, type infer as Infer, object, string, enum as zodEnum } from 'zod';
 
 import {
     UpdateProjectSchema as GeneratedUpdateProjectSchema,
@@ -19,6 +19,31 @@ export type ClientConfigurationSettingFormData = Infer<typeof ClientConfiguratio
 export const UpdateProjectSchema = GeneratedUpdateProjectSchema.partial();
 export type UpdateProjectFormData = Infer<typeof UpdateProjectSchema>;
 
+export const ProjectBudgetCardSchema = object({
+    type: zodEnum(['none', 'fixed', 'percent']),
+    value: string()
+}).superRefine((budget, context) => {
+    if (budget.type === 'none') {
+        return;
+    }
+
+    const value = budget.value.trim();
+    if (budget.type === 'fixed') {
+        const numericValue = Number(value);
+        if (!/^\d+$/.test(value) || !Number.isSafeInteger(numericValue) || numericValue < 1 || numericValue > 2_147_483_647) {
+            context.addIssue({ code: 'custom', message: 'Enter a whole number from 1 to 2,147,483,647.', path: ['value'] });
+        }
+
+        return;
+    }
+
+    const numericValue = Number(value);
+    if (!/^(?:\d+(?:\.\d{0,4})?|\.\d{1,4})$/.test(value) || !Number.isFinite(numericValue) || numericValue <= 0 || numericValue > 100) {
+        context.addIssue({ code: 'custom', message: 'Enter a percentage greater than 0 and no more than 100, with up to 4 decimal places.', path: ['value'] });
+    }
+});
+export type ProjectBudgetCardFormData = Infer<typeof ProjectBudgetCardSchema>;
+
 export const SourceMapUploadSchema = object({
     file: custom<File | null>((value) => typeof File !== 'undefined' && value instanceof File, 'Source map file is required'),
     generated_file_url: string().url('Enter the absolute URL of the generated JavaScript file')
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
index 4010d85b3e..b2ea5b8704 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
@@ -7,6 +7,11 @@ export enum StackStatus {
   Discarded = "discarded",
 }
 
+export enum ProjectIngestLimitType {
+  Fixed = 0,
+  PercentOfOrganizationLimit = 1,
+}
+
 export enum BillingStatus {
   Trialing = 0,
   Active = 1,
@@ -250,6 +255,7 @@ export interface NewProject {
   organization_id: string;
   name: string;
   delete_bot_data_enabled: boolean;
+  ingest_limit?: null | ProjectIngestLimit;
   promoted_tabs?: string[] | null;
 }
 
@@ -415,6 +421,15 @@ export interface OAuthTokenResponse {
   resource?: null | string;
 }
 
+export interface OrganizationBudgetAlertSettings {
+  enabled: boolean;
+  /**
+   * Percentage thresholds of the organization's effective monthly event allowance.
+   * Example: [50, 80, 90].
+   */
+  thresholds: number[];
+}
+
 export interface PersistentEvent {
   /**
    * Unique id that identifies an event.
@@ -507,6 +522,14 @@ export interface ProblemDetails {
   instance?: null | string;
 }
 
+export interface ProjectIngestLimit {
+  type: ProjectIngestLimitType;
+  /** @format int32 */
+  fixed_limit?: null | number;
+  /** @format double */
+  percent_of_organization_limit?: null | number;
+}
+
 export interface RecordProductTourResult {
   /** @format date-time */
   recorded_utc: string;
@@ -674,11 +697,18 @@ export interface UpdateEventSubmissionSettings {
   enabled?: null | boolean;
 }
 
+/** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
+export interface UpdateOrganization {
+  name: string;
+  budget_alert_settings?: null | OrganizationBudgetAlertSettings;
+}
+
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
 export interface UpdateProject {
   name: string;
   delete_bot_data_enabled: boolean;
-  promoted_tabs?: string[] | null;
+  ingest_limit?: null | ProjectIngestLimit;
+  promoted_tabs?: null | string[];
 }
 
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
@@ -907,6 +937,7 @@ export interface ViewOrganization {
   is_throttled: boolean;
   is_over_monthly_limit: boolean;
   is_over_request_limit: boolean;
+  budget_alert_settings?: null | OrganizationBudgetAlertSettings;
 }
 
 export interface ViewProject {
@@ -928,6 +959,12 @@ export interface ViewProject {
   event_count: number;
   has_premium_features: boolean;
   has_slack_integration: boolean;
+  ingest_limit?: null | ProjectIngestLimit;
+  /** @format int32 */
+  effective_ingest_limit?: null | number;
+  is_smart_throttled: boolean;
+  /** @format double */
+  smart_throttle_sample_rate?: null | number;
   usage_hours: UsageHourInfo[];
   usage: UsageInfo[];
 }
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
index a0ad26433e..e218c82915 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/generated/schemas.ts
@@ -27,6 +27,7 @@ export const StackStatusSchema = zodEnum([
   "ignored",
   "discarded",
 ]);
+export const ProjectIngestLimitTypeSchema = union([literal(0), literal(1)]);
 export const BillingStatusSchema = union([
   literal(0),
   literal(1),
@@ -53,10 +54,10 @@ export const AdminAssistantOrganizationUsageSchema = object({
   blocked_by_rate_limit: int(),
   blocked_by_token_limit: int(),
   blocked_by_cost_limit: int(),
-  monthly_token_limit: int().nullable(),
-  monthly_cost_limit_usd: number().nullable(),
-  token_utilization: number().nullable(),
-  cost_utilization: number().nullable(),
+  monthly_token_limit: int().nullable().optional(),
+  monthly_cost_limit_usd: number().nullable().optional(),
+  token_utilization: number().nullable().optional(),
+  cost_utilization: number().nullable().optional(),
 });
 export type AdminAssistantOrganizationUsageFormData = Infer<
   typeof AdminAssistantOrganizationUsageSchema
@@ -203,8 +204,10 @@ export const CountResultSchema = object({
   aggregations: record(
     string(),
     lazy(() => IAggregateSchema),
-  ),
-  data: record(string(), unknown()).nullable(),
+  )
+    .nullable()
+    .optional(),
+  data: record(string(), unknown()).nullable().optional(),
 });
 export type CountResultFormData = Infer<typeof CountResultSchema>;
 
@@ -305,6 +308,9 @@ export const NewProjectSchema = object({
     .regex(/^[a-fA-F0-9]{24}$/, "Organization id has invalid format"),
   name: string().min(1, "Name is required"),
   delete_bot_data_enabled: boolean(),
+  ingest_limit: lazy(() => ProjectIngestLimitSchema)
+    .nullable()
+    .optional(),
   promoted_tabs: array(string()).nullable().optional(),
 });
 export type NewProjectFormData = Infer<typeof NewProjectSchema>;
@@ -563,6 +569,14 @@ export const OAuthTokenResponseSchema = object({
 });
 export type OAuthTokenResponseFormData = Infer<typeof OAuthTokenResponseSchema>;
 
+export const OrganizationBudgetAlertSettingsSchema = object({
+  enabled: boolean(),
+  thresholds: array(number()),
+});
+export type OrganizationBudgetAlertSettingsFormData = Infer<
+  typeof OrganizationBudgetAlertSettingsSchema
+>;
+
 export const PersistentEventSchema = object({
   id: string()
     .length(24, "Id must be exactly 24 characters")
@@ -587,7 +601,8 @@ export const PersistentEventSchema = object({
   type: string()
     .min(1, "Type is required")
     .max(100, "Type must be at most 100 characters")
-    .nullable(),
+    .nullable()
+    .optional(),
   source: string()
     .min(1, "Source is required")
     .max(2000, "Source must be at most 2000 characters")
@@ -619,7 +634,7 @@ export const PredefinedSavedViewDefinitionSchema = object({
   filter: string().min(1, "Filter is required").nullable().optional(),
   time: string().min(1, "Time is required").nullable().optional(),
   sort: string().min(1, "Sort is required").nullable().optional(),
-  filterDefinitions: unknown().optional(),
+  filterDefinitions: unknown().nullable().optional(),
   columns: record(
     string(),
     lazy(() => SavedViewColumnSettingsSchema),
@@ -642,6 +657,13 @@ export const ProblemDetailsSchema = object({
 });
 export type ProblemDetailsFormData = Infer<typeof ProblemDetailsSchema>;
 
+export const ProjectIngestLimitSchema = object({
+  type: ProjectIngestLimitTypeSchema,
+  fixed_limit: int32().nullable().optional(),
+  percent_of_organization_limit: number().nullable().optional(),
+});
+export type ProjectIngestLimitFormData = Infer<typeof ProjectIngestLimitSchema>;
+
 export const RecordProductTourResultSchema = object({
   recorded_utc: iso.datetime(),
 });
@@ -742,7 +764,7 @@ export const StackSchema = object({
 export type StackFormData = Infer<typeof StackSchema>;
 
 export const StringValueFromBodySchema = object({
-  value: string().min(1, "Value is required").nullable(),
+  value: string().min(1, "Value is required").nullable().optional(),
 });
 export type StringValueFromBodyFormData = Infer<
   typeof StringValueFromBodySchema
@@ -754,7 +776,7 @@ export const TokenResultSchema = object({
 export type TokenResultFormData = Infer<typeof TokenResultSchema>;
 
 export const UpdateAssistantConversationSharingSchema = object({
-  enabled: boolean().nullable(),
+  enabled: boolean().nullable().optional(),
 });
 export type UpdateAssistantConversationSharingFormData = Infer<
   typeof UpdateAssistantConversationSharingSchema
@@ -805,9 +827,20 @@ export type UpdateEventSubmissionSettingsFormData = Infer<
   typeof UpdateEventSubmissionSettingsSchema
 >;
 
+export const UpdateOrganizationSchema = object({
+  name: string().min(1, "Name is required").optional(),
+  budget_alert_settings: lazy(() => OrganizationBudgetAlertSettingsSchema)
+    .nullable()
+    .optional(),
+});
+export type UpdateOrganizationFormData = Infer<typeof UpdateOrganizationSchema>;
+
 export const UpdateProjectSchema = object({
   name: string().min(1, "Name is required").optional(),
   delete_bot_data_enabled: boolean().optional(),
+  ingest_limit: lazy(() => ProjectIngestLimitSchema)
+    .nullable()
+    .optional(),
   promoted_tabs: array(string()).nullable().optional(),
 });
 export type UpdateProjectFormData = Infer<typeof UpdateProjectSchema>;
@@ -1052,6 +1085,9 @@ export const ViewOrganizationSchema = object({
   is_throttled: boolean(),
   is_over_monthly_limit: boolean(),
   is_over_request_limit: boolean(),
+  budget_alert_settings: lazy(() => OrganizationBudgetAlertSettingsSchema)
+    .nullable()
+    .optional(),
 });
 export type ViewOrganizationFormData = Infer<typeof ViewOrganizationSchema>;
 
@@ -1073,6 +1109,12 @@ export const ViewProjectSchema = object({
   event_count: int(),
   has_premium_features: boolean(),
   has_slack_integration: boolean(),
+  ingest_limit: lazy(() => ProjectIngestLimitSchema)
+    .nullable()
+    .optional(),
+  effective_ingest_limit: int32().nullable().optional(),
+  is_smart_throttled: boolean(),
+  smart_throttle_sample_rate: number().nullable().optional(),
   usage_hours: array(lazy(() => UsageHourInfoSchema)),
   usage: array(lazy(() => UsageInfoSchema)),
 });
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte
index 454149affb..b190ac7a51 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/usage/+page.svelte
@@ -14,6 +14,7 @@
     import { Skeleton } from '#comp/ui/skeleton/index.ts';
     import { ChangePlanDialog } from '#features/billing/index.ts';
     import { getOrganizationQuery } from '#features/organizations/api.svelte.ts';
+    import OrganizationBudgetAlertCard from '#features/organizations/components/organization-budget-alert-card.svelte';
     import { getNextBillingDateUtc, getRemainingEventLimit, ORGANIZATION_USAGE_REFETCH_INTERVAL_MS } from '#features/organizations/utils.ts';
     import { formatDateLabel, formatLongDate } from '#shared/dates.ts';
 
@@ -178,6 +179,12 @@
     {/if}
 </div>
 
+{#if organizationQuery.data}
+    {#key organizationQuery.data.id}
+        <OrganizationBudgetAlertCard organization={organizationQuery.data} />
+    {/key}
+{/if}
+
 {#if changePlanDialogOpen && organizationQuery.data}
     <ChangePlanDialog organization={organizationQuery.data} onclose={() => (changePlanDialogOpen = false)} />
 {/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte
index 0de87a451c..9570da0f5d 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/usage/+page.svelte
@@ -15,8 +15,14 @@
     import { ChangePlanDialog } from '#features/billing/index.ts';
     import { getOrganizationQuery } from '#features/organizations/api.svelte.ts';
     import { organization } from '#features/organizations/context.svelte.ts';
-    import { getNextBillingDateUtc, getRemainingEventLimit, ORGANIZATION_USAGE_REFETCH_INTERVAL_MS } from '#features/organizations/utils.ts';
+    import {
+        getEffectiveEventLimit,
+        getNextBillingDateUtc,
+        getRemainingEventLimit,
+        ORGANIZATION_USAGE_REFETCH_INTERVAL_MS
+    } from '#features/organizations/utils.ts';
     import { getProjectQuery } from '#features/projects/api.svelte.ts';
+    import ProjectIngestLimitCard from '#features/projects/components/project-ingest-limit-card.svelte';
     import { formatDateLabel, formatLongDate } from '#shared/dates.ts';
 
     const organizationQuery = getOrganizationQuery({
@@ -34,6 +40,7 @@
     const hasMonthlyUsage = $derived((organizationQuery.data?.max_events_per_month ?? 0) > 0);
     const canChangePlan = $derived(organizationQuery.isSuccess && !!PUBLIC_STRIPE_PUBLISHABLE_KEY);
     const remainingEventLimit = $derived(getRemainingEventLimit(organizationQuery.data));
+    const organizationLimit = $derived(getEffectiveEventLimit(organizationQuery.data));
     const nextBillingDate = $derived(getNextBillingDateUtc(organizationQuery.data));
 
     const projectQuery = getProjectQuery({
@@ -47,7 +54,7 @@
 
     let changePlanDialogOpen = $state(false);
 
-    const chartConfig = {
+    const chartConfig = $derived({
         blocked: {
             color: 'var(--chart-2)',
             label: 'Blocked'
@@ -62,7 +69,7 @@
         },
         limit: {
             color: 'var(--chart-6)',
-            label: 'Limit'
+            label: projectQuery.data?.effective_ingest_limit == null ? 'Organization limit' : 'Current project limit'
         },
         org_total: {
             color: 'var(--chart-5)',
@@ -76,7 +83,7 @@
             color: 'var(--chart-1)',
             label: 'Total'
         }
-    } satisfies Chart.ChartConfig;
+    } satisfies Chart.ChartConfig);
 
     const chartData = $derived.by(() => {
         const project = projectQuery.data;
@@ -100,7 +107,7 @@
                 date: new Date(projItem.date),
                 deleted: projItem.deleted,
                 discarded: projItem.discarded,
-                limit: orgItem?.limit || 0,
+                limit: project.effective_ingest_limit ?? orgItem?.limit ?? 0,
                 org_total: orgItem?.total || 0,
                 too_big: projItem.too_big,
                 total: projItem.total
@@ -108,7 +115,7 @@
         });
     });
 
-    const series = [
+    const series = $derived([
         {
             key: 'org_total',
             ...chartConfig.org_total
@@ -143,7 +150,7 @@
                 }
             }
         }
-    ];
+    ]);
 </script>
 
 <div class="space-y-6">
@@ -214,6 +221,12 @@
     {/if}
 </div>
 
+{#if projectQuery.data && organizationQuery.data}
+    {#key projectQuery.data.id}
+        <ProjectIngestLimitCard project={projectQuery.data} {organizationLimit} />
+    {/key}
+{/if}
+
 {#if changePlanDialogOpen && organizationQuery.data}
     <ChangePlanDialog organization={organizationQuery.data} onclose={() => (changePlanDialogOpen = false)} />
 {/if}
diff --git a/src/Exceptionless.Web/Mapping/OrganizationMapper.cs b/src/Exceptionless.Web/Mapping/OrganizationMapper.cs
index 69b0e27556..4b4fa164e0 100644
--- a/src/Exceptionless.Web/Mapping/OrganizationMapper.cs
+++ b/src/Exceptionless.Web/Mapping/OrganizationMapper.cs
@@ -20,6 +20,7 @@ public OrganizationMapper(TimeProvider timeProvider)
     }
 
     public partial Organization MapToOrganization(NewOrganization source);
+    public partial Organization MapToOrganization(UpdateOrganization source);
 
     [MapperIgnoreTarget(nameof(ViewOrganization.IsOverMonthlyLimit))]
     [MapperIgnoreTarget(nameof(ViewOrganization.IsOverRequestLimit))]
diff --git a/src/Exceptionless.Web/Mapping/ProjectMapper.cs b/src/Exceptionless.Web/Mapping/ProjectMapper.cs
index 6d69ef583d..faabf4891d 100644
--- a/src/Exceptionless.Web/Mapping/ProjectMapper.cs
+++ b/src/Exceptionless.Web/Mapping/ProjectMapper.cs
@@ -18,6 +18,9 @@ public partial class ProjectMapper
     [MapperIgnoreTarget(nameof(ViewProject.OrganizationName))]
     [MapperIgnoreTarget(nameof(ViewProject.StackCount))]
     [MapperIgnoreTarget(nameof(ViewProject.EventCount))]
+    [MapperIgnoreTarget(nameof(ViewProject.EffectiveIngestLimit))]
+    [MapperIgnoreTarget(nameof(ViewProject.IsSmartThrottled))]
+    [MapperIgnoreTarget(nameof(ViewProject.SmartThrottleSampleRate))]
     private partial ViewProject MapToViewProjectCore(Project source);
 
     public ViewProject MapToViewProject(Project source)
diff --git a/src/Exceptionless.Web/Models/Organization/UpdateOrganization.cs b/src/Exceptionless.Web/Models/Organization/UpdateOrganization.cs
new file mode 100644
index 0000000000..dd1946a773
--- /dev/null
+++ b/src/Exceptionless.Web/Models/Organization/UpdateOrganization.cs
@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+using Exceptionless.Core.Models;
+
+namespace Exceptionless.Web.Models;
+
+public record UpdateOrganization
+{
+    [Required]
+    public string Name { get; set; } = null!;
+
+    public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
+}
diff --git a/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs b/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs
index 5c46965b96..0ae3121853 100644
--- a/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs
+++ b/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs
@@ -48,6 +48,7 @@ public record ViewOrganization : IIdentity, IData, IHaveDates
     public bool IsThrottled { get; set; }
     public bool IsOverMonthlyLimit { get; set; }
     public bool IsOverRequestLimit { get; set; }
+    public OrganizationBudgetAlertSettings? BudgetAlertSettings { get; set; }
 }
 
 public static class ViewOrganizationExtensions
diff --git a/src/Exceptionless.Web/Models/Project/UpdateProject.cs b/src/Exceptionless.Web/Models/Project/UpdateProject.cs
index fe76403b6e..73096d0b2b 100644
--- a/src/Exceptionless.Web/Models/Project/UpdateProject.cs
+++ b/src/Exceptionless.Web/Models/Project/UpdateProject.cs
@@ -1,8 +1,11 @@
-namespace Exceptionless.Web.Models;
+using Exceptionless.Core.Models;
+
+namespace Exceptionless.Web.Models;
 
 public record UpdateProject
 {
     public string Name { get; set; } = null!;
     public bool DeleteBotDataEnabled { get; set; }
+    public ProjectIngestLimit? IngestLimit { get; set; }
     public List<string>? PromotedTabs { get; set; }
 }
diff --git a/src/Exceptionless.Web/Models/Project/ViewProject.cs b/src/Exceptionless.Web/Models/Project/ViewProject.cs
index 52f5576e9a..26e1204abd 100644
--- a/src/Exceptionless.Web/Models/Project/ViewProject.cs
+++ b/src/Exceptionless.Web/Models/Project/ViewProject.cs
@@ -23,6 +23,10 @@ public class ViewProject : IIdentity, IData, IHaveCreatedDate
     public long EventCount { get; set; }
     public bool HasPremiumFeatures { get; set; }
     public bool HasSlackIntegration { get; set; }
+    public ProjectIngestLimit? IngestLimit { get; set; }
+    public int? EffectiveIngestLimit { get; set; }
+    public bool IsSmartThrottled { get; set; }
+    public double? SmartThrottleSampleRate { get; set; }
     public ICollection<UsageHourInfo> UsageHours { get; set; } = new SortedSet<UsageHourInfo>(Comparer<UsageHourInfo>.Create((a, b) => a.Date.CompareTo(b.Date)));
     public ICollection<UsageInfo> Usage { get; set; } = new SortedSet<UsageInfo>(Comparer<UsageInfo>.Create((a, b) => a.Date.CompareTo(b.Date)));
 }
diff --git a/src/Exceptionless.Web/Utility/OpenApi/DeltaSchemaTransformer.cs b/src/Exceptionless.Web/Utility/OpenApi/DeltaSchemaTransformer.cs
index 3e37b98026..641d55d5ce 100644
--- a/src/Exceptionless.Web/Utility/OpenApi/DeltaSchemaTransformer.cs
+++ b/src/Exceptionless.Web/Utility/OpenApi/DeltaSchemaTransformer.cs
@@ -44,12 +44,30 @@ public async Task TransformAsync(OpenApiSchema schema, OpenApiSchemaTransformerC
             .Where(p => p.CanRead && p.CanWrite))
         {
             bool isNullable = IsPropertyNullable(property);
-            var propertySchema = CreateSchemaForType(property.PropertyType, isNullable);
-            await PopulateNestedSchemaAsync(propertySchema, property.PropertyType, context, cancellationToken);
+            var generatedSchema = await context.GetOrCreateSchemaAsync(property.PropertyType, cancellationToken: cancellationToken);
+            DataAnnotationHelper.ApplyToSchema(generatedSchema, property);
+            ApplyArrayAnnotations(generatedSchema, property);
+            await PopulateNestedSchemaAsync(generatedSchema, property.PropertyType, context, cancellationToken);
 
-            // Apply data annotations from the inner type's property
-            DataAnnotationHelper.ApplyToSchema(propertySchema, property);
-            ApplyArrayAnnotations(propertySchema, property);
+            OpenApiSchema propertySchema;
+
+            if (isNullable && RequiresNullableWrapper(property.PropertyType))
+            {
+                propertySchema = new OpenApiSchema
+                {
+                    OneOf =
+                    [
+                        new OpenApiSchema { Type = JsonSchemaType.Null },
+                        generatedSchema
+                    ]
+                };
+            }
+            else
+            {
+                propertySchema = generatedSchema;
+                if (isNullable)
+                    propertySchema.Type = propertySchema.Type.GetValueOrDefault() | JsonSchemaType.Null;
+            }
 
             string propertyName = property.Name.ToLowerUnderscoredWords();
             schema.Properties[propertyName] = propertySchema;
@@ -57,7 +75,6 @@ public async Task TransformAsync(OpenApiSchema schema, OpenApiSchemaTransformerC
 
         // Ensure no required array - all properties are optional for PATCH
         schema.Required = null;
-
     }
 
     private static async Task PopulateNestedSchemaAsync(
@@ -99,6 +116,28 @@ private static bool IsComplexType(Type type)
             && !type.IsEnum;
     }
 
+    private static bool TryGetEnumerableElementType(Type type, out Type elementType)
+    {
+        if (type.IsArray)
+        {
+            elementType = type.GetElementType() ?? typeof(object);
+            return true;
+        }
+
+        if (type == typeof(string) || !typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
+        {
+            elementType = typeof(object);
+            return false;
+        }
+
+        var enumerableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>)
+            ? type
+            : type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>));
+
+        elementType = enumerableType?.GetGenericArguments()[0] ?? typeof(object);
+        return true;
+    }
+
     private static bool IsDeltaType(Type type)
     {
         return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Delta<>);
@@ -123,76 +162,16 @@ private static bool IsPropertyNullable(PropertyInfo property)
         }
     }
 
-    private static OpenApiSchema CreateSchemaForType(Type type, bool isNullable)
+    private static bool RequiresNullableWrapper(Type type)
     {
-        var schema = new OpenApiSchema();
-        JsonSchemaType schemaType = default;
-
-        // Handle nullable value types (int?, DateTime?, etc.)
-        var underlyingType = Nullable.GetUnderlyingType(type);
-        if (underlyingType is not null)
-        {
-            type = underlyingType;
-            isNullable = true;
-        }
-
-        // Add null type if nullable
-        if (isNullable)
-        {
-            schemaType |= JsonSchemaType.Null;
-        }
-
-        if (type == typeof(string))
-        {
-            schemaType |= JsonSchemaType.String;
-        }
-        else if (type == typeof(bool))
-        {
-            schemaType |= JsonSchemaType.Boolean;
-        }
-        else if (type == typeof(int) || type == typeof(long) || type == typeof(short) || type == typeof(byte))
-        {
-            schemaType |= JsonSchemaType.Integer;
-        }
-        else if (type == typeof(double) || type == typeof(float) || type == typeof(decimal))
-        {
-            schemaType |= JsonSchemaType.Number;
-        }
-        else if (type == typeof(DateTime) || type == typeof(DateTimeOffset))
-        {
-            schemaType |= JsonSchemaType.String;
-            schema.Format = "date-time";
-        }
-        else if (type == typeof(Guid))
-        {
-            schemaType |= JsonSchemaType.String;
-            schema.Format = "uuid";
-        }
-        else if (type.IsEnum)
-        {
-            schemaType |= JsonSchemaType.String;
-        }
-        else if (type.IsGenericType && type.GetInterfaces().Concat([type]).Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDictionary<,>)))
-        {
-            schemaType |= JsonSchemaType.Object;
-            var valueType = type.GetGenericArguments().ElementAtOrDefault(1);
-            if (valueType is not null)
-            {
-                schema.AdditionalProperties = CreateSchemaForType(valueType, false);
-            }
-        }
-        else if (TryGetEnumerableElementType(type, out var elementType))
-        {
-            schemaType |= JsonSchemaType.Array;
-            schema.Items = CreateSchemaForType(elementType, false);
-        }
-        else
-        {
-            schemaType = JsonSchemaType.Object;
-        }
+        type = Nullable.GetUnderlyingType(type) ?? type;
+        return type != typeof(string) && !type.IsValueType && !IsDictionaryType(type);
+    }
 
-        schema.Type = schemaType;
-        return schema;
+    private static bool IsDictionaryType(Type type)
+    {
+        return type.IsGenericType
+            && type.GetInterfaces().Concat([type]).Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDictionary<,>));
     }
 
     private static void ApplyArrayAnnotations(OpenApiSchema schema, PropertyInfo property)
@@ -208,26 +187,4 @@ private static void ApplyArrayAnnotations(OpenApiSchema schema, PropertyInfo pro
             schema.MaxItems = maxLength.Length;
         }
     }
-
-    private static bool TryGetEnumerableElementType(Type type, out Type elementType)
-    {
-        if (type.IsArray)
-        {
-            elementType = type.GetElementType() ?? typeof(object);
-            return true;
-        }
-
-        if (type == typeof(string) || !typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
-        {
-            elementType = typeof(object);
-            return false;
-        }
-
-        var enumerableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>)
-            ? type
-            : type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>));
-
-        elementType = enumerableType?.GetGenericArguments()[0] ?? typeof(object);
-        return true;
-    }
 }
diff --git a/tests/Exceptionless.Tests/Api/Data/openapi.json b/tests/Exceptionless.Tests/Api/Data/openapi.json
index 88be9cf072..474b5f89f5 100644
--- a/tests/Exceptionless.Tests/Api/Data/openapi.json
+++ b/tests/Exceptionless.Tests/Api/Data/openapi.json
@@ -6498,12 +6498,12 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             },
             "application/*\u002Bjson": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             }
           },
@@ -6574,12 +6574,12 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             },
             "application/*\u002Bjson": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             }
           },
@@ -12512,6 +12512,16 @@
           "delete_bot_data_enabled": {
             "type": "boolean"
           },
+          "ingest_limit": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProjectIngestLimit"
+              }
+            ]
+          },
           "promoted_tabs": {
             "type": [
               "null",
@@ -13190,6 +13200,27 @@
           }
         }
       },
+      "OrganizationBudgetAlertSettings": {
+        "required": [
+          "enabled",
+          "thresholds"
+        ],
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean"
+          },
+          "thresholds": {
+            "uniqueItems": true,
+            "type": "array",
+            "items": {
+              "type": "integer",
+              "format": "int32"
+            },
+            "description": "Percentage thresholds of the organization\u0027s effective monthly event allowance.\nExample: [50, 80, 90]."
+          }
+        }
+      },
       "PersistentEvent": {
         "required": [
           "organization_id",
@@ -13448,6 +13479,42 @@
           }
         }
       },
+      "ProjectIngestLimit": {
+        "required": [
+          "type"
+        ],
+        "type": "object",
+        "properties": {
+          "type": {
+            "$ref": "#/components/schemas/ProjectIngestLimitType"
+          },
+          "fixed_limit": {
+            "type": [
+              "null",
+              "integer"
+            ],
+            "format": "int32"
+          },
+          "percent_of_organization_limit": {
+            "type": [
+              "null",
+              "number"
+            ],
+            "format": "double"
+          }
+        }
+      },
+      "ProjectIngestLimitType": {
+        "enum": [
+          0,
+          1
+        ],
+        "type": "integer",
+        "x-enumNames": [
+          "Fixed",
+          "PercentOfOrganizationLimit"
+        ]
+      },
       "RecordProductTourResult": {
         "required": [
           "recorded_utc"
@@ -13893,6 +13960,25 @@
           }
         }
       },
+      "UpdateOrganization": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "budget_alert_settings": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/OrganizationBudgetAlertSettings"
+              }
+            ]
+          }
+        },
+        "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
+      },
       "UpdateProject": {
         "type": "object",
         "properties": {
@@ -13902,14 +13988,28 @@
           "delete_bot_data_enabled": {
             "type": "boolean"
           },
+          "ingest_limit": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProjectIngestLimit"
+              }
+            ]
+          },
           "promoted_tabs": {
-            "type": [
-              "null",
-              "array"
-            ],
-            "items": {
-              "type": "string"
-            }
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            ]
           }
         },
         "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
@@ -14730,6 +14830,16 @@
           },
           "is_over_request_limit": {
             "type": "boolean"
+          },
+          "budget_alert_settings": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/OrganizationBudgetAlertSettings"
+              }
+            ]
           }
         }
       },
@@ -14746,6 +14856,7 @@
           "event_count",
           "has_premium_features",
           "has_slack_integration",
+          "is_smart_throttled",
           "usage_hours",
           "usage"
         ],
@@ -14809,6 +14920,33 @@
           "has_slack_integration": {
             "type": "boolean"
           },
+          "ingest_limit": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProjectIngestLimit"
+              }
+            ]
+          },
+          "effective_ingest_limit": {
+            "type": [
+              "null",
+              "integer"
+            ],
+            "format": "int32"
+          },
+          "is_smart_throttled": {
+            "type": "boolean"
+          },
+          "smart_throttle_sample_rate": {
+            "type": [
+              "null",
+              "number"
+            ],
+            "format": "double"
+          },
           "usage_hours": {
             "type": "array",
             "items": {
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/ContactEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/ContactEndpointTests.cs
index 21989facec..5c4cc4f62f 100644
--- a/tests/Exceptionless.Tests/Api/Endpoints/ContactEndpointTests.cs
+++ b/tests/Exceptionless.Tests/Api/Endpoints/ContactEndpointTests.cs
@@ -181,6 +181,16 @@ public Task SendOrganizationNoticeAsync(User user, Organization organization, bo
             return Task.CompletedTask;
         }
 
+        public Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit)
+        {
+            return Task.CompletedTask;
+        }
+
         public Task SendOrganizationPaymentFailedAsync(User owner, Organization organization)
         {
             return Task.CompletedTask;
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/OrganizationEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/OrganizationEndpointTests.cs
index dbd4f791cb..55a51128d8 100644
--- a/tests/Exceptionless.Tests/Api/Endpoints/OrganizationEndpointTests.cs
+++ b/tests/Exceptionless.Tests/Api/Endpoints/OrganizationEndpointTests.cs
@@ -2,6 +2,7 @@
 using Exceptionless.Core;
 using Exceptionless.Core.Billing;
 using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Messaging.Models;
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Models.Billing;
 using Exceptionless.Core.Repositories;
@@ -13,6 +14,8 @@
 using Exceptionless.Web.Utility;
 using Foundatio.Repositories;
 using Foundatio.Repositories.Utility;
+using Foundatio.AsyncEx;
+using Foundatio.Messaging;
 using Microsoft.Extensions.DependencyInjection;
 using Stripe;
 using Xunit;
@@ -2782,6 +2785,115 @@ public async Task PatchAsync_EmptyJsonBody_ReturnsOriginalOrganizationUnchanged(
         Assert.Equal(originalOrganization.UpdatedUtc, updated.UpdatedUtc);
     }
 
+    [Fact]
+    public async Task PatchAsync_SameNameWithBudgetAlertSettings_DoesNotRejectAsDuplicate()
+    {
+        // Regression: If PATCH sends the org's current name alongside budget_alert_settings,
+        // IsOrganizationNameAvailableInternalAsync previously found the org itself and returned
+        // false ("already exists"), rejecting an idempotent name update.
+        var originalOrg = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(originalOrg);
+        originalOrg.MaxEventsPerMonth = 1000;
+        await _organizationRepository.SaveAsync(originalOrg, o => o.ImmediateConsistency().Cache());
+
+        var updated = await SendRequestAsAsync<ViewOrganization>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", SampleDataService.TEST_ORG_ID)
+            .Content(new { name = originalOrg.Name, budget_alert_settings = new { enabled = true, thresholds = new[] { 75 } } })
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.Equal(originalOrg.Name, updated.Name);
+        Assert.NotNull(updated.BudgetAlertSettings);
+        Assert.True(updated.BudgetAlertSettings.Enabled);
+    }
+
+    [Fact]
+    public async Task PatchAsync_BudgetAlertSettingsNull_ClearsSettings()
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = [50] };
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        var updated = await SendRequestAsAsync<ViewOrganization>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", organization.Id)
+            .Content("""{"budget_alert_settings":null}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.Null(updated.BudgetAlertSettings);
+    }
+
+    [Theory]
+    [InlineData("{\"budget_alert_settings\":{\"enabled\":false,\"thresholds\":[100]}}")]
+    [InlineData("{\"budget_alert_settings\":{\"enabled\":true,\"thresholds\":[]}}")]
+    public async Task PatchAsync_InvalidBudgetAlertSettings_ReturnsValidationError(string content)
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = 1000;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        await SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", SampleDataService.TEST_ORG_ID)
+            .Content(content, "application/json")
+            .StatusCodeShouldBeUnprocessableEntity()
+        );
+    }
+
+    [Fact]
+    public Task PatchAsync_NullBudgetAlertThresholds_ReturnsBadRequest()
+    {
+        return SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", SampleDataService.TEST_ORG_ID)
+            .Content("""{"budget_alert_settings":{"enabled":true,"thresholds":null}}""", "application/json")
+            .StatusCodeShouldBeBadRequest()
+        );
+    }
+
+    [Fact]
+    public async Task PatchAsync_EnablingAlertAboveCurrentUsage_PublishesOnceImmediately()
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = 1000;
+        organization.BudgetAlertSettings = null;
+        organization.GetCurrentUsage(TimeProvider).Total = 600;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        var messageBus = GetService<IMessageBus>();
+        var countdown = new AsyncCountdownEvent(1);
+        OrganizationBudgetAlert? alert = null;
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(message =>
+        {
+            alert = message;
+            countdown.Signal();
+        }, TestCancellationToken);
+
+        await SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", organization.Id)
+            .Content("""{"budget_alert_settings":{"enabled":true,"thresholds":[50]}}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+        await countdown.WaitAsync(TimeSpan.FromSeconds(5));
+
+        Assert.NotNull(alert);
+        Assert.Equal(50, alert.Threshold);
+        Assert.Equal(600, alert.CurrentEventCount);
+    }
+
     private static MultipartFormDataContent CreateProfileImageContent()
     {
         byte[] bytes = new byte[256 * 1024];
diff --git a/tests/Exceptionless.Tests/Api/Endpoints/ProjectEndpointTests.cs b/tests/Exceptionless.Tests/Api/Endpoints/ProjectEndpointTests.cs
index 23f5b402f8..287c03b2e0 100644
--- a/tests/Exceptionless.Tests/Api/Endpoints/ProjectEndpointTests.cs
+++ b/tests/Exceptionless.Tests/Api/Endpoints/ProjectEndpointTests.cs
@@ -1757,4 +1757,147 @@ public async Task CanGetProjectListStats()
         Assert.Equal(newStacks.Count, project.StackCount);
         Assert.Equal(newEvents.Count, project.EventCount);
     }
+
+    [Fact]
+    public async Task PatchAsync_WithFixedIngestLimit_SavesCorrectly()
+    {
+        var updated = await SendRequestAsAsync<ViewProject>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":{"type":0,"fixed_limit":500}}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.NotNull(updated.IngestLimit);
+        Assert.Equal(ProjectIngestLimitType.Fixed, updated.IngestLimit.Type);
+        Assert.Equal(500, updated.IngestLimit.FixedLimit);
+
+        var project = await _projectRepository.GetByIdAsync(SampleDataService.TEST_PROJECT_ID);
+        Assert.NotNull(project);
+        Assert.NotNull(project.IngestLimit);
+        Assert.Equal(ProjectIngestLimitType.Fixed, project.IngestLimit.Type);
+        Assert.Equal(500, project.IngestLimit.FixedLimit);
+    }
+
+    [Fact]
+    public async Task PatchAsync_WithPercentageIngestLimit_SavesCorrectly()
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = 1000;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        var updated = await SendRequestAsAsync<ViewProject>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":{"type":1,"percent_of_organization_limit":75.0}}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.NotNull(updated.IngestLimit);
+        Assert.Equal(ProjectIngestLimitType.PercentOfOrganizationLimit, updated.IngestLimit.Type);
+        Assert.Equal(75.0m, updated.IngestLimit.PercentOfOrganizationLimit);
+
+        var project = await _projectRepository.GetByIdAsync(SampleDataService.TEST_PROJECT_ID);
+        Assert.NotNull(project);
+        Assert.NotNull(project.IngestLimit);
+        Assert.Equal(75.0m, project.IngestLimit.PercentOfOrganizationLimit);
+    }
+
+    [Fact]
+    public async Task PatchAsync_RemoveIngestLimit_SavesNull()
+    {
+        var project = await _projectRepository.GetByIdAsync(SampleDataService.TEST_PROJECT_ID);
+        Assert.NotNull(project);
+        project.IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 100 };
+        await _projectRepository.SaveAsync(project, o => o.ImmediateConsistency().Cache());
+
+        var updated = await SendRequestAsAsync<ViewProject>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":null}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.Null(updated.IngestLimit);
+
+        var saved = await _projectRepository.GetByIdAsync(SampleDataService.TEST_PROJECT_ID);
+        Assert.NotNull(saved);
+        Assert.Null(saved.IngestLimit);
+    }
+
+    [Fact]
+    public async Task PatchAsync_OnlyIngestLimit_NoNameValidationError()
+    {
+        var original = await _projectRepository.GetByIdAsync(SampleDataService.TEST_PROJECT_ID);
+        Assert.NotNull(original);
+
+        var updated = await SendRequestAsAsync<ViewProject>(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":{"type":0,"fixed_limit":200}}""", "application/json")
+            .StatusCodeShouldBeOk()
+        );
+
+        Assert.NotNull(updated);
+        Assert.Equal(original.Name, updated.Name);
+        Assert.NotNull(updated.IngestLimit);
+        Assert.Equal(200, updated.IngestLimit.FixedLimit);
+    }
+
+    [Theory]
+    [InlineData("{\"ingest_limit\":{\"type\":0,\"fixed_limit\":0}}")]
+    [InlineData("{\"ingest_limit\":{\"type\":1,\"percent_of_organization_limit\":0}}")]
+    [InlineData("{\"ingest_limit\":{\"type\":1,\"percent_of_organization_limit\":100.1}}")]
+    public async Task PatchAsync_InvalidIngestLimit_ReturnsValidationError(string content)
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = 1000;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        await SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content(content, "application/json")
+            .StatusCodeShouldBeUnprocessableEntity()
+        );
+    }
+
+    [Fact]
+    public Task PatchAsync_FractionalFixedIngestLimit_ReturnsBadRequest()
+    {
+        return SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":{"type":0,"fixed_limit":1.5}}""", "application/json")
+            .StatusCodeShouldBeBadRequest()
+        );
+    }
+
+    [Fact]
+    public async Task PatchAsync_PercentageIngestLimitForUnlimitedOrganization_ReturnsValidationError()
+    {
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = -1;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        await SendRequestAsync(r => r
+            .Patch()
+            .AsTestOrganizationUser()
+            .AppendPaths("projects", SampleDataService.TEST_PROJECT_ID)
+            .Content("""{"ingest_limit":{"type":1,"percent_of_organization_limit":50}}""", "application/json")
+            .StatusCodeShouldBeBadRequest()
+        );
+    }
 }
diff --git a/tests/Exceptionless.Tests/Api/Handlers/ContactHandlerTests.cs b/tests/Exceptionless.Tests/Api/Handlers/ContactHandlerTests.cs
index 0b15a79b36..163049facc 100644
--- a/tests/Exceptionless.Tests/Api/Handlers/ContactHandlerTests.cs
+++ b/tests/Exceptionless.Tests/Api/Handlers/ContactHandlerTests.cs
@@ -117,6 +117,16 @@ public Task SendOrganizationNoticeAsync(User user, Organization organization, bo
             return Task.CompletedTask;
         }
 
+        public Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit)
+        {
+            return Task.CompletedTask;
+        }
+
         public Task SendOrganizationPaymentFailedAsync(User owner, Organization organization)
         {
             return Task.CompletedTask;
diff --git a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
index 06dd4f3b17..f12670d8fd 100644
--- a/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
+++ b/tests/Exceptionless.Tests/Api/OpenApiSnapshotTests.cs
@@ -184,8 +184,8 @@ public async Task GetOpenApiJson_MigratedContracts_PreserveControllerMetadata()
         AssertArrayResponseSchema(paths, "/api/v2/projects/{projectId}/webhooks", "WebHook");
 
         AssertRequiredJsonRequestBody(paths, "/api/v1/error/{id}", "patch", "UpdateEvent");
-        AssertRequiredJsonRequestBody(paths, "/api/v2/organizations/{id}", "patch", "NewOrganization");
-        AssertRequiredJsonRequestBody(paths, "/api/v2/organizations/{id}", "put", "NewOrganization");
+        AssertRequiredJsonRequestBody(paths, "/api/v2/organizations/{id}", "patch", "UpdateOrganization");
+        AssertRequiredJsonRequestBody(paths, "/api/v2/organizations/{id}", "put", "UpdateOrganization");
         AssertRequiredJsonRequestBody(paths, "/api/v2/projects/{id}", "patch", "UpdateProject");
         AssertRequiredJsonRequestBody(paths, "/api/v2/projects/{id}", "put", "UpdateProject");
         AssertRequiredJsonRequestBody(paths, "/api/v2/tokens/{id}", "patch", "UpdateToken");
@@ -296,6 +296,16 @@ public async Task GetOpenApiJson_MigratedContracts_PreserveControllerMetadata()
         }
     }
 
+    [Fact]
+    public async Task GetOpenApiJson_DeltaNullableComplexProperties_PreserveSchemasAndAnnotations()
+    {
+        using var document = await GetOpenApiDocumentAsync();
+        var schemas = document.RootElement.GetProperty("components").GetProperty("schemas");
+
+        AssertNullableReference(schemas, "UpdateOrganization", "budget_alert_settings", "OrganizationBudgetAlertSettings");
+        AssertNullableReference(schemas, "UpdateProject", "ingest_limit", "ProjectIngestLimit");
+    }
+
     private async Task<JsonDocument> GetOpenApiDocumentAsync()
     {
         string json = await GetOpenApiJsonAsync();
@@ -419,4 +429,20 @@ private static void AssertRequiredJsonRequestBody(JsonElement paths, string path
         foreach (var mediaType in content.EnumerateObject())
             Assert.Equal($"#/components/schemas/{expectedSchema}", mediaType.Value.GetProperty("schema").GetProperty("$ref").GetString());
     }
+
+    private static void AssertNullableReference(JsonElement schemas, string schemaName, string propertyName, string referenceName)
+    {
+        Assert.True(schemas.TryGetProperty(referenceName, out _), $"Expected referenced schema '{referenceName}'.");
+
+        var propertySchema = schemas
+            .GetProperty(schemaName)
+            .GetProperty("properties")
+            .GetProperty(propertyName);
+        var alternatives = propertySchema.GetProperty("oneOf").EnumerateArray().ToArray();
+
+        Assert.Contains(alternatives, alternative => alternative.TryGetProperty("type", out var type) && type.GetString() == "null");
+        Assert.Contains(alternatives, alternative =>
+            alternative.TryGetProperty("$ref", out var reference) &&
+            reference.GetString() == $"#/components/schemas/{referenceName}");
+    }
 }
diff --git a/tests/Exceptionless.Tests/AppWebHostFactory.cs b/tests/Exceptionless.Tests/AppWebHostFactory.cs
index 87edc24c4f..eb7564c86a 100644
--- a/tests/Exceptionless.Tests/AppWebHostFactory.cs
+++ b/tests/Exceptionless.Tests/AppWebHostFactory.cs
@@ -41,6 +41,13 @@ public AppWebHostFactory()
     public int InstanceId { get; }
     public bool IndexesHaveBeenConfigured { get; set; }
 
+    public static async Task<string> GetConnectionStringAsync(string resourceName)
+    {
+        var app = await s_sharedAppHost.Value;
+        return await app.GetConnectionStringAsync(resourceName)
+            ?? throw new InvalidOperationException($"Unable to resolve the '{resourceName}' connection string.");
+    }
+
     public async ValueTask InitializeAsync()
     {
         _ = await s_sharedAppHost.Value;
diff --git a/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs b/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
index 9bbddb2f9e..f59605f9ea 100644
--- a/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
+++ b/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
@@ -316,4 +316,73 @@ private PersistentEvent GenerateEvent(DateTimeOffset? occurrenceDate = null, str
         occurrenceDate ??= DateTimeOffset.Now;
         return _eventData.GenerateEvent(projectId: TestConstants.ProjectId, organizationId: TestConstants.OrganizationId, generateTags: false, generateData: false, occurrenceDate: occurrenceDate, userIdentity: userIdentity, type: type, source: source, sessionId: sessionId);
     }
+
+    [Fact]
+    public async Task CanRunJob_WhenProjectOverLimit_BlocksEvents()
+    {
+        var project = await _projectRepository.GetByIdAsync(TestConstants.ProjectId);
+        Assert.NotNull(project);
+        project.IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 1 };
+        project.GetCurrentUsage(TimeProvider).Total = 1;
+        await _projectRepository.SaveAsync(project, o => o.ImmediateConsistency().Cache());
+
+        Assert.NotNull(await EnqueueEventPostAsync(GenerateEvent()));
+        Assert.Equal(1, (await _eventQueue.GetQueueStatsAsync()).Enqueued);
+
+        var result = await _job.RunAsync(TestCancellationToken);
+        Assert.True(result.IsSuccess);
+
+        await RefreshDataAsync();
+        Assert.Equal(0, await _eventRepository.CountAsync());
+
+        var usage = await _usageService.GetUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId);
+        Assert.Equal(1, usage.CurrentUsage.Blocked);
+    }
+
+    [Fact]
+    public async Task CanRunJob_WhenSmartThrottleApplied_BlocksEventsOnce()
+    {
+        var organization = await _organizationRepository.GetByIdAsync(TestConstants.OrganizationId);
+        Assert.NotNull(organization);
+        organization.MaxEventsPerMonth = 1_000_000;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        var project = await _projectRepository.GetByIdAsync(TestConstants.ProjectId);
+        Assert.NotNull(project);
+        await _projectRepository.AddAsync(_projectData.GenerateProject(generateId: true, organizationId: organization.Id), o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(_projectData.GenerateProject(generateId: true, organizationId: organization.Id), o => o.ImmediateConsistency().Cache());
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var endOfMonth = new DateTime(utcNow.Year, utcNow.Month, 1, 0, 0, 0, DateTimeKind.Utc).AddMonths(1);
+        double windowsLeft = Math.Max(1, Math.Ceiling((endOfMonth - utcNow).TotalMinutes / 5));
+        int currentWindowSpike = (int)Math.Floor(organization.MaxEventsPerMonth / windowsLeft * 10 * 0.9);
+        await _usageService.IncrementTotalAsync(organization, project.Id, currentWindowSpike);
+
+        var throttleResult = await _usageService.GetSmartThrottleRateAsync(TestConstants.OrganizationId, TestConstants.ProjectId);
+        Assert.True(throttleResult.IsThrottled);
+        Assert.Equal(0.05, throttleResult.SampleRate);
+
+        var events = Enumerable.Range(0, 100).Select(index => GenerateEvent(source: $"source-{index}")).ToList();
+        Assert.NotNull(await EnqueueEventPostAsync(events));
+
+        var result = await _job.RunAsync(TestCancellationToken);
+        Assert.True(result.IsSuccess);
+
+        var usage = await _usageService.GetUsageAsync(TestConstants.OrganizationId, TestConstants.ProjectId);
+        Assert.True(usage.CurrentUsage.Blocked > 0);
+        Assert.Equal(0, usage.CurrentUsage.Discarded);
+
+        await RefreshDataAsync();
+        Assert.InRange(await _eventRepository.CountAsync(), 1, 20);
+    }
+
+    [Fact]
+    public void SmartThrottleSelection_SingleEventPosts_UsesStableFivePercentSample()
+    {
+        var persistentEvent = GenerateEvent();
+
+        int accepted = Enumerable.Range(0, 1_000)
+            .Count(index => EventPostsJob.IsSelectedForSmartThrottle($"post-{index}", persistentEvent, 0));
+
+        Assert.InRange(accepted, 30, 70);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Jobs/EventPostRetryTests.cs b/tests/Exceptionless.Tests/Jobs/EventPostRetryTests.cs
new file mode 100644
index 0000000000..a3b6136813
--- /dev/null
+++ b/tests/Exceptionless.Tests/Jobs/EventPostRetryTests.cs
@@ -0,0 +1,496 @@
+using System.Reflection;
+using System.Text.Json.Nodes;
+using Exceptionless.Core;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Jobs;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Pipeline;
+using Exceptionless.Core.Plugins.EventProcessor;
+using Exceptionless.Core.Queues.Models;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Foundatio.Caching;
+using Foundatio.Queues;
+using Foundatio.Repositories.Models;
+using Foundatio.Resilience;
+using Foundatio.Serializer;
+using Foundatio.Utility;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace Exceptionless.Tests.Jobs;
+
+public sealed class EventPostRetryTests : TestWithServices
+{
+    private const string OrganizationId = "retry-organization";
+    private const string ProjectId = "retry-project";
+
+    private readonly EventPostsJob _job;
+    private readonly EventPostService _eventPostService;
+    private readonly OneTimeFailingEventPipeline _pipeline;
+    private readonly EventRepositoryProxy _eventRepository;
+    private readonly UsageService _usageService;
+    private readonly ITextSerializer _serializer;
+
+    public EventPostRetryTests(ITestOutputHelper output) : base(output)
+    {
+        TimeProvider.SetUtcNow(new DateTimeOffset(2026, 8, 2, 12, 0, 0, TimeSpan.Zero));
+        _job = GetService<EventPostsJob>();
+        _eventPostService = GetService<EventPostService>();
+        _pipeline = GetService<EventPipeline>() as OneTimeFailingEventPipeline
+            ?? throw new InvalidOperationException("The test EventPipeline was not registered.");
+        _eventRepository = (EventRepositoryProxy)(object)GetService<IEventRepository>();
+        _usageService = GetService<UsageService>();
+        _serializer = GetService<ITextSerializer>();
+    }
+
+    [Fact]
+    public async Task SingleEventPipelineFailure_IsRetriedAndCommittedOnce()
+    {
+        var persistentEvent = new PersistentEvent
+        {
+            Type = Event.KnownTypes.Log,
+            Message = "retry me",
+            ReferenceId = "retry-reference",
+            Date = TimeProvider.GetUtcNow()
+        };
+
+        await EnqueueEventPostAsync(persistentEvent);
+
+        var firstResult = await _job.RunAsync(CancellationToken.None);
+        Assert.True(firstResult.IsSuccess);
+        Assert.Equal(1, _pipeline.RunCount);
+        Assert.Empty(_eventRepository.SavedEvents);
+        Assert.Equal(0, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+
+        var retryResult = await _job.RunAsync(CancellationToken.None);
+        Assert.True(retryResult.IsSuccess);
+        Assert.Equal(2, _pipeline.RunCount);
+        Assert.Single(_eventRepository.SavedEvents);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task MixedBatch_CompletionSideEffectFails_PreservesRetriesAndUsage(bool failNotificationRead)
+    {
+        _pipeline.ProcessFirstEvent = true;
+        var cache = (FailOnceCacheProxy)(object)GetService<ICacheClient>();
+        cache.FailDiscardedIncrement = true;
+        cache.FailCompletionNotificationRead = failNotificationRead;
+        await EnqueueEventPostAsync(
+            new PersistentEvent { Type = Event.KnownTypes.Log, ReferenceId = "processed", Date = TimeProvider.GetUtcNow() },
+            new PersistentEvent { Type = Event.KnownTypes.Log, ReferenceId = "retry", Date = TimeProvider.GetUtcNow() });
+
+        var firstResult = await _job.RunAsync(CancellationToken.None);
+        Assert.Equal(!failNotificationRead, firstResult.IsSuccess);
+        Assert.Single(_eventRepository.SavedEvents);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+
+        if (failNotificationRead)
+            Assert.True((await _job.RunAsync(CancellationToken.None)).IsSuccess);
+        Assert.Equal(1, _pipeline.RunCount);
+        Assert.Equal(1, (await GetService<IQueue<EventPost>>().GetQueueStatsAsync()).Queued);
+        Assert.True((await _job.RunAsync(CancellationToken.None)).IsSuccess);
+
+        Assert.Equal(2, _pipeline.RunCount);
+        Assert.Equal(["processed", "retry"], _eventRepository.SavedEvents.Select(ev => ev.ReferenceId));
+        Assert.Equal(2, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Discarded);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId)).CurrentUsage.Discarded);
+    }
+
+    [Fact]
+    public async Task PendingRetries_PartialEnqueueFailure_RedeliversOnlyUnacknowledgedIndexes()
+    {
+        var reservation = await CreateCompletedReservationAsync("partial", [1, 2]);
+        var attempts = new List<int>();
+        Assert.False(await _usageService.RetryPendingEventIngestAsync(reservation, index =>
+        {
+            attempts.Add(index);
+            return Task.FromResult(index == 1);
+        }));
+
+        Assert.True(await _usageService.RetryPendingEventIngestAsync(reservation, index =>
+        {
+            attempts.Add(index);
+            return Task.FromResult(true);
+        }));
+        Assert.True(await _usageService.RetryPendingEventIngestAsync(reservation, _ => throw new InvalidOperationException("Acknowledged retries must not be dispatched.")));
+        Assert.Equal([1, 2, 2], attempts);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+    }
+
+    [Fact]
+    public async Task PendingRetries_ConcurrentDelivery_DispatchesEachIndexOnce()
+    {
+        var reservation = await CreateCompletedReservationAsync("concurrent", [1, 2]);
+        var firstEnqueue = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var releaseEnqueue = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var attempts = new List<int>();
+        var first = _usageService.RetryPendingEventIngestAsync(reservation, async index =>
+        {
+            attempts.Add(index);
+            firstEnqueue.TrySetResult();
+            await releaseEnqueue.Task;
+            return true;
+        });
+        await firstEnqueue.Task;
+        var second = _usageService.RetryPendingEventIngestAsync(reservation, _ => throw new InvalidOperationException("Concurrent delivery must observe acknowledgements."));
+        releaseEnqueue.SetResult();
+
+        Assert.All(await Task.WhenAll(first, second), Assert.True);
+        Assert.Equal([1, 2], attempts);
+    }
+
+    [Fact]
+    public async Task FirstUnlimitedPost_DoesNotReadReservationState()
+    {
+        ((OrganizationRepositoryProxy)(object)GetService<IOrganizationRepository>()).Organization.MaxEventsPerMonth = -1;
+        var cache = (FailOnceCacheProxy)(object)GetService<ICacheClient>();
+        cache.FailReservationLookup = true;
+        await EnqueueEventPostAsync(new PersistentEvent
+        {
+            Type = Event.KnownTypes.Log,
+            ReferenceId = "unlimited",
+            Date = TimeProvider.GetUtcNow()
+        });
+
+        Assert.True((await _job.RunAsync(TestContext.Current.CancellationToken)).IsSuccess);
+        cache.FailReservationLookup = false;
+        Assert.True((await _job.RunAsync(TestContext.Current.CancellationToken)).IsSuccess);
+        Assert.Single(_eventRepository.SavedEvents);
+    }
+
+    [Fact]
+    public async Task CompletedPostRetry_AfterOrganizationBecomesUnlimited_DoesNotReprocessAcceptedEvents()
+    {
+        _pipeline.ProcessFirstEvent = true;
+        ((FailOnceCacheProxy)(object)GetService<ICacheClient>()).FailCompletionNotificationRead = true;
+        await EnqueueEventPostAsync(
+            new PersistentEvent { Type = Event.KnownTypes.Log, ReferenceId = "processed", Date = TimeProvider.GetUtcNow() },
+            new PersistentEvent { Type = Event.KnownTypes.Log, ReferenceId = "retry", Date = TimeProvider.GetUtcNow() });
+
+        Assert.False((await _job.RunAsync(CancellationToken.None)).IsSuccess);
+        Assert.Single(_eventRepository.SavedEvents);
+        ((OrganizationRepositoryProxy)(object)GetService<IOrganizationRepository>()).Organization.MaxEventsPerMonth = -1;
+
+        Assert.True((await _job.RunAsync(CancellationToken.None)).IsSuccess);
+        Assert.Equal(1, _pipeline.RunCount);
+        Assert.Single(_eventRepository.SavedEvents);
+        Assert.True((await _job.RunAsync(CancellationToken.None)).IsSuccess);
+        Assert.Equal(["processed", "retry"], _eventRepository.SavedEvents.Select(ev => ev.ReferenceId));
+        Assert.Equal(2, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ReservedPostRetry_AfterProjectCapCleared_PreservesAcceptedSelection(bool releaseReservation)
+    {
+        var organization = ((OrganizationRepositoryProxy)(object)GetService<IOrganizationRepository>()).Organization;
+        var project = ((ProjectRepositoryProxy)(object)GetService<IProjectRepository>()).Project;
+        organization.MaxEventsPerMonth = -1;
+        project.IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 2 };
+        EventIngestCandidate[] candidates = [new(0, 0), new(1, 1), new(2, 2)];
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "cap-cleared", candidates, TestContext.Current.CancellationToken);
+        if (releaseReservation)
+            await _usageService.ReleaseEventIngestReservationAsync(reservation);
+
+        project.IngestLimit = null;
+        var retry = await _usageService.ReserveEventIngestAsync(organization, project, "cap-cleared", candidates, TestContext.Current.CancellationToken, isRedelivery: true);
+
+        Assert.True(retry.IsTracked);
+        Assert.Equal([0, 1], retry.AcceptedIndexes);
+        await _usageService.CompleteEventIngestReservationAsync(retry, organization, 2);
+        var usage = (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage;
+        Assert.Equal(2, usage.Total);
+        Assert.Equal(1, usage.Blocked);
+    }
+
+    [Fact]
+    public async Task PendingRetries_AcknowledgementFailure_KeepsEventForAtLeastOnceDelivery()
+    {
+        var reservation = await CreateCompletedReservationAsync("acknowledgement", [1]);
+        var cache = (FailOnceCacheProxy)(object)GetService<ICacheClient>();
+        int attempts = 0;
+        await Assert.ThrowsAsync<InvalidOperationException>(() => _usageService.RetryPendingEventIngestAsync(reservation, _ =>
+        {
+            attempts++;
+            cache.FailReservationAcknowledgement = true;
+            return Task.FromResult(true);
+        }));
+
+        Assert.True(await _usageService.RetryPendingEventIngestAsync(reservation, index =>
+        {
+            Assert.Equal(1, index);
+            attempts++;
+            return Task.FromResult(true);
+        }));
+        Assert.Equal(2, attempts);
+        Assert.Equal(1, (await _usageService.GetUsageAsync(OrganizationId, ProjectId)).CurrentUsage.Total);
+    }
+
+    [Fact]
+    public async Task CompletedReservation_LegacyRecordWithoutRetryIndexes_HasNoPendingRetries()
+    {
+        var reservation = await CreateCompletedReservationAsync("legacy", []);
+        var cache = GetService<ICacheClient>();
+        string key = $"usage:ingest-reservation:{{{OrganizationId}}}:legacy";
+        var value = await cache.GetAsync<string>(key);
+        var legacy = JsonNode.Parse(value.Value)!.AsObject();
+        Assert.True(legacy.Remove("RetryIndexes"));
+        await cache.SetAsync(key, legacy.ToJsonString(), TimeSpan.FromDays(35));
+
+        Assert.True(await _usageService.RetryPendingEventIngestAsync(reservation, _ => throw new InvalidOperationException("Legacy completed records have no pending retries.")));
+    }
+
+    [Theory]
+    [InlineData("[1,1]")]
+    [InlineData("[99]")]
+    [InlineData("null")]
+    public async Task PendingRetries_InvalidStoredIndexes_RejectsBeforeDispatch(string indexes)
+    {
+        var reservation = await CreateCompletedReservationAsync("invalid", [1]);
+        var cache = GetService<ICacheClient>();
+        string key = $"usage:ingest-reservation:{{{OrganizationId}}}:invalid";
+        var value = await cache.GetAsync<string>(key);
+        var invalid = JsonNode.Parse(value.Value)!.AsObject();
+        invalid["RetryIndexes"] = JsonNode.Parse(indexes);
+        await cache.SetAsync(key, invalid.ToJsonString(), TimeSpan.FromDays(35));
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.RetryPendingEventIngestAsync(reservation,
+            _ => throw new InvalidOperationException("Invalid retry metadata must not dispatch events.")));
+    }
+
+    private async Task<EventIngestReservation> CreateCompletedReservationAsync(string id, int[] retryIndexes)
+    {
+        var organization = ((OrganizationRepositoryProxy)(object)GetService<IOrganizationRepository>()).Organization;
+        var project = ((ProjectRepositoryProxy)(object)GetService<IProjectRepository>()).Project;
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, id,
+            [new(0, 0), new(1, 1), new(2, 2)]);
+        await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 1, retryIndexes);
+        return reservation;
+    }
+
+    protected override void RegisterServices(IServiceCollection services, AppOptions options)
+    {
+        base.RegisterServices(services, options);
+
+        services.Replace(ServiceDescriptor.Singleton<ICacheClient>(serviceProvider =>
+        {
+            var cache = DispatchProxy.Create<ICacheClient, FailOnceCacheProxy>();
+            ((FailOnceCacheProxy)(object)cache).Inner = new InMemoryCacheClient(new InMemoryCacheClientOptions
+            {
+                CloneValues = true,
+                Serializer = serviceProvider.GetRequiredService<ISerializer>(),
+                TimeProvider = serviceProvider.GetRequiredService<TimeProvider>(),
+                LoggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>()
+            });
+            return cache;
+        }));
+
+        var organization = new Organization
+        {
+            Id = OrganizationId,
+            Name = "Retry Organization",
+            PlanId = "EX_SMALL",
+            MaxEventsPerMonth = 100
+        };
+        var organizationRepository = DispatchProxy.Create<IOrganizationRepository, OrganizationRepositoryProxy>();
+        ((OrganizationRepositoryProxy)(object)organizationRepository).Organization = organization;
+        services.Replace(ServiceDescriptor.Singleton<IOrganizationRepository>(organizationRepository));
+
+        var project = new Project
+        {
+            Id = ProjectId,
+            OrganizationId = OrganizationId,
+            Name = "Retry Project",
+            NextSummaryEndOfDayTicks = DateTime.UtcNow.Ticks
+        };
+        var projectRepository = DispatchProxy.Create<IProjectRepository, ProjectRepositoryProxy>();
+        ((ProjectRepositoryProxy)(object)projectRepository).Project = project;
+        services.Replace(ServiceDescriptor.Singleton<IProjectRepository>(projectRepository));
+
+        var eventRepository = DispatchProxy.Create<IEventRepository, EventRepositoryProxy>();
+        services.Replace(ServiceDescriptor.Singleton<IEventRepository>(eventRepository));
+
+        services.Replace(ServiceDescriptor.Singleton<EventPipeline, OneTimeFailingEventPipeline>());
+        services.AddSingleton<EventPostsJob>();
+        services.Replace(ServiceDescriptor.Singleton<IQueue<EventPost>>(serviceProvider => new InMemoryQueue<EventPost>(new InMemoryQueueOptions<EventPost>
+        {
+            RetryDelay = TimeSpan.Zero,
+            Serializer = serviceProvider.GetRequiredService<ISerializer>(),
+            TimeProvider = serviceProvider.GetRequiredService<TimeProvider>(),
+            ResiliencePolicyProvider = serviceProvider.GetRequiredService<IResiliencePolicyProvider>(),
+            LoggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>()
+        })));
+    }
+
+    private async Task EnqueueEventPostAsync(params PersistentEvent[] events)
+    {
+        var eventPost = new EventPost(false)
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            ApiVersion = 2,
+            CharSet = "utf-8",
+            ContentEncoding = "gzip",
+            MediaType = "application/json",
+            UserAgent = "exceptionless-retry-test"
+        };
+
+        using var stream = new MemoryStream(_serializer.SerializeToBytes(events).Compress());
+        Assert.NotNull(await _eventPostService.EnqueueAsync(eventPost, stream));
+    }
+
+    private sealed class OneTimeFailingEventPipeline : EventPipeline
+    {
+        private readonly IEventRepository _eventRepository;
+        private int _runCount;
+
+        public OneTimeFailingEventPipeline(IServiceProvider serviceProvider, AppOptions options, ILoggerFactory loggerFactory)
+            : base(serviceProvider, options, loggerFactory)
+        {
+            _eventRepository = serviceProvider.GetRequiredService<IEventRepository>();
+        }
+
+        public int RunCount => _runCount;
+        public bool ProcessFirstEvent { get; set; }
+
+        protected override IList<Type> GetActionTypes() => [];
+
+        public override async Task<ICollection<EventContext>> RunAsync(ICollection<EventContext> contexts)
+        {
+            if (Interlocked.Increment(ref _runCount) == 1)
+            {
+                foreach (var context in contexts)
+                {
+                    if (ProcessFirstEvent && context == contexts.First())
+                    {
+                        context.IsProcessed = true;
+                        context.IsDiscarded = true;
+                        await _eventRepository.SaveAsync(context.Event);
+                        continue;
+                    }
+
+                    context.SetError("Simulated transient pipeline failure.", new InvalidOperationException("Simulated transient pipeline failure."));
+                }
+
+                return contexts;
+            }
+
+            foreach (var context in contexts)
+            {
+                context.IsProcessed = true;
+                await _eventRepository.SaveAsync(context.Event);
+            }
+
+            return contexts;
+        }
+    }
+
+    private class FailOnceCacheProxy : DispatchProxy
+    {
+        public ICacheClient Inner { get; set; } = null!;
+        public bool FailDiscardedIncrement { get; set; }
+        public bool FailReservationAcknowledgement { get; set; }
+        public bool FailCompletionNotificationRead { get; set; }
+        public bool FailReservationLookup { get; set; }
+        private bool HasCompletedReservation { get; set; }
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            ArgumentNullException.ThrowIfNull(targetMethod);
+            if (FailReservationLookup && targetMethod.Name == "ExistsAsync" && args?[0] is string lookupKey && lookupKey.Contains("ingest-reservation:", StringComparison.Ordinal))
+                throw new InvalidOperationException("New unlimited posts must not query reservation state.");
+            if (FailCompletionNotificationRead && HasCompletedReservation && targetMethod.Name == "GetAllAsync" && targetMethod.GetGenericArguments().FirstOrDefault() == typeof(int))
+            {
+                FailCompletionNotificationRead = false;
+                throw new InvalidOperationException("Simulated notification usage read failure after reservation completion.");
+            }
+            if (FailReservationAcknowledgement && targetMethod.Name == "SetAllAsync" && args?[0] is IDictionary<string, string> values && values.Keys.Any(key => key.Contains("ingest-reservation:", StringComparison.Ordinal)))
+            {
+                FailReservationAcknowledgement = false;
+                throw new InvalidOperationException("Simulated acknowledgement failure after retry enqueue.");
+            }
+            if (FailDiscardedIncrement && targetMethod.Name == "IncrementAsync" && args?[0] is string key && key.EndsWith(":discarded", StringComparison.Ordinal))
+            {
+                FailDiscardedIncrement = false;
+                throw new InvalidOperationException("Simulated discarded usage write failure after reservation completion.");
+            }
+
+            if (targetMethod.Name == "SetAllAsync" && args?[0] is IDictionary<string, string> updates)
+                HasCompletedReservation |= updates.Any(update => update.Key.Contains("ingest-reservation:", StringComparison.Ordinal) && JsonNode.Parse(update.Value)?["State"]?.GetValue<int>() == 1);
+
+            return targetMethod.Invoke(Inner, args);
+        }
+    }
+
+    private class OrganizationRepositoryProxy : DispatchProxy
+    {
+        public Organization Organization { get; set; } = null!;
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            ArgumentNullException.ThrowIfNull(targetMethod);
+            return targetMethod.Name switch
+            {
+                "GetByIdAsync" => Task.FromResult<Organization?>(Organization.DeepClone()),
+                _ => throw new NotSupportedException(targetMethod.Name)
+            };
+        }
+    }
+
+    private class ProjectRepositoryProxy : DispatchProxy
+    {
+        public Project Project { get; set; } = null!;
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            ArgumentNullException.ThrowIfNull(targetMethod);
+            return targetMethod.Name switch
+            {
+                "GetByIdAsync" => Task.FromResult<Project?>(Project.DeepClone()),
+                "GetCountByOrganizationIdAsync" => Task.FromResult(new CountResult(1)),
+                _ => throw new NotSupportedException(targetMethod.Name)
+            };
+        }
+    }
+
+    private class EventRepositoryProxy : DispatchProxy
+    {
+        private readonly List<PersistentEvent> _savedEvents = [];
+
+        public IReadOnlyList<PersistentEvent> SavedEvents => _savedEvents;
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            ArgumentNullException.ThrowIfNull(targetMethod);
+            if (targetMethod.Name == "SaveAsync" && args is { Length: > 0 })
+            {
+                if (args[0] is PersistentEvent persistentEvent)
+                {
+                    _savedEvents.Add(persistentEvent);
+                    return Task.FromResult(persistentEvent);
+                }
+
+                if (args[0] is IEnumerable<PersistentEvent> events)
+                {
+                    _savedEvents.AddRange(events);
+                    return Task.CompletedTask;
+                }
+
+                throw new NotSupportedException("SaveAsync argument type");
+            }
+
+            if (targetMethod.Name == "CountAsync")
+                return Task.FromResult(new CountResult(_savedEvents.Count));
+
+            throw new NotSupportedException(targetMethod.Name);
+        }
+    }
+}
diff --git a/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationTests.cs b/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationTests.cs
new file mode 100644
index 0000000000..1c7de1bb00
--- /dev/null
+++ b/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationTests.cs
@@ -0,0 +1,278 @@
+using System.Reflection;
+using Exceptionless.Core;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Jobs.WorkItemHandlers;
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.DateTimeExtensions;
+using Exceptionless.Tests.Mail;
+using Foundatio.Jobs;
+using Foundatio.Repositories;
+using Foundatio.Repositories.Models;
+using Foundatio.Repositories.Options;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Xunit;
+
+namespace Exceptionless.Tests.Jobs.WorkItemHandlers;
+
+public sealed class UsageBudgetNotificationTests : TestWithServices
+{
+    private const string OrganizationId = "664ec4c1f12e4f2b7a0d3101";
+    private const string ProjectId = "664ec4c1f12e4f2b7a0d3201";
+    private const string UserId = "664ec4c1f12e4f2b7a0d3301";
+
+    public UsageBudgetNotificationTests(ITestOutputHelper output) : base(output) { }
+
+    private OrganizationRepositoryProxy OrganizationRepository => (OrganizationRepositoryProxy)(object)GetService<IOrganizationRepository>();
+    private ProjectRepositoryProxy ProjectRepository => (ProjectRepositoryProxy)(object)GetService<IProjectRepository>();
+    private UserRepositoryProxy UserRepository => (UserRepositoryProxy)(object)GetService<IUserRepository>();
+    private CountingMailer Mailer => GetService<CountingMailer>();
+    private UsageService UsageService => GetService<UsageService>();
+
+    protected override void RegisterServices(IServiceCollection services, AppOptions options)
+    {
+        base.RegisterServices(services, options);
+
+        var organizationRepository = DispatchProxy.Create<IOrganizationRepository, OrganizationRepositoryProxy>();
+        var projectRepository = DispatchProxy.Create<IProjectRepository, ProjectRepositoryProxy>();
+        var userRepository = DispatchProxy.Create<IUserRepository, UserRepositoryProxy>();
+        services.Replace(ServiceDescriptor.Singleton<IOrganizationRepository>(organizationRepository));
+        services.Replace(ServiceDescriptor.Singleton<IProjectRepository>(projectRepository));
+        services.Replace(ServiceDescriptor.Singleton<IUserRepository>(userRepository));
+
+        services.AddSingleton<CountingMailer>();
+        services.Replace(ServiceDescriptor.Singleton<IMailer>(serviceProvider => serviceProvider.GetRequiredService<CountingMailer>()));
+    }
+
+    [Theory]
+    [InlineData(1_000_000, 1)]
+    [InlineData(100_000_000, 0)]
+    public async Task ProjectHandler_PlanChangedBeforeHandling_UsesLiveThrottleState(int maxEventsPerMonth, int expectedEmailCount)
+    {
+        TimeProvider.SetUtcNow(new DateTimeOffset(2026, 8, 2, 12, 0, 0, TimeSpan.Zero));
+
+        var organization = new Organization
+        {
+            Id = OrganizationId,
+            Name = "Budget Organization",
+            PlanId = "EX_XL",
+            MaxEventsPerMonth = 1_000_000
+        };
+        var project = new Project
+        {
+            Id = ProjectId,
+            OrganizationId = OrganizationId,
+            Name = "Noisy Project"
+        };
+        var user = new User
+        {
+            Id = UserId,
+            FullName = "Budget Owner",
+            EmailAddress = "budget-owner@example.org",
+            IsEmailAddressVerified = true,
+            EmailNotificationsEnabled = true
+        };
+
+        OrganizationRepository.Organization = organization;
+        ProjectRepository.Project = project;
+        ProjectRepository.ProjectCount = 3;
+        UserRepository.Users = new FindResults<User>(
+            [new FindHit<User>(UserId, user, 0, null, null, null)],
+            1,
+            null,
+            null,
+            null);
+
+        int spike = GetCurrentWindowSpike(organization.MaxEventsPerMonth);
+        await UsageService.IncrementTotalAsync(organization, project.Id, spike);
+        var allowance = await UsageService.GetEventIngestAllowanceAsync(organization, project);
+        Assert.True(allowance.SmartThrottle.IsThrottled);
+        Assert.True(await UsageService.IsProjectSmartThrottledAsync(OrganizationId, ProjectId));
+
+        organization.MaxEventsPerMonth = maxEventsPerMonth;
+        Assert.Equal(expectedEmailCount == 1, (await UsageService.GetSmartThrottleRateAsync(OrganizationId, ProjectId)).IsThrottled);
+
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), new ProjectSmartThrottleWorkItem
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            SampleRate = 0.99,
+            CurrentEventCount = 1,
+            EventLimit = 2,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        });
+
+        Assert.Equal(expectedEmailCount, Mailer.ProjectThrottleCalls.Count);
+        if (expectedEmailCount == 1)
+        {
+            var call = Assert.Single(Mailer.ProjectThrottleCalls);
+            Assert.Equal(allowance.SmartThrottle.SampleRate, call.SampleRate);
+            Assert.Equal(allowance.SmartThrottle.CurrentProjectUsage, call.CurrentEventCount);
+            Assert.Equal(allowance.SmartThrottle.FairShareLimit, call.EventLimit);
+        }
+    }
+
+    [Fact]
+    public async Task OrganizationHandler_LaterPageFailureRetry_SendsAllEligibleRecipientsOnce()
+    {
+        var (organization, _, expectedUserIds) = SetUpPagedRecipients();
+        organization.BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = [50] };
+        organization.GetCurrentUsage(TimeProvider).Total = 600_000;
+        var workItem = new OrganizationBudgetAlertWorkItem
+        {
+            OrganizationId = OrganizationId,
+            Threshold = 50,
+            ThresholdEventCount = 1,
+            CurrentEventCount = 1,
+            EventLimit = 1,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        };
+        Mailer.ThrowOnOrganizationBudgetAlertAttempt = 9;
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() => HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), workItem));
+
+        Assert.Equal(expectedUserIds.Take(8), Mailer.OrganizationBudgetAlertCalls.Select(call => call.UserId));
+
+        Mailer.ThrowOnOrganizationBudgetAlertAttempt = null;
+        await HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), workItem);
+        await HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), workItem);
+
+        Assert.Equal(expectedUserIds, Mailer.OrganizationBudgetAlertCalls.Select(call => call.UserId));
+    }
+
+    [Fact]
+    public async Task ProjectHandler_MultiplePagesAndDuplicateDelivery_SendsAllEligibleRecipientsOnce()
+    {
+        var (organization, project, expectedUserIds) = SetUpPagedRecipients();
+        await UsageService.IncrementTotalAsync(organization, project.Id, GetCurrentWindowSpike(organization.MaxEventsPerMonth));
+        Assert.True((await UsageService.GetEventIngestAllowanceAsync(organization, project)).SmartThrottle.IsThrottled);
+        var workItem = new ProjectSmartThrottleWorkItem
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            SampleRate = 0.99,
+            CurrentEventCount = 1,
+            EventLimit = 2,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        };
+
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), workItem);
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), workItem);
+
+        Assert.Equal(expectedUserIds, Mailer.ProjectThrottleCalls.Select(call => call.UserId));
+    }
+
+    private (Organization Organization, Project Project, string[] ExpectedUserIds) SetUpPagedRecipients()
+    {
+        TimeProvider.SetUtcNow(new DateTimeOffset(2026, 8, 2, 12, 0, 0, TimeSpan.Zero));
+        var organization = new Organization
+        {
+            Id = OrganizationId,
+            Name = "Budget Organization",
+            PlanId = "EX_XL",
+            MaxEventsPerMonth = 1_000_000
+        };
+        var project = new Project { Id = ProjectId, OrganizationId = OrganizationId, Name = "Noisy Project" };
+        OrganizationRepository.Organization = organization;
+        ProjectRepository.Project = project;
+        ProjectRepository.ProjectCount = 3;
+
+        var users = Enumerable.Range(0, 13).Select(index => new User
+        {
+            Id = $"664ec4c1f12e4f2b7a0d33{index:D2}",
+            OrganizationIds = new HashSet<string> { OrganizationId },
+            EmailAddress = $"recipient-{index:D2}@example.org",
+            IsEmailAddressVerified = index != 0,
+            EmailNotificationsEnabled = index != 1
+        }).ToArray();
+        UserRepository.PagedUsers = users;
+
+        return (organization, project, users.Skip(2).Select(user => user.Id).ToArray());
+    }
+
+    private int GetCurrentWindowSpike(int maxEventsPerMonth)
+    {
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var endOfMonth = new DateTime(utcNow.Year, utcNow.Month, 1, 0, 0, 0, DateTimeKind.Utc).AddMonths(1);
+        double windowsLeft = Math.Max(1, Math.Ceiling((endOfMonth - utcNow).TotalMinutes / 5));
+        return (int)Math.Floor(maxEventsPerMonth / windowsLeft * 10 * 0.9);
+    }
+
+    private static async Task HandleAsync(WorkItemHandlerBase handler, object workItem)
+    {
+        await using var workItemLock = await handler.GetWorkItemLockAsync(workItem, TestContext.Current.CancellationToken);
+        Assert.NotNull(workItemLock);
+        var context = new WorkItemContext(workItem, "test-job", workItemLock, TestContext.Current.CancellationToken, static (_, _) => Task.CompletedTask);
+        await handler.HandleItemAsync(context);
+    }
+
+    private class OrganizationRepositoryProxy : DispatchProxy
+    {
+        public Organization? Organization { get; set; }
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            if (targetMethod?.Name == "GetByIdAsync")
+                return Task.FromResult(Organization);
+
+            throw new NotSupportedException(targetMethod?.Name);
+        }
+    }
+
+    private class ProjectRepositoryProxy : DispatchProxy
+    {
+        public Project? Project { get; set; }
+        public int ProjectCount { get; set; }
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            return targetMethod?.Name switch
+            {
+                "GetByIdAsync" => Task.FromResult(Project),
+                "GetCountByOrganizationIdAsync" => Task.FromResult(new CountResult(ProjectCount, null, null)),
+                _ => throw new NotSupportedException(targetMethod?.Name)
+            };
+        }
+    }
+
+    private class UserRepositoryProxy : DispatchProxy
+    {
+        public FindResults<User> Users { get; set; } = new();
+        public User[]? PagedUsers { get; set; }
+
+        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+        {
+            if (targetMethod?.Name == "GetByOrganizationIdAsync")
+            {
+                if (PagedUsers is not null)
+                {
+                    string organizationId = (string)args![0]!;
+                    var commandOptions = (args[1] as CommandOptionsDescriptor<User>).Configure();
+                    var users = PagedUsers.Where(user => user.OrganizationIds.Contains(organizationId))
+                        .OrderBy(user => user.EmailAddress, StringComparer.Ordinal).ToArray();
+                    return Task.FromResult(GetPage(users, 1, commandOptions.GetLimit()));
+                }
+
+                return Task.FromResult(Users);
+            }
+
+            throw new NotSupportedException(targetMethod?.Name);
+        }
+
+        private static FindResults<User> GetPage(User[] users, int page, int pageSize)
+        {
+            var hits = users.Skip((page - 1) * pageSize).Take(pageSize)
+                .Select(user => new FindHit<User>(user.Id, user, 0, null, null, null));
+            var results = new FindResults<User>(hits, users.Length,
+                getNextPageFunc: previous => Task.FromResult(GetPage(users, previous.Page + 1, pageSize)));
+            ((IFindResults<User>)results).Page = page;
+            ((IFindResults<User>)results).HasMore = page * pageSize < users.Length;
+
+            return results;
+        }
+    }
+}
diff --git a/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationWorkItemHandlerTests.cs b/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationWorkItemHandlerTests.cs
new file mode 100644
index 0000000000..93b3a89c27
--- /dev/null
+++ b/tests/Exceptionless.Tests/Jobs/WorkItemHandlers/UsageBudgetNotificationWorkItemHandlerTests.cs
@@ -0,0 +1,242 @@
+using Exceptionless.Core.Billing;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Jobs.WorkItemHandlers;
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.DateTimeExtensions;
+using Exceptionless.Tests.Mail;
+using Exceptionless.Tests.Extensions;
+using Exceptionless.Tests.Utility;
+using Foundatio.Jobs;
+using Foundatio.Repositories;
+using Microsoft.Extensions.DependencyInjection;
+using System.Text.Json;
+using Xunit;
+
+namespace Exceptionless.Tests.Jobs.WorkItemHandlers;
+
+public class UsageBudgetNotificationWorkItemHandlerTests : IntegrationTestsBase
+{
+    private const string OrganizationId = "664ec4c1f12e4f2b7a0d3101";
+    private const string ProjectId = "664ec4c1f12e4f2b7a0d3201";
+    private const string UserId = "664ec4c1f12e4f2b7a0d3301";
+
+    public UsageBudgetNotificationWorkItemHandlerTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory) { }
+
+    private CountingMailer Mailer => GetService<CountingMailer>();
+    private IOrganizationRepository OrganizationRepository => GetService<IOrganizationRepository>();
+    private IProjectRepository ProjectRepository => GetService<IProjectRepository>();
+    private IUserRepository UserRepository => GetService<IUserRepository>();
+    private UsageService UsageService => GetService<UsageService>();
+
+    protected override void RegisterServices(IServiceCollection services)
+    {
+        base.RegisterServices(services);
+        services.AddSingleton<CountingMailer>();
+        services.ReplaceSingleton<IMailer>(serviceProvider => serviceProvider.GetRequiredService<CountingMailer>());
+    }
+
+    protected override async Task ResetDataAsync()
+    {
+        await base.ResetDataAsync();
+        Mailer.Reset();
+
+        var billingManager = GetService<BillingManager>();
+        var billingPlans = GetService<BillingPlans>();
+        var organization = GetService<OrganizationData>().GenerateOrganization(billingManager, billingPlans, id: OrganizationId, name: "Budget Organization", plan: billingPlans.ExtraLargePlan);
+        organization.MaxEventsPerMonth = 1_000_000;
+        organization.BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = [50] };
+        await OrganizationRepository.AddAsync(organization, options => options.ImmediateConsistency().Cache());
+
+        var projectData = GetService<ProjectData>();
+        await ProjectRepository.AddAsync([
+            projectData.GenerateProject(id: ProjectId, organizationId: OrganizationId, name: "Noisy Project"),
+            projectData.GenerateProject(generateId: true, organizationId: OrganizationId, name: "Quiet Project"),
+            projectData.GenerateProject(generateId: true, organizationId: OrganizationId, name: "Another Project")
+        ], options => options.ImmediateConsistency().Cache());
+
+        var user = GetService<UserData>().GenerateUser(id: UserId, organizationId: OrganizationId, emailAddress: "budget-owner@example.org");
+        user.IsEmailAddressVerified = true;
+        user.EmailNotificationsEnabled = true;
+        await UserRepository.AddAsync(user, options => options.ImmediateConsistency().Cache());
+    }
+
+    [Fact]
+    public async Task OrganizationHandler_CurrentCrossing_SendsCurrentUsageAndPlan()
+    {
+        var organization = await OrganizationRepository.GetByIdAsync(OrganizationId);
+        Assert.NotNull(organization);
+        organization.GetCurrentUsage(TimeProvider).Total = 600_000;
+        await OrganizationRepository.SaveAsync(organization, options => options.ImmediateConsistency().Cache());
+
+        await HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), new OrganizationBudgetAlertWorkItem
+        {
+            OrganizationId = OrganizationId,
+            Threshold = 50,
+            ThresholdEventCount = 1,
+            CurrentEventCount = 1,
+            EventLimit = 1
+        });
+
+        var call = Assert.Single(Mailer.OrganizationBudgetAlertCalls);
+        Assert.Equal(500_000, call.ThresholdEventCount);
+        Assert.Equal(600_000, call.CurrentEventCount);
+        Assert.Equal(1_000_000, call.EventLimit);
+    }
+
+    [Fact]
+    public void UsageNotificationContracts_LegacyPayloadWithoutPeriod_Deserializes()
+    {
+        const string organizationPayload = """{"OrganizationId":"organization","Threshold":50,"ThresholdEventCount":500,"CurrentEventCount":600,"EventLimit":1000}""";
+        const string projectPayload = """{"OrganizationId":"organization","ProjectId":"project","SampleRate":0.05,"CurrentEventCount":600,"EventLimit":1000}""";
+
+        Assert.Equal(0, JsonSerializer.Deserialize<OrganizationBudgetAlert>(organizationPayload)!.UsagePeriod);
+        Assert.Equal(0, JsonSerializer.Deserialize<OrganizationBudgetAlertWorkItem>(organizationPayload)!.UsagePeriod);
+        Assert.Equal(0, JsonSerializer.Deserialize<ProjectSmartThrottleApplied>(projectPayload)!.UsagePeriod);
+        Assert.Equal(0, JsonSerializer.Deserialize<ProjectSmartThrottleWorkItem>(projectPayload)!.UsagePeriod);
+    }
+
+    [Fact]
+    public async Task OrganizationHandler_DisabledAfterQueue_SuppressesStaleEmail()
+    {
+        var organization = await OrganizationRepository.GetByIdAsync(OrganizationId);
+        Assert.NotNull(organization);
+        organization.BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = false, Thresholds = [50] };
+        await OrganizationRepository.SaveAsync(organization, options => options.ImmediateConsistency().Cache());
+
+        await HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), new OrganizationBudgetAlertWorkItem
+        {
+            OrganizationId = OrganizationId,
+            Threshold = 50,
+            ThresholdEventCount = 500_000,
+            CurrentEventCount = 600_000,
+            EventLimit = 1_000_000,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        });
+
+        Assert.Empty(Mailer.OrganizationBudgetAlertCalls);
+    }
+
+    [Fact]
+    public async Task ProjectHandler_CurrentThrottle_SendsProjectUsageAndFairShare()
+    {
+        var organization = await OrganizationRepository.GetByIdAsync(OrganizationId);
+        var project = await ProjectRepository.GetByIdAsync(ProjectId);
+        Assert.NotNull(organization);
+        Assert.NotNull(project);
+
+        int spike = GetCurrentWindowSpike(organization.MaxEventsPerMonth);
+        await UsageService.IncrementTotalAsync(organization, project.Id, spike);
+        Assert.True((await UsageService.GetEventIngestAllowanceAsync(organization, project)).SmartThrottle.IsThrottled);
+
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), new ProjectSmartThrottleWorkItem
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            SampleRate = 0.05,
+            CurrentEventCount = 1,
+            EventLimit = 1,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        });
+
+        var call = Assert.Single(Mailer.ProjectThrottleCalls);
+        Assert.Equal(spike, call.CurrentEventCount);
+        Assert.Equal(333_333, call.EventLimit);
+        Assert.Equal(0.05, call.SampleRate);
+    }
+
+    [Fact]
+    public async Task ProjectHandler_ThrottleExpiredBeforeHandling_SuppressesStaleEmail()
+    {
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), new ProjectSmartThrottleWorkItem
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            SampleRate = 0.05,
+            CurrentEventCount = 1,
+            EventLimit = 1,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        });
+
+        Assert.Empty(Mailer.ProjectThrottleCalls);
+    }
+
+    [Fact]
+    public async Task OrganizationHandler_PartialFailureRetry_SendsEachRecipientOnce()
+    {
+        var organization = await OrganizationRepository.GetByIdAsync(OrganizationId);
+        Assert.NotNull(organization);
+        organization.GetCurrentUsage(TimeProvider).Total = 600_000;
+        await OrganizationRepository.SaveAsync(organization, options => options.ImmediateConsistency().Cache());
+
+        var secondUser = GetService<UserData>().GenerateUser(generateId: true, organizationId: OrganizationId, emailAddress: "second-owner@example.org");
+        secondUser.IsEmailAddressVerified = true;
+        secondUser.EmailNotificationsEnabled = true;
+        await UserRepository.AddAsync(secondUser, options => options.ImmediateConsistency().Cache());
+
+        var workItem = new OrganizationBudgetAlertWorkItem
+        {
+            OrganizationId = OrganizationId,
+            Threshold = 50,
+            ThresholdEventCount = 500_000,
+            CurrentEventCount = 600_000,
+            EventLimit = 1_000_000,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        };
+        Mailer.ThrowOnOrganizationBudgetAlertAttempt = 2;
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() => HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), workItem));
+        Mailer.ThrowOnOrganizationBudgetAlertAttempt = null;
+        await HandleAsync(GetService<OrganizationBudgetAlertWorkItemHandler>(), workItem);
+
+        Assert.Equal(2, Mailer.OrganizationBudgetAlertCalls.Count);
+        Assert.Equal(2, Mailer.OrganizationBudgetAlertCalls.Select(call => call.UserId).Distinct().Count());
+    }
+
+    [Fact]
+    public async Task ProjectHandler_DuplicateDelivery_SendsRecipientOnce()
+    {
+        var organization = await OrganizationRepository.GetByIdAsync(OrganizationId);
+        var project = await ProjectRepository.GetByIdAsync(ProjectId);
+        Assert.NotNull(organization);
+        Assert.NotNull(project);
+        int spike = GetCurrentWindowSpike(organization.MaxEventsPerMonth);
+        await UsageService.IncrementTotalAsync(organization, project.Id, spike);
+        Assert.True((await UsageService.GetEventIngestAllowanceAsync(organization, project)).SmartThrottle.IsThrottled);
+
+        var workItem = new ProjectSmartThrottleWorkItem
+        {
+            OrganizationId = OrganizationId,
+            ProjectId = ProjectId,
+            SampleRate = 0.05,
+            CurrentEventCount = spike,
+            EventLimit = 333_333,
+            UsagePeriod = TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()
+        };
+
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), workItem);
+        await HandleAsync(GetService<ProjectSmartThrottleWorkItemHandler>(), workItem);
+
+        Assert.Single(Mailer.ProjectThrottleCalls);
+    }
+
+    private int GetCurrentWindowSpike(int maxEventsPerMonth)
+    {
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+        var endOfMonth = new DateTime(utcNow.Year, utcNow.Month, 1, 0, 0, 0, DateTimeKind.Utc).AddMonths(1);
+        double windowsLeft = Math.Max(1, Math.Ceiling((endOfMonth - utcNow).TotalMinutes / 5));
+        return (int)Math.Floor(maxEventsPerMonth / windowsLeft * 10 * 0.9);
+    }
+
+    private static async Task HandleAsync(WorkItemHandlerBase handler, object workItem)
+    {
+        await using var workItemLock = await handler.GetWorkItemLockAsync(workItem, TestContext.Current.CancellationToken);
+        Assert.NotNull(workItemLock);
+        var context = new WorkItemContext(workItem, "test-job", workItemLock, TestContext.Current.CancellationToken, static (_, _) => Task.CompletedTask);
+        await handler.HandleItemAsync(context);
+    }
+}
diff --git a/tests/Exceptionless.Tests/Mail/CountingMailer.cs b/tests/Exceptionless.Tests/Mail/CountingMailer.cs
index 2967a84886..5c8d039891 100644
--- a/tests/Exceptionless.Tests/Mail/CountingMailer.cs
+++ b/tests/Exceptionless.Tests/Mail/CountingMailer.cs
@@ -6,16 +6,20 @@ namespace Exceptionless.Tests.Mail;
 public class CountingMailer : IMailer
 {
     private int _organizationNoticeCount;
+    private int _organizationBudgetAlertAttemptCount;
 
     public int OrganizationNoticeCount => _organizationNoticeCount;
 
     public List<OrganizationNoticeCall> OrganizationNoticeCalls { get; } = [];
+    public List<OrganizationBudgetAlertCall> OrganizationBudgetAlertCalls { get; } = [];
+    public List<ProjectThrottleCall> ProjectThrottleCalls { get; } = [];
 
     /// <summary>
     /// When true, <see cref="SendOrganizationNoticeAsync"/> throws instead of recording a call.
     /// Reset by <see cref="Reset"/>.
     /// </summary>
     public bool ShouldThrow { get; set; }
+    public int? ThrowOnOrganizationBudgetAlertAttempt { get; set; }
 
     public Task<bool> SendContactRequestAsync(string name, string emailAddress, string? company, string? subject, string message, string? clientIpAddress, string? userAgent, string? referrer)
     {
@@ -55,6 +59,28 @@ public Task SendOrganizationPaymentFailedAsync(User owner, Organization organiza
         return Task.CompletedTask;
     }
 
+    public Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit)
+    {
+        int attempt = Interlocked.Increment(ref _organizationBudgetAlertAttemptCount);
+        if (ThrowOnOrganizationBudgetAlertAttempt == attempt)
+            throw new InvalidOperationException("Simulated budget alert mailer failure.");
+
+        lock (OrganizationBudgetAlertCalls)
+        {
+            OrganizationBudgetAlertCalls.Add(new OrganizationBudgetAlertCall(user.Id, organization.Id, threshold, thresholdEventCount, currentEventCount, eventLimit));
+        }
+        return Task.CompletedTask;
+    }
+
+    public Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit)
+    {
+        lock (ProjectThrottleCalls)
+        {
+            ProjectThrottleCalls.Add(new ProjectThrottleCall(user.Id, organization.Id, project.Id, sampleRate, currentEventCount, eventLimit));
+        }
+        return Task.CompletedTask;
+    }
+
     public Task SendProjectDailySummaryAsync(User user, Project project, IEnumerable<Stack>? mostFrequent, IEnumerable<Stack>? newest, DateTime startDate, bool hasSubmittedEvents, double count, double uniqueCount, double newCount, double fixedCount, int blockedCount, int tooBigCount, bool isFreePlan)
     {
         return Task.CompletedTask;
@@ -73,12 +99,24 @@ public Task SendUserPasswordResetAsync(User user)
     public void Reset()
     {
         Interlocked.Exchange(ref _organizationNoticeCount, 0);
+        Interlocked.Exchange(ref _organizationBudgetAlertAttemptCount, 0);
         lock (OrganizationNoticeCalls)
         {
             OrganizationNoticeCalls.Clear();
         }
+        lock (OrganizationBudgetAlertCalls)
+        {
+            OrganizationBudgetAlertCalls.Clear();
+        }
+        lock (ProjectThrottleCalls)
+        {
+            ProjectThrottleCalls.Clear();
+        }
         ShouldThrow = false;
+        ThrowOnOrganizationBudgetAlertAttempt = null;
     }
 }
 
 public record OrganizationNoticeCall(string UserId, string OrganizationId, bool IsOverMonthlyLimit, bool IsOverHourlyLimit);
+public record OrganizationBudgetAlertCall(string UserId, string OrganizationId, int Threshold, int ThresholdEventCount, int CurrentEventCount, int EventLimit);
+public record ProjectThrottleCall(string UserId, string OrganizationId, string ProjectId, double SampleRate, int CurrentEventCount, int EventLimit);
diff --git a/tests/Exceptionless.Tests/Mail/MailerTests.cs b/tests/Exceptionless.Tests/Mail/MailerTests.cs
index 9aa950e99c..c972cf4988 100644
--- a/tests/Exceptionless.Tests/Mail/MailerTests.cs
+++ b/tests/Exceptionless.Tests/Mail/MailerTests.cs
@@ -109,9 +109,11 @@ public void AppUrlBuilder_ProductionBaseUrl_UsesRootSvelteRoutes()
             ("organization/organization-1/upgrade", appUrls.OrganizationUpgrade("organization-1")),
             ("organization/organization-1/dashboard?view=stacks", appUrls.OrganizationFrequent("organization-1")),
             ("organization/organization-1/usage", appUrls.OrganizationManage("organization-1")),
+            ("organization/organization-1/usage", appUrls.OrganizationUsage("organization-1")),
             ("organization/organization-1/billing", appUrls.OrganizationBilling("organization-1")),
             ("project/project-1/dashboard?type=error", appUrls.ProjectTimeline("project-1")),
             ("project/project-1/configure", appUrls.ProjectConfigure("project-1")),
+            ("project/project-1/usage", appUrls.ProjectUsage("project-1")),
             ("project/project-1/dashboard?type=error&view=stacks", appUrls.ProjectMostFrequent("project-1")),
             ("project/project-1/dashboard?type=error&view=stacks", appUrls.ProjectNewest("project-1")),
             ("account/notifications", appUrls.AccountNotifications()),
@@ -565,6 +567,61 @@ public async Task SendOrganizationPaymentFailedAsync_WithOrganization_RendersBil
         Assert.Contains("Payment failed", body, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Fact]
+    public async Task SendOrganizationBudgetAlertAsync_WithHtmlName_RendersCountsAndSafeUsageLinks()
+    {
+        // Arrange
+        var user = _userData.GenerateSampleUser();
+        var organization = _organizationData.GenerateSampleOrganization(_billingManager, _plans);
+        organization.Id = "organization-budget";
+        organization.Name = "<Budget & \"Team\">";
+
+        // Act
+        await _mailer.SendOrganizationBudgetAlertAsync(user, organization, 80, 800, 825, 1000);
+        var body = await RunMailJobAsync();
+
+        // Assert
+        Assert.Contains(WebUtility.HtmlEncode(organization.Name), body, StringComparison.Ordinal);
+        Assert.Contains("View Usage", body, StringComparison.Ordinal);
+        Assert.Contains("The organization has accepted 825 events", body, StringComparison.Ordinal);
+        Assert.Contains("The 80% alert is 800 events", body, StringComparison.Ordinal);
+        Assert.Contains("the current allowance is 1000, and 175 events remain", body, StringComparison.Ordinal);
+        string baseUrl = _options.BaseURL.TrimEnd('/');
+        Assert.Contains($"{baseUrl}/organization/organization-budget/usage", body, StringComparison.Ordinal);
+        Assert.Contains($"{baseUrl}/account/notifications", body, StringComparison.Ordinal);
+        Assert.DoesNotContain("<Budget & \"Team\">", body, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task SendProjectThrottledNoticeAsync_WithHtmlNames_RendersCountsAndSafeUsageLinks()
+    {
+        // Arrange
+        var user = _userData.GenerateSampleUser();
+        var organization = _organizationData.GenerateSampleOrganization(_billingManager, _plans);
+        organization.Id = "organization-throttle";
+        organization.Name = "<Organization & \"Team\">";
+        var project = _projectData.GenerateSampleProject();
+        project.Id = "project-throttle";
+        project.Name = "<Checkout & API>";
+
+        // Act
+        await _mailer.SendProjectThrottledNoticeAsync(user, organization, project, 0.05, 123, 100);
+        var body = await RunMailJobAsync();
+
+        // Assert
+        Assert.Contains(WebUtility.HtmlEncode(organization.Name), body, StringComparison.Ordinal);
+        Assert.Contains(WebUtility.HtmlEncode(project.Name), body, StringComparison.Ordinal);
+        Assert.Contains("View Project Usage", body, StringComparison.Ordinal);
+        Assert.Contains("accepted 123 events this month", body, StringComparison.Ordinal);
+        Assert.Contains("monthly fair-share allowance is 100 events", body, StringComparison.Ordinal);
+        Assert.Contains("stable 5% sample", body, StringComparison.Ordinal);
+        string baseUrl = _options.BaseURL.TrimEnd('/');
+        Assert.Contains($"{baseUrl}/project/project-throttle/usage", body, StringComparison.Ordinal);
+        Assert.Contains($"{baseUrl}/account/notifications", body, StringComparison.Ordinal);
+        Assert.DoesNotContain("<Organization & \"Team\">", body, StringComparison.Ordinal);
+        Assert.DoesNotContain("<Checkout & API>", body, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task SendProjectDailySummaryAsync_WithSubmittedEvents_RendersTimelineLinks()
     {
@@ -796,7 +853,7 @@ private void AssertValidUrls(string body, bool requireUrls)
     private static void AssertValidInternalUrl(Uri uri)
     {
         Assert.Empty(uri.Fragment);
-        Assert.Matches(@"^/(?:event/[^/]+|stack/[^/]+(?:/(?:mark-fixed|ignored|discarded))?|project/[^/]+/(?:configure|dashboard)|account/(?:notifications|verify)|organization/[^/]+/(?:dashboard|usage|billing|upgrade)|signup|reset-password/[^/]+)$", uri.AbsolutePath);
+        Assert.Matches(@"^/(?:event/[^/]+|stack/[^/]+(?:/(?:mark-fixed|ignored|discarded))?|project/[^/]+/(?:configure|dashboard|usage)|account/(?:notifications|verify)|organization/[^/]+/(?:dashboard|usage|billing|upgrade)|signup|reset-password/[^/]+)$", uri.AbsolutePath);
 
         if (uri.AbsolutePath is "/account/verify" or "/signup")
         {
diff --git a/tests/Exceptionless.Tests/Mail/NullMailer.cs b/tests/Exceptionless.Tests/Mail/NullMailer.cs
index 7ce54fcde6..86b854c649 100644
--- a/tests/Exceptionless.Tests/Mail/NullMailer.cs
+++ b/tests/Exceptionless.Tests/Mail/NullMailer.cs
@@ -35,6 +35,16 @@ public Task SendOrganizationPaymentFailedAsync(User owner, Organization organiza
         return Task.CompletedTask;
     }
 
+    public Task SendOrganizationBudgetAlertAsync(User user, Organization organization, int threshold, int thresholdEventCount, int currentEventCount, int eventLimit)
+    {
+        return Task.CompletedTask;
+    }
+
+    public Task SendProjectThrottledNoticeAsync(User user, Organization organization, Project project, double sampleRate, int currentEventCount, int eventLimit)
+    {
+        return Task.CompletedTask;
+    }
+
     public Task SendProjectDailySummaryAsync(User user, Project project, IEnumerable<Stack>? mostFrequent, IEnumerable<Stack>? newest, DateTime startDate, bool hasSubmittedEvents, double count, double uniqueCount, double newCount, double fixedCount, int blockedCount, int tooBigCount, bool isFreePlan)
     {
         return Task.CompletedTask;
diff --git a/tests/Exceptionless.Tests/Serializer/Models/OrganizationSerializerTests.cs b/tests/Exceptionless.Tests/Serializer/Models/OrganizationSerializerTests.cs
index 31505a2f3e..a6e2985c26 100644
--- a/tests/Exceptionless.Tests/Serializer/Models/OrganizationSerializerTests.cs
+++ b/tests/Exceptionless.Tests/Serializer/Models/OrganizationSerializerTests.cs
@@ -141,4 +141,41 @@ public void Deserialize_SnakeCaseJson_ParsesCorrectly()
         Assert.Equal("EX_SMALL", result.PlanId);
         Assert.Equal(10000, result.MaxEventsPerMonth);
     }
+
+    [Fact]
+    public void Deserialize_LegacyJsonWithoutBudgetSettings_DefaultsToNull()
+    {
+        var result = _serializer.Deserialize<Organization>("""{"id":"550000000000000000000005","name":"Legacy"}""");
+
+        Assert.NotNull(result);
+        Assert.Null(result.BudgetAlertSettings);
+    }
+
+    [Fact]
+    public void RoundTrip_WithBudgetSettings_PreservesSnakeCaseValues()
+    {
+        var organization = new Organization
+        {
+            Id = "550000000000000000000006",
+            Name = "Budgeted",
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = [50, 80] }
+        };
+
+        string json = _serializer.SerializeToString(organization);
+        var result = _serializer.Deserialize<Organization>(json);
+
+        Assert.Contains("\"budget_alert_settings\"", json);
+        Assert.NotNull(result?.BudgetAlertSettings);
+        Assert.True(result.BudgetAlertSettings.Enabled);
+        Assert.Equal([50, 80], result.BudgetAlertSettings.Thresholds);
+    }
+
+    [Fact]
+    public void RoundTrip_WithNullBudgetSettings_OmitsPersistedField()
+    {
+        string json = _serializer.SerializeToString(new Organization { Id = "550000000000000000000007", Name = "Default" });
+
+        Assert.DoesNotContain("budget_alert_settings", json);
+        Assert.Null(_serializer.Deserialize<Organization>(json)?.BudgetAlertSettings);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Serializer/Models/ProjectSerializerTests.cs b/tests/Exceptionless.Tests/Serializer/Models/ProjectSerializerTests.cs
index b512a647f6..be5a604e79 100644
--- a/tests/Exceptionless.Tests/Serializer/Models/ProjectSerializerTests.cs
+++ b/tests/Exceptionless.Tests/Serializer/Models/ProjectSerializerTests.cs
@@ -69,4 +69,50 @@ public void Deserialize_RoundTrip_PreservesBasicProperties()
         Assert.Equal("My Project", deserialized.Name);
         Assert.True(deserialized.IsConfigured);
     }
+
+    [Fact]
+    public void Deserialize_LegacyJsonWithoutIngestLimit_DefaultsToNull()
+    {
+        var project = _serializer.Deserialize<Project>("""{"id":"proj-legacy","organization_id":"org1","name":"Legacy"}""");
+
+        Assert.NotNull(project);
+        Assert.Null(project.IngestLimit);
+    }
+
+    public static TheoryData<ProjectIngestLimitType, int?, decimal?> IngestLimits => new()
+    {
+        { ProjectIngestLimitType.Fixed, 100, null },
+        { ProjectIngestLimitType.PercentOfOrganizationLimit, null, 8.3m }
+    };
+
+    [Theory]
+    [MemberData(nameof(IngestLimits))]
+    public void RoundTrip_WithIngestLimit_PreservesSnakeCaseValues(ProjectIngestLimitType type, int? fixedLimit, decimal? percentage)
+    {
+        var project = new Project
+        {
+            Id = "proj-budget",
+            OrganizationId = "org1",
+            Name = "Budgeted",
+            IngestLimit = new ProjectIngestLimit { Type = type, FixedLimit = fixedLimit, PercentOfOrganizationLimit = percentage }
+        };
+
+        string json = _serializer.SerializeToString(project);
+        var result = _serializer.Deserialize<Project>(json);
+
+        Assert.Contains("\"ingest_limit\"", json);
+        Assert.NotNull(result?.IngestLimit);
+        Assert.Equal(type, result.IngestLimit.Type);
+        Assert.Equal(fixedLimit, result.IngestLimit.FixedLimit);
+        Assert.Equal(percentage, result.IngestLimit.PercentOfOrganizationLimit);
+    }
+
+    [Fact]
+    public void RoundTrip_WithNullIngestLimit_OmitsPersistedField()
+    {
+        string json = _serializer.SerializeToString(new Project { Id = "proj-default", OrganizationId = "org1", Name = "Default" });
+
+        Assert.DoesNotContain("ingest_limit", json);
+        Assert.Null(_serializer.Deserialize<Project>(json)?.IngestLimit);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Services/RedisAtomicCacheBatchTests.cs b/tests/Exceptionless.Tests/Services/RedisAtomicCacheBatchTests.cs
new file mode 100644
index 0000000000..9362d6c16e
--- /dev/null
+++ b/tests/Exceptionless.Tests/Services/RedisAtomicCacheBatchTests.cs
@@ -0,0 +1,132 @@
+using Exceptionless.Core.Configuration;
+using Exceptionless.Core.Services;
+using Exceptionless.Insulation.Redis;
+using StackExchange.Redis;
+using Xunit;
+
+namespace Exceptionless.Tests.Services;
+
+public sealed class RedisAtomicCacheBatchTests(AppWebHostFactory factory) : IAsyncLifetime, IClassFixture<AppWebHostFactory>
+{
+    private readonly string _scope = $"atomic-batch-{Guid.NewGuid():N}";
+    private IConnectionMultiplexer _connection = null!;
+    private RedisAtomicCacheBatch _batch = null!;
+
+    public async ValueTask InitializeAsync()
+    {
+        _ = factory;
+        _connection = await ConnectionMultiplexer.ConnectAsync(await AppWebHostFactory.GetConnectionStringAsync("Redis"));
+        _batch = new RedisAtomicCacheBatch(_connection, new CacheOptions { Scope = _scope }, TimeProvider.System);
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        await _connection.GetDatabase().KeyDeleteAsync([
+            Key("record"),
+            Key("bucket"),
+            Key("members"),
+            Key("mismatch"),
+            Key("mismatch-members"),
+            Key("concurrent"),
+            Key("wrong-type-scalar"),
+            Key("wrong-type-list")
+        ]);
+        await _connection.CloseAsync();
+        _connection.Dispose();
+    }
+
+    [Fact]
+    public async Task TrySetAllAsync_ExpectedValuesMatch_UpdatesAllValuesWithIndependentExpirations()
+    {
+        var database = _connection.GetDatabase();
+        await database.StringSetAsync(Key("record"), "__EX_MISSING__");
+        await database.StringSetAsync(Key("bucket"), "1");
+        var expected = new Dictionary<string, string?>
+        {
+            ["record"] = "__EX_MISSING__",
+            ["bucket"] = "1"
+        };
+        var updates = new Dictionary<string, AtomicCacheValue>
+        {
+            ["record"] = new("active", TimeSpan.FromHours(1)),
+            ["bucket"] = new("2", TimeSpan.FromMinutes(5))
+        };
+
+        bool updated = await _batch.TrySetAllAsync(
+            expected,
+            updates,
+            new Dictionary<string, string> { ["members"] = "organization-id" },
+            TimeSpan.FromMinutes(5));
+
+        Assert.True(updated);
+        Assert.Equal("active", await database.StringGetAsync(Key("record")));
+        Assert.Equal("2", await database.StringGetAsync(Key("bucket")));
+        Assert.NotNull(await database.SortedSetScoreAsync(Key("members"), "organization-id"));
+        Assert.InRange((await database.KeyTimeToLiveAsync(Key("record")))!.Value.TotalMinutes, 59, 60);
+        Assert.InRange((await database.KeyTimeToLiveAsync(Key("bucket")))!.Value.TotalMinutes, 4, 5);
+    }
+
+    [Fact]
+    public async Task TrySetAllAsync_ExpectedValueDoesNotMatch_ChangesNothing()
+    {
+        var database = _connection.GetDatabase();
+        await database.StringSetAsync(Key("mismatch"), "before");
+
+        bool updated = await _batch.TrySetAllAsync(
+            new Dictionary<string, string?> { ["mismatch"] = "different" },
+            new Dictionary<string, AtomicCacheValue> { ["mismatch"] = new("after", TimeSpan.FromMinutes(5)) },
+            new Dictionary<string, string> { ["mismatch-members"] = "member" },
+            TimeSpan.FromMinutes(5));
+
+        Assert.False(updated);
+        Assert.Equal("before", await database.StringGetAsync(Key("mismatch")));
+        Assert.Null(await database.SortedSetScoreAsync(Key("mismatch-members"), "member"));
+    }
+
+    [Fact]
+    public async Task TrySetAllAsync_ConcurrentWriters_OnlyOneWins()
+    {
+        var database = _connection.GetDatabase();
+        await database.StringSetAsync(Key("concurrent"), "before");
+        var expected = new Dictionary<string, string?> { ["concurrent"] = "before" };
+
+        var results = await Task.WhenAll(
+            _batch.TrySetAllAsync(expected, new Dictionary<string, AtomicCacheValue> { ["concurrent"] = new("first", TimeSpan.FromMinutes(5)) }),
+            _batch.TrySetAllAsync(expected, new Dictionary<string, AtomicCacheValue> { ["concurrent"] = new("second", TimeSpan.FromMinutes(5)) }));
+
+        Assert.Single(results, result => result);
+        Assert.Contains((string?)await database.StringGetAsync(Key("concurrent")), new[] { "first", "second" });
+    }
+
+    [Fact]
+    public async Task TrySetAllAsync_ListKeyHasWrongType_DoesNotChangeScalars()
+    {
+        var database = _connection.GetDatabase();
+        await database.StringSetAsync(Key("wrong-type-scalar"), "before");
+        await database.StringSetAsync(Key("wrong-type-list"), "not-a-sorted-set");
+
+        await Assert.ThrowsAsync<RedisServerException>(() => _batch.TrySetAllAsync(
+            new Dictionary<string, string?> { ["wrong-type-scalar"] = "before" },
+            new Dictionary<string, AtomicCacheValue> { ["wrong-type-scalar"] = new("after", TimeSpan.FromMinutes(5)) },
+            new Dictionary<string, string> { ["wrong-type-list"] = "member" },
+            TimeSpan.FromMinutes(5)));
+
+        Assert.Equal("before", await database.StringGetAsync(Key("wrong-type-scalar")));
+    }
+
+    [Fact]
+    public async Task TrySetAllAsync_InvalidBatch_RejectsBeforeRedisMutation()
+    {
+        await Assert.ThrowsAsync<ArgumentException>(() => _batch.TrySetAllAsync(
+            new Dictionary<string, string?> { ["expected"] = null },
+            new Dictionary<string, AtomicCacheValue> { ["different"] = new("value", TimeSpan.FromMinutes(5)) }));
+
+        await Assert.ThrowsAsync<ArgumentException>(() => _batch.TrySetAllAsync(
+            new Dictionary<string, string?> { ["overlap"] = null },
+            new Dictionary<string, AtomicCacheValue> { ["overlap"] = new("value", TimeSpan.FromMinutes(5)) },
+            new Dictionary<string, string> { ["overlap"] = "member" },
+            TimeSpan.FromMinutes(5)));
+    }
+
+    private RedisKey Key(string key) => $"{_scope}:{key}";
+}
diff --git a/tests/Exceptionless.Tests/Services/UsageBudgetServiceTests.cs b/tests/Exceptionless.Tests/Services/UsageBudgetServiceTests.cs
new file mode 100644
index 0000000000..b6ac00348d
--- /dev/null
+++ b/tests/Exceptionless.Tests/Services/UsageBudgetServiceTests.cs
@@ -0,0 +1,927 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using Exceptionless.Core;
+using Exceptionless.Core.Billing;
+using Exceptionless.Core.Extensions;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
+using Exceptionless.DateTimeExtensions;
+using Exceptionless.Tests.Extensions;
+using Foundatio.AsyncEx;
+using Foundatio.Caching;
+using Foundatio.Lock;
+using Foundatio.Messaging;
+using Foundatio.Repositories;
+using Xunit;
+using LogLevel = Microsoft.Extensions.Logging.LogLevel;
+
+namespace Exceptionless.Tests.Services;
+
+public sealed partial class UsageServiceTests
+{
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_OrganizationNotFound_ReturnsNoThrottle()
+    {
+        // Regression test: When the organization does not exist, GetMaxEventsPerMonthAsync
+        // returns 0 (default). GetSmartThrottleRateAsync must not divide by zero.
+        string nonExistentOrganizationId = "000000000000000000000099";
+        string nonExistentProjectId = "000000000000000000000098";
+
+        // Act - this would divide by zero before the fix (maxEventsPerMonth=0 returned for missing organization)
+        var result = await _usageService.GetSmartThrottleRateAsync(nonExistentOrganizationId, nonExistentProjectId);
+
+        // Assert - should return NoThrottle since maxEventsPerMonth <= 0 means unlimited/invalid
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+    }
+
+    // ── GetEventIngestAllowanceAsync ────────────────────────────────────────
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithNoIngestLimit_ReturnsOrganizationLimit()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.True(result.EventsLeft > 0);
+        Assert.Equal(1.0, result.SampleRate);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithFixedIngestLimit_BelowOrganizationLimit_ReturnsFixed()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 100 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(100, result.EventsLeft);
+        Assert.Equal(100, result.EffectiveProjectLimit);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithFixedIngestLimit_AboveOrganizationLimit_ReturnsOrganizationLimit()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 10000 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 749);
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(1, result.EventsLeft);
+        Assert.Equal(750, result.EffectiveProjectLimit);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithPercentageIngestLimit_50Percent_ReturnsCorrectLimit()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.PercentOfOrganizationLimit, PercentOfOrganizationLimit = 50 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(500, result.EventsLeft);
+        Assert.Equal(500, result.EffectiveProjectLimit);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithInvalidPersistedPercentage_IsInactive()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks
+        }, o => o.ImmediateConsistency().Cache());
+        project.IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.PercentOfOrganizationLimit, PercentOfOrganizationLimit = 150 };
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization, project);
+
+        Assert.Equal(-1, result.EffectiveProjectLimit);
+        Assert.True(result.EventsLeft > 0);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithFixedLimit_OverLimit_IsOverProjectLimitTrue()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 100 }
+        }, o => o.ImmediateConsistency().Cache());
+        project.GetCurrentUsage(TimeProvider).Total = 100;
+        await _projectRepository.SaveAsync(project, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(0, result.EventsLeft);
+        Assert.True(result.IsOverProjectLimit);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.Equal(100, result.EffectiveProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Organization_OverLimit_IsOverOrganizationLimitTrue()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 750);
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(0, result.EventsLeft);
+        Assert.True(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_UnlimitedOrganization_WithFixedProjectLimit_ReturnsFixed()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = _plans.UnlimitedPlan.MaxEventsPerMonth, PlanId = _plans.UnlimitedPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 500 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(500, result.EventsLeft);
+        Assert.Equal(500, result.EffectiveProjectLimit);
+        Assert.False(result.IsOverOrganizationLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    // ── GetSmartThrottleRateAsync ────────────────────────────────────────────
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_BelowThreshold_ReturnsNoThrottle()
+    {
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id };
+        organization.GetCurrentUsage(TimeProvider).Total = 600;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project1 = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var project2 = await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        project1.GetCurrentUsage(TimeProvider).Total = 600;
+        await _projectRepository.SaveAsync(project1, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_SingleProjectInOrganization_ReturnsNoThrottle()
+    {
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id };
+        organization.GetCurrentUsage(TimeProvider).Total = 900;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        project.GetCurrentUsage(TimeProvider).Total = 900;
+        await _projectRepository.SaveAsync(project, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_NoOrganizationUsage_ReturnsNoThrottle()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project1 = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var project2 = await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_NoProjectUsage_ReturnsNoThrottle()
+    {
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id };
+        organization.GetCurrentUsage(TimeProvider).Total = 900;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project1 = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var project2 = await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_AboveThreshold_FairShare_ReturnsNoThrottle()
+    {
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id };
+        organization.GetCurrentUsage(TimeProvider).Total = 900;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project1 = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var project2 = await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        // fairShare = 1000/2 = 500; projectTotal = 900 → fairShareRatio = 1.8 ≤ 2.0
+        project1.GetCurrentUsage(TimeProvider).Total = 900;
+        await _projectRepository.SaveAsync(project1, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_CurrentWindowSpike_UsesFixedFivePercentSample()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1_000_000,
+            PlanId = _plans.ExtraLargePlan.Id
+        }, o => o.ImmediateConsistency().Cache());
+        var project1 = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "P3", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.IncrementTotalAsync(organization, project1.Id, 1_900);
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.True(result.IsThrottled);
+        Assert.Equal(0.05, result.SampleRate);
+        Assert.Equal(1_900, result.CurrentProjectUsage);
+        Assert.Equal(333_333, result.FairShareLimit);
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_HighMonthlyUsageWithoutCurrentSpike_ReturnsNoThrottle()
+    {
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 1_000_000, PlanId = _plans.ExtraLargePlan.Id };
+        organization.GetCurrentUsage(TimeProvider).Total = 900_000;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project1 = new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks };
+        project1.GetCurrentUsage(TimeProvider).Total = 900_000;
+        project1 = await _projectRepository.AddAsync(project1, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "P2", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_UnlimitedOrganization_ReturnsNoThrottle()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = _plans.UnlimitedPlan.MaxEventsPerMonth, PlanId = _plans.UnlimitedPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "P1", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project.Id);
+
+        Assert.False(result.IsThrottled);
+        Assert.Equal(1.0, result.SampleRate);
+    }
+
+    // ── Budget Alert Threshold tests ─────────────────────────────────────────
+
+    [Fact]
+    public async Task IncrementTotalAsync_CrossingThreshold_PublishesAlertMessage()
+    {
+        var messageBus = GetService<IMessageBus>();
+        var countdown = new AsyncCountdownEvent(1);
+        OrganizationBudgetAlert? alert = null;
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(a =>
+        {
+            alert = a;
+            countdown.Signal();
+        }, TestCancellationToken);
+
+        var organization = new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1000,
+            PlanId = _plans.SmallPlan.Id,
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = new SortedSet<int> { 50 } }
+        };
+        organization.GetCurrentUsage(TimeProvider).Total = 490;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.GetEventsLeftAsync(organization.Id);
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 15);
+        await countdown.WaitAsync(TimeSpan.FromSeconds(5));
+
+        Assert.NotNull(alert);
+        Assert.Equal(organization.Id, alert.OrganizationId);
+        Assert.Equal(50, alert.Threshold);
+        Assert.Equal(500, alert.ThresholdEventCount);
+        Assert.Equal(1000, alert.EventLimit);
+    }
+
+    [Fact]
+    public async Task IncrementTotalAsync_Threshold_NotDuplicated_WhenCrossedTwice()
+    {
+        var messageBus = GetService<IMessageBus>();
+        int alertCount = 0;
+        var firstAlert = new AsyncCountdownEvent(1);
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(a =>
+        {
+            int count = Interlocked.Increment(ref alertCount);
+            if (count == 1) firstAlert.Signal();
+        }, TestCancellationToken);
+
+        var organization = new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1000,
+            PlanId = _plans.SmallPlan.Id,
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = new SortedSet<int> { 50 } }
+        };
+        organization.GetCurrentUsage(TimeProvider).Total = 490;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.GetEventsLeftAsync(organization.Id);
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 15);
+        await firstAlert.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 20);
+        await Task.Delay(200, TestCancellationToken);
+
+        Assert.Equal(1, alertCount);
+    }
+
+    [Fact]
+    public async Task CheckBudgetAlertThresholdsAsync_ConcurrentCalls_PublishesAlertExactlyOnce()
+    {
+        // Regression: non-atomic get-then-set allowed two concurrent workers to both see the
+        // key absent and both publish. The fix uses AddAsync (atomic) so only the worker
+        // whose increment returns 1 sends the alert.
+        var messageBus = GetService<IMessageBus>();
+        int alertCount = 0;
+        var firstAlert = new AsyncCountdownEvent(1);
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(_ =>
+        {
+            int count = Interlocked.Increment(ref alertCount);
+            if (count == 1) firstAlert.Signal();
+        }, TestCancellationToken);
+
+        var organization = new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1000,
+            PlanId = _plans.SmallPlan.Id,
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = new SortedSet<int> { 50 } }
+        };
+        organization.GetCurrentUsage(TimeProvider).Total = 490;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        // Simulate concurrent workers by calling GetEventsLeftAsync + IncrementTotalAsync
+        // concurrently. Both workers see usage crossing 50%; only one should publish the alert.
+        await _usageService.GetEventsLeftAsync(organization.Id);
+        var tasks = Enumerable.Range(0, 5)
+            .Select(_ => _usageService.IncrementTotalAsync(organization.Id, project.Id, 15))
+            .ToArray();
+        await Task.WhenAll(tasks);
+
+        // Wait for the first (and only) alert, then give extra time for any duplicates.
+        await firstAlert.WaitAsync(TimeSpan.FromSeconds(5));
+        await Task.Delay(300, TestCancellationToken);
+
+        Assert.Equal(1, alertCount);
+    }
+
+    [Fact]
+    public async Task IncrementTotalAsync_DisabledAlerts_DoNotPublishMessages()
+    {
+        var messageBus = GetService<IMessageBus>();
+        int alertCount = 0;
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(_ => { Interlocked.Increment(ref alertCount); }, TestCancellationToken);
+
+        var organization = new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1000,
+            PlanId = _plans.SmallPlan.Id,
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = false, Thresholds = new SortedSet<int> { 50 } }
+        };
+        organization.GetCurrentUsage(TimeProvider).Total = 490;
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.GetEventsLeftAsync(organization.Id);
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 100);
+
+        await Task.Delay(200, TestCancellationToken);
+        Assert.Equal(0, alertCount);
+    }
+
+    [Fact]
+    public async Task IncrementTotalAsync_AllThresholds_AllFireOnce()
+    {
+        var messageBus = GetService<IMessageBus>();
+        var firedThresholds = new System.Collections.Concurrent.ConcurrentBag<int>();
+        var countdown = new AsyncCountdownEvent(3);
+        await messageBus.SubscribeAsync<OrganizationBudgetAlert>(a =>
+        {
+            firedThresholds.Add(a.Threshold);
+            countdown.Signal();
+        }, TestCancellationToken);
+
+        var organization = new Organization
+        {
+            Name = "Test",
+            MaxEventsPerMonth = 1000,
+            PlanId = _plans.SmallPlan.Id,
+            BudgetAlertSettings = new OrganizationBudgetAlertSettings { Enabled = true, Thresholds = new SortedSet<int> { 50, 80, 90 } }
+        };
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+
+        await _usageService.GetEventsLeftAsync(organization.Id);
+        await _usageService.IncrementTotalAsync(organization.Id, project.Id, 950);
+        await countdown.WaitAsync(TimeSpan.FromSeconds(5));
+
+        Assert.Equal(3, firedThresholds.Count);
+        Assert.Contains(50, firedThresholds);
+        Assert.Contains(80, firedThresholds);
+        Assert.Contains(90, firedThresholds);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_SmallPercentageLimit_UsesRoundUp_NotZero()
+    {
+        // Regression: 1% of 50 events floored to 0 with (int)cast, making the project
+        // permanently over-budget on the first event. Math.Ceiling must be used.
+        var organization = new Organization { Name = "Test", MaxEventsPerMonth = 50, PlanId = _plans.SmallPlan.Id };
+        organization = await _organizationRepository.AddAsync(organization, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.PercentOfOrganizationLimit, PercentOfOrganizationLimit = 1 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        // 1% of 50 = 0.5 → must ceil to 1, not floor to 0
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+        Assert.True(result.EffectiveProjectLimit >= 1, $"EffectiveProjectLimit was {result.EffectiveProjectLimit}, expected >= 1 (floor bug would produce 0)");
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_DecimalPercentage_UsesExactCeiling()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 3000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.PercentOfOrganizationLimit, PercentOfOrganizationLimit = 1.1m }
+        }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization, project);
+
+        Assert.Equal(33, result.EffectiveProjectLimit);
+    }
+
+    [Fact]
+    public void GetBudgetThresholdEventCount_ExactPercentage_DoesNotRoundPastInteger()
+    {
+        Assert.Equal(210, UsageService.GetBudgetThresholdEventCount(3000, 7));
+        Assert.Equal(5250, UsageService.GetBudgetThresholdEventCount(75000, 7));
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ConcurrentProjectCapReservations_DoNotExceedRemainingLimit()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 100 }
+        }, o => o.ImmediateConsistency().Cache());
+        await _usageService.IncrementTotalAsync(organization, project.Id, 90);
+
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var reservations = await Task.WhenAll(Enumerable.Range(0, 10).Select(index =>
+            _usageService.ReserveEventIngestAsync(organization, project, $"reservation-{index}", candidates, TestCancellationToken)));
+
+        Assert.Equal(10, reservations.Sum(reservation => reservation.ReservedCount));
+
+        await Task.WhenAll(reservations.Select(_usageService.ReleaseEventIngestReservationAsync));
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_ReleasesUnprocessedCapacity()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Test",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 100 }
+        }, o => o.ImmediateConsistency().Cache());
+        await _usageService.IncrementTotalAsync(organization, project.Id, 90);
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var first = await _usageService.ReserveEventIngestAsync(organization, project, "first", candidates, TestCancellationToken);
+
+        await _usageService.CompleteEventIngestReservationAsync(first, organization, 4);
+        var second = await _usageService.ReserveEventIngestAsync(organization, project, "second", candidates, TestCancellationToken);
+
+        Assert.Equal(6, second.ReservedCount);
+        await _usageService.ReleaseEventIngestReservationAsync(second);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_AfterRelease_RecreatesReservationWithoutDoubleDecrement()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Retry", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Retry",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 10 }
+        }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var first = await _usageService.ReserveEventIngestAsync(organization, project, "retry", candidates, TestCancellationToken);
+        await _usageService.ReleaseEventIngestReservationAsync(first);
+
+        var retried = await _usageService.ReserveEventIngestAsync(organization, project, "retry", candidates, TestCancellationToken);
+        var competing = await _usageService.ReserveEventIngestAsync(organization, project, "competing", candidates, TestCancellationToken);
+
+        Assert.Equal(10, retried.ReservedCount);
+        Assert.Equal(0, competing.ReservedCount);
+        await _usageService.ReleaseEventIngestReservationAsync(retried);
+        await _usageService.CompleteEventIngestReservationAsync(competing, organization, 0);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_AfterCompletion_ReturnsCompletedTombstone()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Completed", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Completed", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 2).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "completed", candidates, TestCancellationToken);
+        await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 2);
+
+        var retry = await _usageService.ReserveEventIngestAsync(organization, project, "completed", candidates, TestCancellationToken);
+
+        Assert.True(retry.IsCompleted);
+        Assert.Equal(2, retry.ProcessedCount);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ColdBucketNoisyBatch_IsSampledImmediately()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1_000_000, PlanId = _plans.ExtraLargePlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Noisy", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "Quiet", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "Other", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        int spike = 2000;
+        var candidates = Enumerable.Range(0, spike)
+            .Select(index => new EventIngestCandidate(index, (ulong)index * 7919UL))
+            .ToArray();
+
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "cold-bucket", candidates, TestCancellationToken);
+
+        Assert.True(reservation.SmartThrottle.IsThrottled);
+        Assert.InRange(reservation.ReservedCount, 60, 140);
+        await _usageService.ReleaseEventIngestReservationAsync(reservation);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_FirstMinutesOfMonth_IgnoresPreviousMonthBucket()
+    {
+        TimeProvider.SetUtcNow(new DateTimeOffset(2026, 7, 31, 23, 59, 0, TimeSpan.Zero));
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _usageService.IncrementTotalAsync(organization, project.Id, 900);
+        TimeProvider.Advance(TimeSpan.FromMinutes(3));
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization, project);
+
+        Assert.Equal(1000, result.EventsLeft);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_AfterMonthBoundary_ChargesCurrentPeriodWithoutReleasingCapacity()
+    {
+        TimeProvider.SetUtcNow(new DateTimeOffset(2026, 7, 31, 23, 59, 0, TimeSpan.Zero));
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Boundary", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Boundary", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "month-boundary", candidates, TestCancellationToken);
+
+        TimeProvider.Advance(TimeSpan.FromMinutes(2));
+        await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 10);
+
+        Assert.Equal(90, (await _usageService.GetEventIngestAllowanceAsync(organization, project)).EventsLeft);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_MissingState_FailsClosed()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Missing", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Missing", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "missing-state", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        await GetService<ICacheClient>().RemoveAsync($"usage:ingest-reservation:{{{organization.Id}}}:missing-state");
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.CompleteEventIngestReservationAsync(reservation, organization, 1));
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ActiveReplay_ReturnsSameGenerationWithoutDoubleAccounting()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Replay", MaxEventsPerMonth = 1000, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Replay",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 5 }
+        }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+
+        var first = await _usageService.ReserveEventIngestAsync(organization, project, "active-replay", candidates, TestCancellationToken);
+        var replay = await _usageService.ReserveEventIngestAsync(organization, project, "active-replay", candidates, TestCancellationToken);
+
+        Assert.Equal(first.GenerationId, replay.GenerationId);
+        Assert.Equal(first.AcceptedIndexes, replay.AcceptedIndexes);
+        Assert.Equal(5, (await _usageService.GetUsageAsync(organization.Id, project.Id)).CurrentUsage.Blocked);
+        var competing = await _usageService.ReserveEventIngestAsync(organization, project, "active-replay-competing", candidates, TestCancellationToken);
+        Assert.Equal(0, competing.ReservedCount);
+        await _usageService.CompleteEventIngestReservationAsync(competing, organization, 0);
+        await _usageService.ReleaseEventIngestReservationAsync(replay);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ReleasedReservation_RecreatesWithNewGenerationAndRejectsStaleHandle()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Generation", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Generation", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 2).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var first = await _usageService.ReserveEventIngestAsync(organization, project, "generation", candidates, TestCancellationToken);
+        await _usageService.ReleaseEventIngestReservationAsync(first);
+
+        var retried = await _usageService.ReserveEventIngestAsync(organization, project, "generation", candidates, TestCancellationToken);
+
+        Assert.NotEqual(first.GenerationId, retried.GenerationId);
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.CompleteEventIngestReservationAsync(first, organization, 2));
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.ReleaseEventIngestReservationAsync(first));
+        await _usageService.ReleaseEventIngestReservationAsync(retried);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ReleasedRetry_NarrowsPreviousSelectionAndCountsNewBlocksOnce()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Narrow", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Narrow",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 5 }
+        }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+        var first = await _usageService.ReserveEventIngestAsync(organization, project, "narrow", candidates, TestCancellationToken);
+        await _usageService.ReleaseEventIngestReservationAsync(first);
+        await _usageService.IncrementTotalAsync(organization, project.Id, 3);
+
+        var retried = await _usageService.ReserveEventIngestAsync(organization, project, "narrow", candidates, TestCancellationToken);
+        var replay = await _usageService.ReserveEventIngestAsync(organization, project, "narrow", candidates, TestCancellationToken);
+
+        Assert.Equal(2, retried.ReservedCount);
+        Assert.All(retried.AcceptedIndexes, index => Assert.Contains(index, first.AcceptedIndexes));
+        Assert.Equal(8, (await _usageService.GetUsageAsync(organization.Id, project.Id)).CurrentUsage.Blocked);
+        Assert.Equal(retried.GenerationId, replay.GenerationId);
+        Assert.Equal(8, (await _usageService.GetUsageAsync(organization.Id, project.Id)).CurrentUsage.Blocked);
+        await _usageService.ReleaseEventIngestReservationAsync(retried);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_DuplicateCompletion_CommitsUsageOnce()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Duplicate", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Duplicate", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var reservation = await _usageService.ReserveEventIngestAsync(
+            organization,
+            project,
+            "duplicate-complete",
+            [new EventIngestCandidate(0, 0), new EventIngestCandidate(1, 1)],
+            TestCancellationToken);
+
+        await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 2);
+        await _usageService.CompleteEventIngestReservationAsync(reservation, organization, 2);
+
+        Assert.Equal(2, (await _usageService.GetUsageAsync(organization.Id, project.Id)).CurrentUsage.Total);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_TamperedIdentity_FailsClosed()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Identity", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Identity", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "identity", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        var tampered = reservation with { ProjectId = "000000000000000000000099" };
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.CompleteEventIngestReservationAsync(tampered, organization, 1));
+        await _usageService.ReleaseEventIngestReservationAsync(reservation);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_MalformedReservedCounter_FailsClosed()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Corrupt", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Corrupt", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "corrupt", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        await GetService<ICacheClient>().SetAsync($"usage:reserved:{{{organization.Id}}}:{reservation.UsagePeriod}:total", "invalid", TimeSpan.FromDays(1));
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => _usageService.CompleteEventIngestReservationAsync(reservation, organization, 1));
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ConcurrentProjects_DoNotExceedOrganizationCap()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Shared", MaxEventsPerMonth = 10, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var firstProject = await _projectRepository.AddAsync(new Project { Name = "First", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var secondProject = await _projectRepository.AddAsync(new Project { Name = "Second", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 10).Select(index => new EventIngestCandidate(index, (ulong)index)).ToArray();
+
+        var reservations = await Task.WhenAll(
+            _usageService.ReserveEventIngestAsync(organization, firstProject, "shared-first", candidates, TestCancellationToken),
+            _usageService.ReserveEventIngestAsync(organization, secondProject, "shared-second", candidates, TestCancellationToken));
+
+        Assert.Equal(10, reservations.Sum(reservation => reservation.ReservedCount));
+        await Task.WhenAll(reservations.Select(_usageService.ReleaseEventIngestReservationAsync));
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_ActiveSmartThrottleReplay_RestoresState()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Throttle Replay", MaxEventsPerMonth = 1_000_000, PlanId = _plans.ExtraLargePlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Noisy", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "Quiet", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        await _projectRepository.AddAsync(new Project { Name = "Other", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var candidates = Enumerable.Range(0, 2000).Select(index => new EventIngestCandidate(index, (ulong)index * 7919UL)).ToArray();
+        var reservation = await _usageService.ReserveEventIngestAsync(organization, project, "throttle-replay", candidates, TestCancellationToken);
+        int bucket = TimeProvider.GetUtcNow().UtcDateTime.Floor(TimeSpan.FromMinutes(5)).ToEpoch();
+        await GetService<ICacheClient>().RemoveAsync($"usage:{bucket}:{organization.Id}:{project.Id}:smart-throttle");
+
+        await _usageService.ReserveEventIngestAsync(organization, project, "throttle-replay", candidates, TestCancellationToken);
+
+        Assert.True(await _usageService.IsProjectSmartThrottledAsync(organization.Id, project.Id));
+        await _usageService.ReleaseEventIngestReservationAsync(reservation);
+    }
+
+    [Fact]
+    public async Task ReserveEventIngestAsync_AtomicCommitFails_LeavesNoPartialReservation()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Reserve CAS", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Reserve CAS", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var cache = GetService<ICacheClient>();
+        var atomicBatch = new ControllableAtomicCacheBatch(cache) { FailNext = true };
+        var usageService = CreateUsageService(atomicBatch);
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => usageService.ReserveEventIngestAsync(
+            organization,
+            project,
+            "reserve-cas",
+            [new EventIngestCandidate(0, 0)],
+            TestCancellationToken));
+
+        Assert.False((await cache.GetAsync<string>($"usage:ingest-reservation:{{{organization.Id}}}:reserve-cas")).HasValue);
+        Assert.False((await cache.GetAsync<string>($"usage:reserved:{{{organization.Id}}}:{TimeProvider.GetUtcNow().UtcDateTime.StartOfMonth().ToEpoch()}:total")).HasValue);
+    }
+
+    [Fact]
+    public async Task CompleteEventIngestReservationAsync_AtomicCommitFails_PreservesActiveCapacity()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Complete CAS", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Complete CAS",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 1 }
+        }, o => o.ImmediateConsistency().Cache());
+        var atomicBatch = new ControllableAtomicCacheBatch(GetService<ICacheClient>());
+        var usageService = CreateUsageService(atomicBatch);
+        var reservation = await usageService.ReserveEventIngestAsync(organization, project, "complete-cas", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        atomicBatch.FailNext = true;
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => usageService.CompleteEventIngestReservationAsync(reservation, organization, 1));
+
+        var competing = await usageService.ReserveEventIngestAsync(organization, project, "complete-cas-competing", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        Assert.Equal(0, competing.ReservedCount);
+        await usageService.CompleteEventIngestReservationAsync(competing, organization, 0);
+        await usageService.ReleaseEventIngestReservationAsync(reservation);
+    }
+
+    [Fact]
+    public async Task ReleaseEventIngestReservationAsync_AtomicCommitFails_PreservesActiveCapacity()
+    {
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Release CAS", MaxEventsPerMonth = 100, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project
+        {
+            Name = "Release CAS",
+            OrganizationId = organization.Id,
+            NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks,
+            IngestLimit = new ProjectIngestLimit { Type = ProjectIngestLimitType.Fixed, FixedLimit = 1 }
+        }, o => o.ImmediateConsistency().Cache());
+        var atomicBatch = new ControllableAtomicCacheBatch(GetService<ICacheClient>());
+        var usageService = CreateUsageService(atomicBatch);
+        var reservation = await usageService.ReserveEventIngestAsync(organization, project, "release-cas", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        atomicBatch.FailNext = true;
+
+        await Assert.ThrowsAsync<UsageServiceException>(() => usageService.ReleaseEventIngestReservationAsync(reservation));
+
+        var competing = await usageService.ReserveEventIngestAsync(organization, project, "release-cas-competing", [new EventIngestCandidate(0, 0)], TestCancellationToken);
+        Assert.Equal(0, competing.ReservedCount);
+        await usageService.CompleteEventIngestReservationAsync(competing, organization, 0);
+        await usageService.ReleaseEventIngestReservationAsync(reservation);
+    }
+
+    private UsageService CreateUsageService(IAtomicCacheBatch atomicCacheBatch) => new(
+        _organizationRepository,
+        _projectRepository,
+        GetService<ICacheClient>(),
+        GetService<ILockProvider>(),
+        atomicCacheBatch,
+        GetService<IMessagePublisher>(),
+        _notificationService,
+        GetService<AppOptions>(),
+        TimeProvider,
+        Log);
+
+    private sealed class ControllableAtomicCacheBatch(ICacheClient cacheClient) : IAtomicCacheBatch
+    {
+        private readonly InMemoryAtomicCacheBatch _inner = new(cacheClient);
+
+        public bool FailNext { get; set; }
+
+        public Task<bool> TrySetAllAsync(IReadOnlyDictionary<string, string?> expectedValues, IReadOnlyDictionary<string, AtomicCacheValue> values,
+            IReadOnlyDictionary<string, string>? listValues = null, TimeSpan? listExpiresIn = null)
+        {
+            if (FailNext)
+            {
+                FailNext = false;
+                return Task.FromResult(false);
+            }
+
+            return _inner.TrySetAllAsync(expectedValues, values, listValues, listExpiresIn);
+        }
+    }
+}
diff --git a/tests/Exceptionless.Tests/Services/UsageServiceTests.cs b/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
index f6857ba13c..ac5db0f141 100644
--- a/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
+++ b/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
@@ -18,7 +18,7 @@
 
 namespace Exceptionless.Tests.Services;
 
-public sealed class UsageServiceTests : IntegrationTestsBase
+public sealed partial class UsageServiceTests : IntegrationTestsBase
 {
     private readonly IOrganizationRepository _organizationRepository;
     private readonly IProjectRepository _projectRepository;
@@ -375,8 +375,11 @@ public async Task SavePendingUsageAsync_AssistantSaveFails_RetainsUsageForRetry(
             repository.Object,
             _projectRepository,
             GetService<ICacheClient>(),
+            GetService<Foundatio.Lock.ILockProvider>(),
+            GetService<IAtomicCacheBatch>(),
             GetService<IMessagePublisher>(),
             _notificationService,
+            GetService<Exceptionless.Core.AppOptions>(),
             TimeProvider,
             GetService<ILoggerFactory>());
         await usageService.RecordAssistantUsageAsync(organization.Id, new AssistantUsageIncrement
@@ -588,8 +591,11 @@ public async Task IncrementTotalAsync_WhenHourlyOveragePublicationFails_RetriesD
             _organizationRepository,
             _projectRepository,
             cache,
+            GetService<Foundatio.Lock.ILockProvider>(),
+            GetService<IAtomicCacheBatch>(),
             publisher,
             _notificationService,
+            GetService<Exceptionless.Core.AppOptions>(),
             TimeProvider,
             GetService<ILoggerFactory>());
         var published = new AsyncCountdownEvent(1);
diff --git a/tests/Exceptionless.Tests/Validation/ProjectValidatorTests.cs b/tests/Exceptionless.Tests/Validation/ProjectValidatorTests.cs
index 9c5df0271c..2989a571ce 100644
--- a/tests/Exceptionless.Tests/Validation/ProjectValidatorTests.cs
+++ b/tests/Exceptionless.Tests/Validation/ProjectValidatorTests.cs
@@ -135,6 +135,24 @@ public async Task Validate_WhenProjectIsValid_ReturnsSuccess()
         Assert.True(isValid);
     }
 
+    [Theory]
+    [InlineData("0.0001", true)]
+    [InlineData("8.3", true)]
+    [InlineData("0.00001", false)]
+    public async Task Validate_PercentageIngestLimit_UsesBoundedPrecision(string value, bool expectedValid)
+    {
+        var project = CreateValidProject();
+        project.IngestLimit = new ProjectIngestLimit
+        {
+            Type = ProjectIngestLimitType.PercentOfOrganizationLimit,
+            PercentOfOrganizationLimit = Decimal.Parse(value, System.Globalization.CultureInfo.InvariantCulture)
+        };
+
+        var (isValid, _) = await _validator.ValidateAsync(project);
+
+        Assert.Equal(expectedValid, isValid);
+    }
+
     [Fact]
     public async Task ValidateAsync_WhenProjectIsValid_ReturnsSuccess()
     {
diff --git a/tests/http/organizations.http b/tests/http/organizations.http
index f99aea39d3..545a55a218 100644
--- a/tests/http/organizations.http
+++ b/tests/http/organizations.http
@@ -46,6 +46,20 @@ Content-Type: application/json
 
 { "plan_id": "EX_FREE" }
 
+### Enable Budget Alerts
+PATCH {{apiUrl}}/organizations/{{organizationId}}
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "budget_alert_settings": { "enabled": true, "thresholds": [50, 80, 90] } }
+
+### Clear Budget Alert Settings
+PATCH {{apiUrl}}/organizations/{{organizationId}}
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "budget_alert_settings": null }
+
 ### Delete the sample organization
 DELETE {{apiUrl}}/organizations/{{organizationId}}
 Authorization: Bearer {{token}}
diff --git a/tests/http/projects.http b/tests/http/projects.http
index 8c8e5a02e2..17550b03f5 100644
--- a/tests/http/projects.http
+++ b/tests/http/projects.http
@@ -62,6 +62,27 @@ Authorization: Bearer {{token}}
 POST {{apiUrl}}/projects/{{projectId}}/reset-data
 Authorization: Bearer {{token}}
 
+### Set Fixed Project Event Budget
+PATCH {{apiUrl}}/projects/{{projectId}}
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "ingest_limit": { "type": 0, "fixed_limit": 20000 } }
+
+### Set Percentage Project Event Budget
+PATCH {{apiUrl}}/projects/{{projectId}}
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "ingest_limit": { "type": 1, "percent_of_organization_limit": 50 } }
+
+### Clear Project Event Budget
+PATCH {{apiUrl}}/projects/{{projectId}}
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "ingest_limit": null }
+
 ### Delete the sample project
 DELETE {{apiUrl}}/projects/{{projectId}}
 Authorization: Bearer {{token}}