diff --git a/.gitignore b/.gitignore
index 5cd0861747..9c8213d1bc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -84,3 +84,4 @@ debug-storybook.log
 .devcontainer/devcontainer-lock.json
 
 *.lscache
+.gstack/
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..9f066398bf
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/design.md
@@ -0,0 +1,887 @@
+# 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 smart-throttling windows remaining in the period.
+* `burstMultiplier` preserves existing burst tolerance behavior. A default value such as 10 is acceptable if it matches existing Exceptionless throttle behavior.
+* The evaluation window should align with existing usage bucket behavior where possible.
+
+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 = 1% to 5%
+```
+
+Implementation may use a fixed default such as 1% or 5% for v1, as long as behavior is deterministic/testable and does not expose many configuration options.
+
+Sampling goals:
+
+* Preserve visibility into whether the problem is still occurring.
+* Preserve visibility into whether a deployed fix reduced occurrences.
+* Avoid accepting 0 events from a throttled project while the organization still has monthly allowance.
+* 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-smart-throttle:{yyyyMM}:{organizationId}:{projectId}
+```
+
+Suggested value:
+
+```json
+{
+  "is_throttled": true,
+  "sample_rate": 0.01,
+  "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.
+
+### 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 accepted usage, current limit context, and a link to project usage.
+
+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; }
+```
+
+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.
+
+### 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 should be set before or atomically with enqueueing the work item to reduce 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(
+    string organizationId,
+    string projectId,
+    int submittedEventCount);
+```
+
+Behavior:
+
+* Compute organization events left using existing organization usage logic.
+* 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 current organization-only method should be refactored into a shared helper:
+
+```csharp
+private async Task<int> GetEventsLeftAsync(
+    string organizationId,
+    string? projectId,
+    int maxEventsPerMonth)
+```
+
+Use existing total and bucket cache keys with optional project id.
+
+### 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..49faea95bf
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/api-compatibility/spec.md
@@ -0,0 +1,149 @@
+# Spec: API Compatibility
+
+## MODIFIED 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.
+
+## ADDED Requirements
+
+### Requirement: Organization API exposes budget alert settings
+
+The organization API may expose and update 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.
+
+## ADDED Requirements
+
+### 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.
+
+## ADDED Requirements
+
+### Requirement: Project API accepts event budget configuration
+
+The project update API may 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.
+
+## ADDED Requirements
+
+### 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.
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..62a5b3d36e
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/event-ingestion/spec.md
@@ -0,0 +1,329 @@
+# 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.
+
+## ADDED Requirements
+
+### 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.
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..ed43f44397
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/jobs-notifications-and-queues/spec.md
@@ -0,0 +1,180 @@
+# Spec: Jobs, Notifications & Queues
+
+## ADDED Requirements
+
+### Requirement: Organizations may configure budget alert thresholds
+
+Organizations may 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 may generate at most 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.
+
+## ADDED Requirements
+
+### 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.
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..18c006aa47
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/specs/organizations-projects-users-auth/spec.md
@@ -0,0 +1,115 @@
+# Spec: Organizations, Projects, Users & Auth
+
+## ADDED Requirements
+
+### Requirement: Budget alert settings belong to an organization
+
+Budget alert settings belong to an organization and may be changed 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.
+
+## ADDED Requirements
+
+### 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.
+
+## ADDED Requirements
+
+### 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. Only users authorized to update the project may configure its event budget.
+
+#### 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.
+
+## ADDED Requirements
+
+### 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.
+
+## ADDED Requirements
+
+### 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..340fea6fc2
--- /dev/null
+++ b/openspec/changes/add-usage-budget-controls/tasks.md
@@ -0,0 +1,356 @@
+# Tasks: Add Usage Budget Controls
+
+## OpenSpec
+
+* Task 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
+
+* Task 2: Add organization budget alert settings model
+    * Add OrganizationBudgetAlertSettings.
+    * Add nullable BudgetAlertSettings to Organization.
+    * Add validation for enabled settings and percentage thresholds.
+    * Verification:
+        * dotnet build
+        * Add model/validation tests if existing model validation tests are available.
+* Task 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
+* Task 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.
+* Task 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
+* Task 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.
+    * Verification:
+        * dotnet build
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+
+## Organization budget alert emails
+
+* Task 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
+* Task 8: Publish budget alert messages when thresholds are crossed
+    * Add OrganizationBudgetAlert message.
+    * In UsageService.IncrementTotalAsync, detect threshold crossings after accepted event usage increments.
+    * 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
+* Task 9: Add budget alert dedupe
+    * Add dedupe key per organization, threshold, and monthly usage period.
+    * 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
+* Task 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.
+    * Verification:
+        * dotnet test -- --filter-class OrganizationBudgetAlertWorkItemHandlerTests
+        * If no dedicated handler test class exists, add one.
+* Task 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
+
+* Task 12: Add smart throughput calculation
+    * Calculate allowed throughput from events left in the monthly period and time/windows left in the period.
+    * Preserve existing burst tolerance behavior where appropriate.
+    * 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
+* Task 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.
+    * Verification:
+        * Tests where Project A spikes and Project B remains unaffected.
+        * Tests where multiple projects are evaluated independently.
+        * dotnet test -- --filter-class UsageServiceTests
+* Task 14: Add sampled acceptance for smart-throttled projects
+    * Implement 1–5% sampled acceptance when project is smart-throttled and organization has remaining allowance.
+    * Prefer deterministic/testable sampling.
+    * Record blocked usage for non-sampled events.
+    * 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
+* Task 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
+* Task 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.
+    * Verification:
+        * dotnet test -- --filter-class ProjectSmartThrottleNotificationWorkItemHandlerTests
+        * dotnet build
+
+## Optional project event budgets
+
+* Task 17: Refactor UsageService events-left calculation
+    * Extract organization-only events-left logic into a helper that accepts optional projectId.
+    * Reuse 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
+* Task 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
+* Task 19: Add parsed-event ingest allowance result
+    * Add EventIngestAllowanceResult.
+    * Add UsageService.GetEventIngestAllowanceAsync(string organizationId, string projectId, int submittedEventCount) or equivalent.
+    * 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
+
+* Task 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
+* Task 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 accepted usage only for processed events.
+    * Verification:
+        * dotnet test -- --filter-class EventPostsJobTests
+
+## Backend API tests
+
+* Task 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
+* Task 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
+* Task 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
+* Task 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
+
+* Task 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.
+    * 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.
+* Task 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.
+    * Verification:
+        * cd src/Exceptionless.Web/ClientApp && npm ci && npm run check
+        * cd src/Exceptionless.Web/ClientApp && npm run lint
+* Task 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.
+* Task 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
+* Task 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.
+* Task 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
+
+* Task 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
+* Task 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.
+* Task 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.
+* Task 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.
+* Task 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
+
+* Task 37: Run targeted validation
+    * 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
+* Task 38: Run OpenSpec validation
+    * Command:
+        * openspec validate add-usage-budget-controls --strict --no-interactive
+* Task 39: Optional full validation before merge
+    * Commands:
+        * dotnet test
+        * cd src/Exceptionless.Web/ClientApp && npm run build
+        * openspec validate --all --strict --no-interactive
diff --git a/src/Exceptionless.Core/Bootstrapper.cs b/src/Exceptionless.Core/Bootstrapper.cs
index 334f2b07ae..29f2053809 100644
--- a/src/Exceptionless.Core/Bootstrapper.cs
+++ b/src/Exceptionless.Core/Bootstrapper.cs
@@ -109,6 +109,8 @@ public static void RegisterServices(IServiceCollection services, AppOptions appO
             handlers.Register<FixStackStatsWorkItem>(s.GetRequiredService<FixStackStatsWorkItemHandler>);
             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/Exceptionless.Core.csproj b/src/Exceptionless.Core/Exceptionless.Core.csproj
index 2ee31516e5..a8f38c730c 100644
--- a/src/Exceptionless.Core/Exceptionless.Core.csproj
+++ b/src/Exceptionless.Core/Exceptionless.Core.csproj
@@ -2,20 +2,24 @@
   <ItemGroup>
     <None Remove="Mail\Templates\event-notice.html" />
     <None Remove="Mail\Templates\organization-added.html" />
+    <None Remove="Mail\Templates\organization-budget-alert.html" />
     <None Remove="Mail\Templates\organization-invited.html" />
     <None Remove="Mail\Templates\organization-notice.html" />
     <None Remove="Mail\Templates\organization-payment-failed.html" />
     <None Remove="Mail\Templates\project-daily-summary.html" />
+    <None Remove="Mail\Templates\project-smart-throttle.html" />
     <None Remove="Mail\Templates\user-email-verify.html" />
     <None Remove="Mail\Templates\user-password-reset.html" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Mail\Templates\event-notice.html" />
     <EmbeddedResource Include="Mail\Templates\organization-added.html" />
+    <EmbeddedResource Include="Mail\Templates\organization-budget-alert.html" />
     <EmbeddedResource Include="Mail\Templates\organization-invited.html" />
     <EmbeddedResource Include="Mail\Templates\organization-notice.html" />
     <EmbeddedResource Include="Mail\Templates\organization-payment-failed.html" />
     <EmbeddedResource Include="Mail\Templates\project-daily-summary.html" />
+    <EmbeddedResource Include="Mail\Templates\project-smart-throttle.html" />
     <EmbeddedResource Include="Mail\Templates\user-email-verify.html" />
     <EmbeddedResource Include="Mail\Templates\user-password-reset.html" />
   </ItemGroup>
diff --git a/src/Exceptionless.Core/Jobs/EventPostsJob.cs b/src/Exceptionless.Core/Jobs/EventPostsJob.cs
index 0f771e9b64..0995392cdf 100644
--- a/src/Exceptionless.Core/Jobs/EventPostsJob.cs
+++ b/src/Exceptionless.Core/Jobs/EventPostsJob.cs
@@ -175,6 +175,38 @@ protected override async Task<JobResult> ProcessQueueEntryAsync(QueueEntryContex
             return JobResult.Success;
         }
 
+        // Check project-specific ingest limits
+        var ingestAllowance = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+        if (ingestAllowance.EventsLeft < 1)
+        {
+            if (!isInternalProject)
+                _logger.LogDebug("Unable to process EventPost {FilePath}: Over project ingest limit", payloadPath);
+
+            await _usageService.IncrementBlockedAsync(organization.Id, project.Id, events.Count);
+            await CompleteEntryAsync(entry, ep, _timeProvider.GetUtcNow().UtcDateTime);
+            return JobResult.Success;
+        }
+
+        // Apply smart throttling: sample events from projects consuming disproportionate resources
+        var throttleResult = await _usageService.GetSmartThrottleRateAsync(organization.Id, project.Id);
+        if (throttleResult.IsThrottled)
+        {
+            int sampled = (int)Math.Max(1, Math.Ceiling(events.Count * throttleResult.SampleRate));
+            if (sampled < events.Count)
+            {
+                int discarded = events.Count - sampled;
+                // Use deterministic sampling to keep a representative sample
+                events = events.Take(sampled).ToList();
+                await _usageService.RecordSmartThrottleAsync(organization.Id, project.Id, discarded, throttleResult);
+
+                if (!isInternalProject)
+                    _logger.LogInformation("Smart throttling applied to EventPost {FilePath}: Accepted {Sampled}/{Total} events (rate={SampleRate:F2})", payloadPath, sampled, sampled + discarded, throttleResult.SampleRate);
+            }
+        }
+
+        // Use the more restrictive of org and project limits
+        eventsToProcess = Math.Min(eventsToProcess, ingestAllowance.EventsLeft);
+
         // 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;
 
diff --git a/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs b/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs
new file mode 100644
index 0000000000..505da28dc5
--- /dev/null
+++ b/src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationBudgetAlertWorkItemHandler.cs
@@ -0,0 +1,99 @@
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Foundatio.Extensions.Hosting.Startup;
+using Foundatio.Jobs;
+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 ILogger _logger;
+
+    public EnqueueOrganizationBudgetAlertOnUsageThreshold(IQueue<WorkItemData> workItemQueue, IMessageSubscriber subscriber, ILoggerFactory loggerFactory)
+    {
+        _workItemQueue = workItemQueue;
+        _subscriber = subscriber;
+        _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
+            });
+        }, shutdownToken);
+    }
+}
+
+public class OrganizationBudgetAlertWorkItemHandler : WorkItemHandlerBase
+{
+    private readonly IOrganizationRepository _organizationRepository;
+    private readonly IUserRepository _userRepository;
+    private readonly IMailer _mailer;
+
+    public OrganizationBudgetAlertWorkItemHandler(IOrganizationRepository organizationRepository, IUserRepository userRepository, IMailer mailer, ILoggerFactory loggerFactory) : base(loggerFactory)
+    {
+        _organizationRepository = organizationRepository;
+        _userRepository = userRepository;
+        _mailer = mailer;
+    }
+
+    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);
+
+        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 } || !organization.BudgetAlertSettings.Thresholds.Contains(wi.Threshold))
+        {
+            Log.LogInformation("Budget alerts disabled or threshold {Threshold}% removed for organization: {OrganizationId}, skipping", wi.Threshold, wi.OrganizationId);
+            return;
+        }
+
+        var results = await _userRepository.GetByOrganizationIdAsync(organization.Id);
+        foreach (var user in results.Documents)
+        {
+            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;
+            }
+
+            Log.LogTrace("Sending budget alert email to {EmailAddress}...", user.EmailAddress);
+            await _mailer.SendOrganizationBudgetAlertAsync(user, organization, wi.Threshold, wi.ThresholdEventCount, wi.CurrentEventCount, wi.EventLimit);
+        }
+
+        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..f9f70b0322
--- /dev/null
+++ b/src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectSmartThrottleWorkItemHandler.cs
@@ -0,0 +1,101 @@
+using Exceptionless.Core.Mail;
+using Exceptionless.Core.Messaging.Models;
+using Exceptionless.Core.Models;
+using Exceptionless.Core.Models.WorkItems;
+using Exceptionless.Core.Repositories;
+using Foundatio.Extensions.Hosting.Startup;
+using Foundatio.Jobs;
+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 ILogger _logger;
+
+    public EnqueueProjectSmartThrottleOnThrottleApplied(IQueue<WorkItemData> workItemQueue, IMessageSubscriber subscriber, ILoggerFactory loggerFactory)
+    {
+        _workItemQueue = workItemQueue;
+        _subscriber = subscriber;
+        _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
+            });
+        }, shutdownToken);
+    }
+}
+
+public class ProjectSmartThrottleWorkItemHandler : WorkItemHandlerBase
+{
+    private readonly IOrganizationRepository _organizationRepository;
+    private readonly IProjectRepository _projectRepository;
+    private readonly IUserRepository _userRepository;
+    private readonly IMailer _mailer;
+
+    public ProjectSmartThrottleWorkItemHandler(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IUserRepository userRepository, IMailer mailer, ILoggerFactory loggerFactory) : base(loggerFactory)
+    {
+        _organizationRepository = organizationRepository;
+        _projectRepository = projectRepository;
+        _userRepository = userRepository;
+        _mailer = mailer;
+    }
+
+    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);
+
+        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;
+        }
+
+        var results = await _userRepository.GetByOrganizationIdAsync(organization.Id);
+        foreach (var user in results.Documents)
+        {
+            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;
+            }
+
+            Log.LogTrace("Sending smart throttle email to {EmailAddress}...", user.EmailAddress);
+            await _mailer.SendProjectThrottledNoticeAsync(user, organization, project, wi.SampleRate, wi.CurrentEventCount, wi.EventLimit);
+        }
+
+        Log.LogTrace("Done sending smart throttle emails");
+    }
+}
diff --git a/src/Exceptionless.Core/Mail/IMailer.cs b/src/Exceptionless.Core/Mail/IMailer.cs
index 79b3b7f39e..dc98c759ee 100644
--- a/src/Exceptionless.Core/Mail/IMailer.cs
+++ b/src/Exceptionless.Core/Mail/IMailer.cs
@@ -10,6 +10,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 b6498c1d45..3d8fad6963 100644
--- a/src/Exceptionless.Core/Mail/Mailer.cs
+++ b/src/Exceptionless.Core/Mail/Mailer.cs
@@ -195,6 +195,57 @@ public Task SendOrganizationPaymentFailedAsync(User owner, Organization organiza
         }, template);
     }
 
+    public 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 data = new Dictionary<string, object?> {
+                { "Subject", subject },
+                { "BaseUrl", _appOptions.BaseURL },
+                { "OrganizationId", organization.Id },
+                { "OrganizationName", organization.Name },
+                { "Threshold", threshold },
+                { "ThresholdEventCount", thresholdEventCount },
+                { "CurrentEventCount", currentEventCount },
+                { "EventLimit", eventLimit },
+                { "RemainingEventCount", Math.Max(0, eventLimit - currentEventCount) }
+            };
+
+        return QueueMessageAsync(new MailMessage
+        {
+            To = user.EmailAddress,
+            Subject = subject,
+            Body = RenderTemplate(template, data)
+        }, template);
+    }
+
+    public 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 data = new Dictionary<string, object?> {
+                { "Subject", subject },
+                { "BaseUrl", _appOptions.BaseURL },
+                { "OrganizationId", organization.Id },
+                { "OrganizationName", organization.Name },
+                { "ProjectId", project.Id },
+                { "ProjectName", project.Name },
+                { "SampleRate", sampleRate },
+                { "SamplePercent", (int)(sampleRate * 100) },
+                { "CurrentEventCount", currentEventCount },
+                { "EventLimit", eventLimit }
+            };
+
+        return QueueMessageAsync(new MailMessage
+        {
+            To = user.EmailAddress,
+            Subject = subject,
+            Body = RenderTemplate(template, data)
+        }, template);
+    }
+
     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)
     {
         const string template = "project-daily-summary";
diff --git a/src/Exceptionless.Core/Mail/Templates/organization-budget-alert.html b/src/Exceptionless.Core/Mail/Templates/organization-budget-alert.html
new file mode 100644
index 0000000000..ca434d0f8b
--- /dev/null
+++ b/src/Exceptionless.Core/Mail/Templates/organization-budget-alert.html
@@ -0,0 +1 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en" style="background:#f7f7f7!important"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><meta name="viewport" content="width=device-width"><title>{{Subject}}</title><style>@media only screen{html{min-height:100%;background:#f7f7f7}}@media only screen and (max-width:596px){table.body img{width:auto;height:auto}table.body center{min-width:0!important}table.body .container{width:95%!important}table.body .columns{height:auto!important;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;padding-left:16px!important;padding-right:16px!important}th.small-12{display:inline-block!important;width:100%!important}}</style></head><body style="-moz-box-sizing:border-box;-ms-text-size-adjust:100%;-webkit-box-sizing:border-box;-webkit-text-size-adjust:100%;Margin:0;background:#f7f7f7!important;box-sizing:border-box;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;min-width:100%;padding:0;text-align:left;width:100%!important"><span class="preheader" style="color:#f7f7f7;display:none!important;font-size:1px;line-height:1px;max-height:0;max-width:0;mso-hide:all!important;opacity:0;overflow:hidden;visibility:hidden"></span><table class="body" style="Margin:0;background:#f7f7f7!important;border-collapse:collapse;border-spacing:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;height:100%;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="center" align="center" valign="top" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><center data-parsed style="min-width:580px;width:100%"><table align="center" class="wrapper header float-center" style="Margin:0 auto;background:#2c2c2c;border-collapse:collapse;border-spacing:0;float:none;margin:0 auto;padding:0;text-align:center;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="wrapper-inner" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:8px 15px;text-align:left;vertical-align:top;word-wrap:break-word"><table align="center" class="container" style="Margin:0 auto;background:0 0;border-collapse:collapse;border-spacing:0;margin:0 auto;padding:0;text-align:inherit;vertical-align:top;width:580px"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><img src="https://be.exceptionless.io/img/exceptionless-logo.png" alt="Exceptionless" style="-ms-interpolation-mode:bicubic;clear:both;display:block;margin-left:15px;max-width:100%;outline:0;text-decoration:none;width:auto"></td></tr></tbody></table></td></tr></table><table align="center" class="container float-center" style="Margin:0 auto;background:#f7f7f7;border-collapse:collapse;border-spacing:0;float:none;margin:0 auto;padding:0;text-align:center;vertical-align:top;width:580px"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table class="spacer" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td height="5px" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:5px;font-weight:400;hyphens:auto;line-height:5px;margin:0;mso-line-height-rule:exactly;padding:0;text-align:left;vertical-align:top;word-wrap:break-word">&#xA0;</td></tr></tbody></table><table class="row" style="border-collapse:collapse;border-spacing:0;display:table;padding:0;position:relative;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><th class="small-12 large-12 columns first last" style="Margin:0 auto;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0 auto;padding:0;padding-bottom:16px;padding-left:16px;padding-right:16px;text-align:left;width:564px"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><th style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left"><p class="lead" style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:20px;font-weight:400;line-height:1.6;margin:0;margin-bottom:10px;padding:0;text-align:left"><strong>{{OrganizationName}}</strong> has used <strong>{{Threshold}}%</strong> of its monthly event allowance ({{CurrentEventCount}} of {{EventLimit}} events).</p><p style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;margin-bottom:10px;padding:0;text-align:left">You have <strong>{{RemainingEventCount}}</strong> events remaining this billing period. Consider upgrading your plan or adjusting your event volume to avoid service interruption.</p><center data-parsed style="min-width:532px;width:100%"><table class="button button radius float-center" style="Margin:0 0 16px 0;border-collapse:collapse;border-spacing:0;float:none;margin:0 0 16px 0;padding:0;text-align:center;vertical-align:top;width:auto"><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;background:#5E9A00;border:none;border-collapse:collapse!important;border-radius:3px;color:#fefefe;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><a href="{{BaseUrl}}/organization/{{OrganizationId}}/manage" style="Margin:0;border:0 solid #5E9A00;border-radius:3px;color:#fefefe;display:inline-block;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:700;line-height:1.3;margin:0;padding:8px 16px 8px 16px;text-align:left;text-decoration:none">View Usage</a></td></tr></table></td></tr></table></center><table class="spacer" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td height="5px" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:5px;font-weight:400;hyphens:auto;line-height:5px;margin:0;mso-line-height-rule:exactly;padding:0;text-align:left;vertical-align:top;word-wrap:break-word">&#xA0;</td></tr></tbody></table><p style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;margin-bottom:10px;padding:0;text-align:left">You can also view the <a href="{{BaseUrl}}/organization/{{OrganizationId}}/frequent" style="Margin:0;color:#5E9A00;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">most frequent events</a> to see which events are counting against your plan limits.</p></th><th class="expander" style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0!important;text-align:left;visibility:hidden;width:0"></th></tr></table></th></tr></tbody></table><table class="wrapper actions" align="center" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="wrapper-inner" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table class="row" style="border-collapse:collapse;border-spacing:0;display:table;padding:0;position:relative;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><th class="small-12 large-12 columns first last" style="Margin:0 auto;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0 auto;padding:0;padding-bottom:16px;padding-left:16px;padding-right:16px;text-align:left;width:564px"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><th style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left"><h5 style="Margin:0;Margin-bottom:10px;color:#939393;font-family:Helvetica,Arial,sans-serif;font-size:20px;font-weight:400;line-height:1.3;margin:0;margin-bottom:5px;margin-top:0;padding:0;text-align:left;word-wrap:normal">Other Actions</h5><ul style="margin-top:0"><li style="margin-left:5px;margin-top:5px"><a href="{{BaseUrl}}/organization/{{OrganizationId}}/upgrade" style="Margin:0;color:#6EBC1A;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">Upgrade plan</a></li><li style="margin-left:5px;margin-top:5px"><a href="{{BaseUrl}}/account/manage?tab=notifications" style="Margin:0;color:#6EBC1A;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">Change your notification settings</a></li></ul></th><th class="expander" style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0!important;text-align:left;visibility:hidden;width:0"></th></tr></table></th></tr></tbody></table></td></tr></table></td></tr></tbody></table></center></td></tr></table></body></html>
diff --git a/src/Exceptionless.Core/Mail/Templates/project-smart-throttle.html b/src/Exceptionless.Core/Mail/Templates/project-smart-throttle.html
new file mode 100644
index 0000000000..618deb72da
--- /dev/null
+++ b/src/Exceptionless.Core/Mail/Templates/project-smart-throttle.html
@@ -0,0 +1 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en" style="background:#f7f7f7!important"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><meta name="viewport" content="width=device-width"><title>{{Subject}}</title><style>@media only screen{html{min-height:100%;background:#f7f7f7}}@media only screen and (max-width:596px){table.body img{width:auto;height:auto}table.body center{min-width:0!important}table.body .container{width:95%!important}table.body .columns{height:auto!important;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;padding-left:16px!important;padding-right:16px!important}th.small-12{display:inline-block!important;width:100%!important}}</style></head><body style="-moz-box-sizing:border-box;-ms-text-size-adjust:100%;-webkit-box-sizing:border-box;-webkit-text-size-adjust:100%;Margin:0;background:#f7f7f7!important;box-sizing:border-box;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;min-width:100%;padding:0;text-align:left;width:100%!important"><span class="preheader" style="color:#f7f7f7;display:none!important;font-size:1px;line-height:1px;max-height:0;max-width:0;mso-hide:all!important;opacity:0;overflow:hidden;visibility:hidden"></span><table class="body" style="Margin:0;background:#f7f7f7!important;border-collapse:collapse;border-spacing:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;height:100%;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="center" align="center" valign="top" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><center data-parsed style="min-width:580px;width:100%"><table align="center" class="wrapper header float-center" style="Margin:0 auto;background:#2c2c2c;border-collapse:collapse;border-spacing:0;float:none;margin:0 auto;padding:0;text-align:center;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="wrapper-inner" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:8px 15px;text-align:left;vertical-align:top;word-wrap:break-word"><table align="center" class="container" style="Margin:0 auto;background:0 0;border-collapse:collapse;border-spacing:0;margin:0 auto;padding:0;text-align:inherit;vertical-align:top;width:580px"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><img src="https://be.exceptionless.io/img/exceptionless-logo.png" alt="Exceptionless" style="-ms-interpolation-mode:bicubic;clear:both;display:block;margin-left:15px;max-width:100%;outline:0;text-decoration:none;width:auto"></td></tr></tbody></table></td></tr></table><table align="center" class="container float-center" style="Margin:0 auto;background:#f7f7f7;border-collapse:collapse;border-spacing:0;float:none;margin:0 auto;padding:0;text-align:center;vertical-align:top;width:580px"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table class="spacer" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td height="5px" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:5px;font-weight:400;hyphens:auto;line-height:5px;margin:0;mso-line-height-rule:exactly;padding:0;text-align:left;vertical-align:top;word-wrap:break-word">&#xA0;</td></tr></tbody></table><table class="row" style="border-collapse:collapse;border-spacing:0;display:table;padding:0;position:relative;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><th class="small-12 large-12 columns first last" style="Margin:0 auto;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0 auto;padding:0;padding-bottom:16px;padding-left:16px;padding-right:16px;text-align:left;width:564px"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><th style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left"><p class="lead" style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:20px;font-weight:400;line-height:1.6;margin:0;margin-bottom:10px;padding:0;text-align:left">Smart throttling has been activated for <strong>{{ProjectName}}</strong> in <strong>{{OrganizationName}}</strong>.</p><p style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;margin-bottom:10px;padding:0;text-align:left">Your organization has used {{CurrentEventCount}} of {{EventLimit}} events this billing period. To protect your remaining budget, events from this project are now being sampled at <strong>{{SamplePercent}}%</strong>. This means approximately {{SamplePercent}}% of incoming events will be accepted while the rest are discarded.</p><p style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;margin-bottom:10px;padding:0;text-align:left">Throttling will automatically adjust as your usage changes. To stop throttling, you can upgrade your plan or reduce event volume.</p><center data-parsed style="min-width:532px;width:100%"><table class="button button radius float-center" style="Margin:0 0 16px 0;border-collapse:collapse;border-spacing:0;float:none;margin:0 0 16px 0;padding:0;text-align:center;vertical-align:top;width:auto"><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;background:#5E9A00;border:none;border-collapse:collapse!important;border-radius:3px;color:#fefefe;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><a href="{{BaseUrl}}/organization/{{OrganizationId}}/manage" style="Margin:0;border:0 solid #5E9A00;border-radius:3px;color:#fefefe;display:inline-block;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:700;line-height:1.3;margin:0;padding:8px 16px 8px 16px;text-align:left;text-decoration:none">View Usage</a></td></tr></table></td></tr></table></center><table class="spacer" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><td height="5px" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:5px;font-weight:400;hyphens:auto;line-height:5px;margin:0;mso-line-height-rule:exactly;padding:0;text-align:left;vertical-align:top;word-wrap:break-word">&#xA0;</td></tr></tbody></table><p style="Margin:0;Margin-bottom:10px;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;margin-bottom:10px;padding:0;text-align:left">You can also view the <a href="{{BaseUrl}}/organization/{{OrganizationId}}/frequent" style="Margin:0;color:#5E9A00;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">most frequent events</a> to see which events are counting against your plan limits.</p></th><th class="expander" style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0!important;text-align:left;visibility:hidden;width:0"></th></tr></table></th></tr></tbody></table><table class="wrapper actions" align="center" style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><td class="wrapper-inner" style="-moz-hyphens:auto;-webkit-hyphens:auto;Margin:0;border-collapse:collapse!important;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;hyphens:auto;line-height:1.3;margin:0;padding:0;text-align:left;vertical-align:top;word-wrap:break-word"><table class="row" style="border-collapse:collapse;border-spacing:0;display:table;padding:0;position:relative;text-align:left;vertical-align:top;width:100%"><tbody><tr style="padding:0;text-align:left;vertical-align:top"><th class="small-12 large-12 columns first last" style="Margin:0 auto;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0 auto;padding:0;padding-bottom:16px;padding-left:16px;padding-right:16px;text-align:left;width:564px"><table style="border-collapse:collapse;border-spacing:0;padding:0;text-align:left;vertical-align:top;width:100%"><tr style="padding:0;text-align:left;vertical-align:top"><th style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left"><h5 style="Margin:0;Margin-bottom:10px;color:#939393;font-family:Helvetica,Arial,sans-serif;font-size:20px;font-weight:400;line-height:1.3;margin:0;margin-bottom:5px;margin-top:0;padding:0;text-align:left;word-wrap:normal">Other Actions</h5><ul style="margin-top:0"><li style="margin-left:5px;margin-top:5px"><a href="{{BaseUrl}}/organization/{{OrganizationId}}/upgrade" style="Margin:0;color:#6EBC1A;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">Upgrade plan</a></li><li style="margin-left:5px;margin-top:5px"><a href="{{BaseUrl}}/account/manage?tab=notifications" style="Margin:0;color:#6EBC1A;font-family:Helvetica,Arial,sans-serif;font-weight:400;line-height:1.3;margin:0;padding:0;text-align:left;text-decoration:none">Change your notification settings</a></li></ul></th><th class="expander" style="Margin:0;color:#2c2c2c;font-family:Helvetica,Arial,sans-serif;font-size:16px;font-weight:400;line-height:1.3;margin:0;padding:0!important;text-align:left;visibility:hidden;width:0"></th></tr></table></th></tr></tbody></table></td></tr></table></td></tr></tbody></table></center></td></tr></table></body></html>
diff --git a/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs b/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs
new file mode 100644
index 0000000000..1d6bf4219b
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Messaging/OrganizationBudgetAlert.cs
@@ -0,0 +1,10 @@
+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; }
+}
diff --git a/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs b/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs
new file mode 100644
index 0000000000..b3e9ca7c2c
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Messaging/ProjectSmartThrottleApplied.cs
@@ -0,0 +1,10 @@
+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; }
+}
diff --git a/src/Exceptionless.Core/Models/Organization.cs b/src/Exceptionless.Core/Models/Organization.cs
index 27b9e3c937..b7cf6e12ef 100644
--- a/src/Exceptionless.Core/Models/Organization.cs
+++ b/src/Exceptionless.Core/Models/Organization.cs
@@ -171,6 +171,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; }
@@ -265,6 +270,19 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
                     [nameof(SuspendedByUserId)]);
             }
         }
+
+        if (BudgetAlertSettings is { Enabled: true })
+        {
+            if (BudgetAlertSettings.Thresholds.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))
+                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 0e5f223072..7215e2dbd3 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.
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..6a11ee2b45
--- /dev/null
+++ b/src/Exceptionless.Core/Models/WorkItems/OrganizationBudgetAlertWorkItem.cs
@@ -0,0 +1,14 @@
+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 string UniqueIdentifier => $"BudgetAlert:{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..d9a6014603
--- /dev/null
+++ b/src/Exceptionless.Core/Models/WorkItems/ProjectSmartThrottleWorkItem.cs
@@ -0,0 +1,14 @@
+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 string UniqueIdentifier => $"SmartThrottle:{OrganizationId}:{ProjectId}";
+}
diff --git a/src/Exceptionless.Core/Services/UsageService.cs b/src/Exceptionless.Core/Services/UsageService.cs
index 4a12491675..f42c2ef5b6 100644
--- a/src/Exceptionless.Core/Services/UsageService.cs
+++ b/src/Exceptionless.Core/Services/UsageService.cs
@@ -444,6 +444,19 @@ public async Task IncrementTotalAsync(string organizationId, string projectId, i
             long monthTotal = currentTotalCache.Value + bucketTotal;
             if (monthTotal >= maxEventsPerMonth && monthTotal - maxEventsPerMonth < eventCount)
                 await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = organizationId });
+
+            // Check budget alert thresholds — non-fatal: alert failures must not break event ingestion
+            if (maxEventsPerMonth > 0)
+            {
+                try
+                {
+                    await CheckBudgetAlertThresholdsAsync(organizationId, (int)monthTotal, maxEventsPerMonth);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Failed to check budget alert thresholds for organization {OrganizationId}", organizationId);
+                }
+            }
         }
 
         if (bucketTotal >= bucketLimit && bucketTotal - bucketLimit < eventCount)
@@ -454,6 +467,179 @@ public async Task IncrementTotalAsync(string organizationId, string projectId, i
         }
     }
 
+    /// <summary>
+    /// Gets the event ingest allowance for a project, taking into account both organization limits
+    /// and project-specific ingest limits. Returns how many events can be processed and the sample rate.
+    /// </summary>
+    public async Task<EventIngestAllowance> GetEventIngestAllowanceAsync(string organizationId, string projectId)
+    {
+        int orgEventsLeft = await GetEventsLeftAsync(organizationId);
+        if (orgEventsLeft < 1)
+            return new EventIngestAllowance { EventsLeft = 0, SampleRate = 0, IsOverOrgLimit = true };
+
+        var project = await _projectRepository.GetByIdAsync(projectId, o => o.Cache());
+        if (project?.IngestLimit is null)
+            return new EventIngestAllowance { EventsLeft = orgEventsLeft, SampleRate = 1.0 };
+
+        int effectiveLimit = await GetEffectiveProjectLimitAsync(project, organizationId);
+        if (effectiveLimit < 0)
+            return new EventIngestAllowance { EventsLeft = orgEventsLeft, SampleRate = 1.0 };
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        int projectTotal = await GetProjectMonthTotalAsync(utcNow, organizationId, projectId);
+
+        if (projectTotal >= effectiveLimit)
+            return new EventIngestAllowance { EventsLeft = 0, SampleRate = 0, IsOverProjectLimit = true, EffectiveProjectLimit = effectiveLimit };
+
+        int projectEventsLeft = effectiveLimit - projectTotal;
+        int eventsLeft = Math.Min(orgEventsLeft, projectEventsLeft);
+
+        return new EventIngestAllowance { EventsLeft = eventsLeft, SampleRate = 1.0, EffectiveProjectLimit = effectiveLimit };
+    }
+
+    /// <summary>
+    /// Calculates the smart throttle sample rate for a project within the organization.
+    /// Returns 1.0 if no throttling is needed, or a value between 0 and 1 representing
+    /// the probability of accepting an event from this project.
+    /// </summary>
+    public async Task<SmartThrottleResult> GetSmartThrottleRateAsync(string organizationId, string projectId)
+    {
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+
+        int maxEventsPerMonth = await GetMaxEventsPerMonthAsync(organizationId);
+        if (maxEventsPerMonth <= 0)
+            return SmartThrottleResult.NoThrottle;
+
+        // Calculate fair share: what percentage of events has this project been using?
+        int orgTotal = await GetOrganizationMonthTotalAsync(utcNow, organizationId);
+        int projectTotal = await GetProjectMonthTotalAsync(utcNow, organizationId, projectId);
+
+        if (orgTotal <= 0 || projectTotal <= 0)
+            return SmartThrottleResult.NoThrottle;
+
+        // Only throttle when we're approaching the limit (>80%)
+        double usageRatio = (double)orgTotal / maxEventsPerMonth;
+        if (usageRatio < 0.8)
+            return SmartThrottleResult.NoThrottle;
+
+        // Get total project count for org to determine fair share
+        var projectCount = await GetOrganizationProjectCountAsync(organizationId);
+        if (projectCount <= 1)
+            return SmartThrottleResult.NoThrottle;
+
+        double fairShare = (double)maxEventsPerMonth / projectCount;
+        double projectShare = (double)projectTotal / orgTotal;
+
+        // If this project is consuming more than 2x its fair share, apply throttling
+        double fairShareRatio = projectTotal / fairShare;
+        if (fairShareRatio <= 2.0)
+            return SmartThrottleResult.NoThrottle;
+
+        // Scale sample rate: heavier consumers get more aggressive throttling
+        // At 2x fair share: rate = 0.5, at 4x: rate = 0.25, etc.
+        double sampleRate = Math.Max(0.1, 1.0 / fairShareRatio);
+
+        return new SmartThrottleResult
+        {
+            SampleRate = sampleRate,
+            IsThrottled = true,
+            ProjectShare = projectShare,
+            FairShareRatio = fairShareRatio
+        };
+    }
+
+    private async Task CheckBudgetAlertThresholdsAsync(string organizationId, int currentTotal, int maxEventsPerMonth)
+    {
+        var organization = await _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+        if (organization?.BudgetAlertSettings is not { Enabled: true })
+            return;
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        double usagePercent = (double)currentTotal / maxEventsPerMonth * 100;
+
+        foreach (int threshold in organization.BudgetAlertSettings.Thresholds)
+        {
+            if (usagePercent < threshold)
+                break;
+
+            int thresholdEventCount = (int)Math.Ceiling((double)threshold / 100 * maxEventsPerMonth);
+
+            string alertSentKey = GetBudgetAlertSentKey(utcNow, organizationId, threshold);
+            // Atomically mark as sent for this billing period — only the first writer (increment == 1) sends the alert.
+            long alertCount = await _cache.IncrementAsync(alertSentKey, 1, TimeSpan.FromDays(32));
+            if (alertCount != 1)
+                continue;
+
+            await _messagePublisher.PublishAsync(new OrganizationBudgetAlert
+            {
+                OrganizationId = organizationId,
+                Threshold = threshold,
+                ThresholdEventCount = thresholdEventCount,
+                CurrentEventCount = currentTotal,
+                EventLimit = maxEventsPerMonth
+            });
+        }
+    }
+
+    private async Task<int> GetEffectiveProjectLimitAsync(Project project, string organizationId)
+    {
+        if (project.IngestLimit is null)
+            return -1;
+
+        return project.IngestLimit.Type switch
+        {
+            ProjectIngestLimitType.Fixed => project.IngestLimit.FixedLimit ?? -1,
+            ProjectIngestLimitType.PercentOfOrganizationLimit => await CalculatePercentageLimitAsync(project.IngestLimit.PercentOfOrganizationLimit, organizationId),
+            _ => -1
+        };
+    }
+
+    private async Task<int> CalculatePercentageLimitAsync(decimal? percent, string organizationId)
+    {
+        if (percent is null or <= 0)
+            return -1;
+
+        int maxEventsPerMonth = await GetMaxEventsPerMonthAsync(organizationId);
+        if (maxEventsPerMonth < 0)
+            return -1;
+
+        return (int)Math.Ceiling(maxEventsPerMonth * (double)percent.Value / 100);
+    }
+
+    private async Task<int> GetProjectMonthTotalAsync(DateTime utcNow, string organizationId, string projectId)
+    {
+        var currentTotalCache = await _cache.GetAsync<int>(GetTotalCacheKey(utcNow, organizationId, projectId));
+        if (currentTotalCache.HasValue)
+            return currentTotalCache.Value;
+
+        var project = await _projectRepository.GetByIdAsync(projectId, o => o.Cache());
+        return project?.GetCurrentUsage(_timeProvider).Total ?? 0;
+    }
+
+    private async Task<int> GetOrganizationMonthTotalAsync(DateTime utcNow, string organizationId)
+    {
+        var currentTotalCache = await _cache.GetAsync<int>(GetTotalCacheKey(utcNow, organizationId));
+        if (currentTotalCache.HasValue)
+            return currentTotalCache.Value;
+
+        var organization = await _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+        return organization?.GetCurrentUsage(_timeProvider).Total ?? 0;
+    }
+
+    private async Task<int> GetOrganizationProjectCountAsync(string organizationId)
+    {
+        var cacheKey = $"usage:project-count:{organizationId}";
+        var cached = await _cache.GetAsync<int>(cacheKey);
+        if (cached.HasValue)
+            return cached.Value;
+
+        var countResult = await _projectRepository.GetCountByOrganizationIdAsync(organizationId);
+        long count = countResult.Total;
+        int projectCount = (int)Math.Max(1, count);
+        await _cache.SetAsync(cacheKey, projectCount, TimeSpan.FromHours(1));
+        return projectCount;
+    }
+
     public async Task IncrementBlockedAsync(string organizationId, string? projectId, int eventCount = 1)
     {
         if (eventCount <= 0)
@@ -489,6 +675,42 @@ public async Task IncrementDiscardedAsync(string organizationId, string projectI
         AppDiagnostics.EventsDiscarded.Add(eventCount);
     }
 
+    /// <summary>
+    /// Records smart throttle discard and publishes a deduped notification (once per billing period per project).
+    /// </summary>
+    public async Task RecordSmartThrottleAsync(string organizationId, string projectId, int discardedCount, SmartThrottleResult throttleResult)
+    {
+        await IncrementDiscardedAsync(organizationId, projectId, discardedCount);
+
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
+        string notifyKey = $"usage:smart-throttle-notified:{utcNow:yyyy-MM}:{organizationId}:{projectId}";
+        if (await _cache.GetAsync<bool>(notifyKey) is { HasValue: true, Value: true })
+            return;
+
+        await _cache.SetAsync(notifyKey, true, TimeSpan.FromDays(32));
+
+        int projectTotal = await GetProjectMonthTotalAsync(utcNow, organizationId, projectId);
+        int maxEventsPerMonth = await GetMaxEventsPerMonthAsync(organizationId);
+        int projectCount = await GetOrganizationProjectCountAsync(organizationId);
+        int fairShareLimit = maxEventsPerMonth > 0 ? (int)(maxEventsPerMonth / Math.Max(1, projectCount)) : 0;
+
+        try
+        {
+            await _messagePublisher.PublishAsync(new ProjectSmartThrottleApplied
+            {
+                OrganizationId = organizationId,
+                ProjectId = projectId,
+                SampleRate = throttleResult.SampleRate,
+                CurrentEventCount = projectTotal,
+                EventLimit = fairShareLimit
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to publish smart throttle notification for project {ProjectId}", projectId);
+        }
+    }
+
     public async Task IncrementTooBigAsync(string organizationId, string? projectId)
     {
         var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
@@ -620,6 +842,31 @@ 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 int GetCurrentBucket(DateTime utcTime) => utcTime.Floor(_bucketSize).ToEpoch();
     private int GetTotalBucket(DateTime utcTime) => utcTime.StartOfMonth().ToEpoch();
 }
+
+public class EventIngestAllowance
+{
+    public int EventsLeft { get; init; }
+    public double SampleRate { get; init; } = 1.0;
+    public bool IsOverOrgLimit { get; init; }
+    public bool IsOverProjectLimit { get; init; }
+    public int EffectiveProjectLimit { get; init; } = -1;
+}
+
+public class SmartThrottleResult
+{
+    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; }
+}
diff --git a/src/Exceptionless.Web/Bootstrapper.cs b/src/Exceptionless.Web/Bootstrapper.cs
index f83edd3615..e408f0b1f3 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/src/lib/features/organizations/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts
index 96d51972c1..ebfe8e744c 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
@@ -6,7 +6,7 @@ import { accessToken } from '$features/auth/index.svelte';
 import { type FetchClientResponse, type ProblemDetails, useFetchClient } from '@exceptionless/fetchclient';
 import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-query';
 
-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;
@@ -389,9 +389,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/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/organizations/models.ts
index 85d1fe5de6..d05f925285 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,14 @@
-export type { Invoice, InvoiceGridModel, NewOrganization, ViewOrganization } from '$generated/api';
+export type { Invoice, InvoiceGridModel, NewOrganization, OrganizationBudgetAlertSettings, ViewOrganization } from '$generated/api';
+
+export interface UpdateOrganization {
+    name?: string;
+    budget_alert_settings?: OrganizationBudgetAlertSettingsUpdate | null;
+}
+
+export interface OrganizationBudgetAlertSettingsUpdate {
+    enabled: boolean;
+    thresholds: number[];
+}
 
 // TODO: This should be generated from the backend enum - investigate why it wasn't included in the generated API
 export enum SuspensionCode {
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 c380dca5e7..99884f2f60 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,21 @@
-import { date, type infer as Infer, number, object, string, enum as zodEnum } from 'zod';
+import { date, type infer as Infer, number, object, string, enum as zodEnum, array, boolean } from 'zod';
 
 import { SuspensionCode } from './models';
 
 export { type NewOrganizationFormData, NewOrganizationSchema } from '$generated/schemas';
 
+export const BudgetAlertSettingsSchema = object({
+    enabled: boolean(),
+    thresholds: array(number().int().min(1).max(100))
+});
+export type BudgetAlertSettingsFormData = Infer<typeof BudgetAlertSettingsSchema>;
+
+export const UpdateOrganizationSchema = object({
+    name: string().min(1, 'Name is required').optional(),
+    budget_alert_settings: BudgetAlertSettingsSchema.nullable().optional()
+});
+export type UpdateOrganizationFormData = Infer<typeof UpdateOrganizationSchema>;
+
 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/projects/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
index a055dfb212..fd0abbc731 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/models.ts
@@ -1,6 +1,13 @@
+export { ProjectIngestLimitType } from '$generated/api';
 export type { ClientConfiguration, NewProject, NotificationSettings, UpdateProject, ViewProject } from '$generated/api';
 
 export interface ClientConfigurationSetting {
     key: string;
     value: string;
 }
+
+export interface ProjectIngestLimitUpdate {
+    type: 'fixed' | 'percent';
+    fixed_limit?: number | null;
+    percent_of_organization_limit?: number | null;
+}
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 e495e7dd4f..f17b4c158b 100644
--- a/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/projects/schemas.ts
@@ -5,7 +5,7 @@ import {
     type NotificationSettingsFormData,
     NotificationSettingsSchema
 } from '$generated/schemas';
-import { type infer as Infer, object, string } from 'zod';
+import { discriminatedUnion, literal, type infer as Infer, nullable, number, object, optional, string } from 'zod';
 
 export { type NewProjectFormData, NewProjectSchema, type NotificationSettingsFormData, NotificationSettingsSchema };
 
@@ -15,5 +15,25 @@ export const ClientConfigurationSettingSchema = object({
 });
 export type ClientConfigurationSettingFormData = Infer<typeof ClientConfigurationSettingSchema>;
 
+export const FixedIngestLimitSchema = object({
+    type: literal(0),
+    fixed_limit: number().int().min(1, 'Limit must be at least 1').nullable().optional(),
+    percent_of_organization_limit: optional(nullable(number()))
+});
+
+export const PercentIngestLimitSchema = object({
+    type: literal(1),
+    fixed_limit: optional(nullable(number())),
+    percent_of_organization_limit: number().min(1, 'Percentage must be at least 1').max(999, 'Percentage must be at most 999').nullable().optional()
+});
+
+export const IngestLimitSchema = discriminatedUnion('type', [FixedIngestLimitSchema, PercentIngestLimitSchema]);
+export type IngestLimitFormData = Infer<typeof IngestLimitSchema>;
+
 export const UpdateProjectSchema = GeneratedUpdateProjectSchema.partial();
 export type UpdateProjectFormData = Infer<typeof UpdateProjectSchema>;
+
+export const UpdateProjectIngestLimitSchema = object({
+    ingest_limit: IngestLimitSchema.nullable().optional()
+});
+export type UpdateProjectIngestLimitFormData = Infer<typeof UpdateProjectIngestLimitSchema>;
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts b/src/Exceptionless.Web/ClientApp/src/lib/generated/api.ts
index 8ef1330255..5934489784 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,
@@ -112,6 +117,8 @@ export interface InvoiceLineItem {
   amount: number;
 }
 
+export type JsonElement = any;
+
 export interface Login {
   /** The email address or domain username */
   email: string;
@@ -128,6 +135,7 @@ export interface NewProject {
   organization_id: string;
   name: string;
   delete_bot_data_enabled: boolean;
+  ingest_limit?: null | ProjectIngestLimit;
 }
 
 export interface NewSavedView {
@@ -137,6 +145,7 @@ export interface NewSavedView {
   filter?: null | string;
   time?: null | string;
   sort?: null | string;
+  /** @pattern ^[a-z0-9]+(?:-[a-z0-9]+)*$ */
   slug?: null | string;
   view_type: string;
   filter_definitions?: null | string;
@@ -192,6 +201,15 @@ export interface OAuthAccount {
   extra_data: Record<string, 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.
@@ -256,6 +274,29 @@ export interface PersistentEvent {
   reference_id?: null | string;
 }
 
+export interface PredefinedSavedViewDefinition {
+  key: string;
+  name: string;
+  slug: string;
+  viewType: string;
+  filter?: null | string;
+  time?: null | string;
+  sort?: null | string;
+  filterDefinitions?: null | JsonElement;
+  columns?: null | Record<string, boolean>;
+  columnOrder?: string[] | null;
+  showStats?: null | boolean;
+  showChart?: null | boolean;
+}
+
+export interface ProjectIngestLimit {
+  type: ProjectIngestLimitType;
+  /** @format int32 */
+  fixed_limit?: null | number;
+  /** @format double */
+  percent_of_organization_limit?: null | number;
+}
+
 export interface ResetPasswordModel {
   password_reset_token: string;
   password: string;
@@ -364,10 +405,17 @@ export interface UpdateEvent {
   description?: null | string;
 }
 
+/** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
+export interface UpdateOrganization {
+  name: string;
+  budget_alert_settings: object;
+}
+
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
 export interface UpdateProject {
   name: string;
   delete_bot_data_enabled: boolean;
+  ingest_limit: object;
 }
 
 /** A class the tracks changes (i.e. the Delta) for a particular TEntityType. */
@@ -538,6 +586,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 {
@@ -559,6 +608,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 8642423da4..302631d358 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),
@@ -169,6 +170,7 @@ 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).optional(),
 });
 export type NewProjectFormData = Infer<typeof NewProjectSchema>;
 
@@ -277,6 +279,14 @@ export const OAuthAccountSchema = object({
 });
 export type OAuthAccountFormData = Infer<typeof OAuthAccountSchema>;
 
+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")
@@ -320,6 +330,31 @@ export const PersistentEventSchema = object({
 });
 export type PersistentEventFormData = Infer<typeof PersistentEventSchema>;
 
+export const PredefinedSavedViewDefinitionSchema = object({
+  key: string().min(1, "Key is required"),
+  name: string().min(1, "Name is required"),
+  slug: string().min(1, "Slug is required"),
+  viewType: string().min(1, "View type is required"),
+  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: lazy(() => JsonElementSchema).optional(),
+  columns: record(string(), boolean()).nullable().optional(),
+  columnOrder: array(string()).nullable().optional(),
+  showStats: boolean().nullable().optional(),
+  showChart: boolean().nullable().optional(),
+});
+export type PredefinedSavedViewDefinitionFormData = Infer<
+  typeof PredefinedSavedViewDefinitionSchema
+>;
+
+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 ResetPasswordModelSchema = object({
   password_reset_token: string().length(
     40,
@@ -414,9 +449,16 @@ export const UpdateEventSchema = object({
 });
 export type UpdateEventFormData = Infer<typeof UpdateEventSchema>;
 
+export const UpdateOrganizationSchema = object({
+  name: string().min(1, "Name is required").optional(),
+  budget_alert_settings: record(string(), unknown()).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: record(string(), unknown()).optional(),
 });
 export type UpdateProjectFormData = Infer<typeof UpdateProjectSchema>;
 
@@ -425,12 +467,7 @@ export const UpdateSavedViewSchema = 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(),
-  slug: string()
-    .min(1, "Slug is required")
-    .max(100, "Slug must be at most 100 characters")
-    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug has invalid format")
-    .nullable()
-    .optional(),
+  slug: string().min(1, "Slug is required").nullable().optional(),
   filter_definitions: string()
     .min(1, "Filter definitions is required")
     .nullable()
@@ -577,6 +614,9 @@ export const ViewOrganizationSchema = object({
   is_throttled: boolean(),
   is_over_monthly_limit: boolean(),
   is_over_request_limit: boolean(),
+  budget_alert_settings: lazy(
+    () => OrganizationBudgetAlertSettingsSchema,
+  ).optional(),
 });
 export type ViewOrganizationFormData = Infer<typeof ViewOrganizationSchema>;
 
@@ -598,6 +638,10 @@ export const ViewProjectSchema = object({
   event_count: int(),
   has_premium_features: boolean(),
   has_slack_integration: boolean(),
+  ingest_limit: lazy(() => ProjectIngestLimitSchema).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)),
 });
@@ -633,10 +677,7 @@ export const ViewSavedViewSchema = object({
   show_stats: boolean().nullable().optional(),
   show_chart: boolean().nullable().optional(),
   name: string().min(1, "Name is required"),
-  slug: string()
-    .min(1, "Slug is required")
-    .max(100, "Slug must be at most 100 characters")
-    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug has invalid format"),
+  slug: string().min(1, "Slug is required"),
   time: string().min(1, "Time is required").nullable().optional(),
   sort: string().min(1, "Sort is required").nullable().optional(),
   version: int32(),
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/manage/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/manage/+page.svelte
index 617d3654c8..147738944b 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/manage/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/organization/[organizationId]/manage/+page.svelte
@@ -4,17 +4,20 @@
     import { page } from '$app/state';
     import ErrorMessage from '$comp/error-message.svelte';
     import { Muted } from '$comp/typography';
+    import { Badge } from '$comp/ui/badge';
     import { Button, buttonVariants } from '$comp/ui/button';
     import * as DropdownMenu from '$comp/ui/dropdown-menu';
     import * as Field from '$comp/ui/field';
     import { Input } from '$comp/ui/input';
     import { Spinner } from '$comp/ui/spinner';
+    import { Switch } from '$comp/ui/switch';
     import { deleteOrganization, getOrganizationQuery, patchOrganization } from '$features/organizations/api.svelte';
     import RemoveOrganizationDialog from '$features/organizations/components/dialogs/remove-organization-dialog.svelte';
     import { type NewOrganizationFormData, NewOrganizationSchema } from '$features/organizations/schemas';
     import { ariaInvalid, getFormErrorMessages, mapFieldErrors, problemDetailsToFormErrors } from '$features/shared/validation';
     import { ProblemDetails } from '@exceptionless/fetchclient';
     import Stacks from '@lucide/svelte/icons/layers';
+    import Plus from '@lucide/svelte/icons/plus';
     import X from '@lucide/svelte/icons/x';
     import { createForm } from '@tanstack/svelte-form';
     import { toast } from 'svelte-sonner';
@@ -70,7 +73,7 @@
             onSubmitAsync: async ({ value }) => {
                 toast.dismiss(toastId);
                 try {
-                    await update.mutateAsync(value);
+                    await update.mutateAsync({ name: value.name });
                     toastId = toast.success('Successfully updated Organization name');
                     return null;
                 } catch (error: unknown) {
@@ -87,10 +90,68 @@
 
     const debouncedFormSubmit = debounce(1000, () => form.handleSubmit());
 
+    // Budget alert settings state
+    const budgetSettings = $derived(organizationQuery.data?.budget_alert_settings);
+    let budgetEnabled = $state(false);
+    let thresholds = $state<number[]>([]);
+    let newThreshold = $state('');
+    let budgetSaving = $state(false);
+    let thresholdError = $state('');
+
+    $effect(() => {
+        budgetEnabled = budgetSettings?.enabled ?? false;
+        thresholds = [...(budgetSettings?.thresholds ?? [])].sort((a, b) => a - b);
+    });
+
+    async function saveBudgetSettings() {
+        toast.dismiss(toastId);
+        budgetSaving = true;
+        try {
+            await update.mutateAsync({
+                budget_alert_settings: {
+                    enabled: budgetEnabled,
+                    thresholds: [...thresholds].sort((a, b) => a - b)
+                }
+            });
+            toastId = toast.success('Budget alert settings saved.');
+        } catch (error: unknown) {
+            const message = error instanceof ProblemDetails ? error.title : 'Please try again.';
+            toastId = toast.error(`Error saving budget settings: ${message}`);
+        } finally {
+            budgetSaving = false;
+        }
+    }
+
+    function addThreshold() {
+        thresholdError = '';
+        const val = parseInt(newThreshold, 10);
+        if (isNaN(val) || val < 1 || val > 99) {
+            thresholdError = 'Enter a percentage between 1 and 99.';
+            return;
+        }
+        if (thresholds.includes(val)) {
+            thresholdError = 'That threshold is already added.';
+            return;
+        }
+        thresholds = [...thresholds, val].sort((a, b) => a - b);
+        newThreshold = '';
+    }
+
+    function removeThreshold(val: number) {
+        thresholds = thresholds.filter((t) => t !== val);
+    }
+
+    function handleThresholdKeydown(e: KeyboardEvent) {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            addThreshold();
+        }
+    }
+
     // TODO: Add Skeleton
 </script>
 
-<div class="space-y-6">
+<div class="space-y-8">
     <Muted>General organization settings</Muted>
 
     <form
@@ -129,6 +190,86 @@
         </form.Field>
     </form>
 
+    <section class="space-y-4" aria-labelledby="budget-alert-heading">
+        <div class="space-y-1">
+            <h2 id="budget-alert-heading" class="text-sm font-medium">Budget alerts</h2>
+            <Muted class="text-xs">Send email alerts when monthly event usage crosses percentage thresholds.</Muted>
+        </div>
+
+        <div class="bg-card space-y-4 rounded-lg border p-4">
+            <div class="flex items-center justify-between">
+                <div>
+                    <div class="text-sm font-medium">Enable budget alerts</div>
+                    <Muted class="text-xs">Receive email notifications when usage thresholds are crossed.</Muted>
+                </div>
+                <Switch
+                    id="budget-enabled"
+                    checked={budgetEnabled}
+                    onCheckedChange={(checked) => (budgetEnabled = checked)}
+                    aria-label="Enable budget alerts"
+                />
+            </div>
+
+            {#if budgetEnabled}
+                <div class="space-y-3">
+                    <div class="text-sm font-medium">Alert thresholds</div>
+                    <div class="flex flex-wrap gap-2" aria-label="Current thresholds">
+                        {#each thresholds as threshold (threshold)}
+                            <Badge variant="secondary" class="gap-1 pr-1">
+                                {threshold}%
+                                <button
+                                    type="button"
+                                    class="ml-1 rounded-full p-0.5 hover:bg-white/20"
+                                    onclick={() => removeThreshold(threshold)}
+                                    aria-label="Remove {threshold}% threshold"
+                                >
+                                    <X class="size-3" />
+                                </button>
+                            </Badge>
+                        {:else}
+                            <Muted class="text-xs italic">No thresholds set. Add at least one below.</Muted>
+                        {/each}
+                    </div>
+
+                    <div class="flex gap-2">
+                        <div class="w-28">
+                            <Field.Field>
+                                <Field.Label for="new-threshold" class="sr-only">New threshold percentage</Field.Label>
+                                <Input
+                                    id="new-threshold"
+                                    type="number"
+                                    min="1"
+                                    max="99"
+                                    placeholder="e.g. 80"
+                                    bind:value={newThreshold}
+                                    onkeydown={handleThresholdKeydown}
+                                    aria-invalid={thresholdError ? 'true' : undefined}
+                                    aria-describedby={thresholdError ? 'threshold-error' : undefined}
+                                />
+                                {#if thresholdError}
+                                    <p id="threshold-error" class="text-destructive text-xs">{thresholdError}</p>
+                                {/if}
+                            </Field.Field>
+                        </div>
+                        <Button type="button" variant="secondary" size="sm" class="mt-0 self-start" onclick={addThreshold} aria-label="Add threshold">
+                            <Plus class="mr-1 size-4" />
+                            Add
+                        </Button>
+                    </div>
+                </div>
+            {/if}
+
+            <div class="flex justify-end border-t pt-3">
+                <Button type="button" onclick={saveBudgetSettings} disabled={budgetSaving || update.isPending} size="sm">
+                    {#if budgetSaving || update.isPending}
+                        <Spinner class="mr-2 size-4" />
+                    {/if}
+                    Save budget settings
+                </Button>
+            </div>
+        </div>
+    </section>
+
     <div class="flex w-full items-center justify-between">
         <Button variant="secondary" href={resolve('/(app)/stacks')}>
             <Stacks class="mr-2 size-4" /> Go To Stacks
@@ -161,3 +302,4 @@
 {#if organizationQuery.isSuccess}
     <RemoveOrganizationDialog bind:open={showRemoveDialog} name={organizationQuery.data.name} {remove} />
 {/if}
+
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/manage/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/manage/+page.svelte
index 0bb415386c..90a46a7836 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/manage/+page.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/project/[projectId]/manage/+page.svelte
@@ -9,6 +9,7 @@
     import { Button } from '$comp/ui/button';
     import * as Field from '$comp/ui/field';
     import { Input } from '$comp/ui/input';
+    import * as Select from '$comp/ui/select';
     import { Spinner } from '$comp/ui/spinner';
     import * as Tooltip from '$comp/ui/tooltip';
     import { deleteProject, generateSampleData, getProjectQuery, resetData, updateProject } from '$features/projects/api.svelte';
@@ -125,10 +126,78 @@
 
     const debouncedFormSubmit = debounce(1000, () => form.handleSubmit());
 
+    // Ingest limit state
+    type LimitType = 'none' | 'fixed' | 'percent';
+    const projectData = $derived(projectQuery.data);
+    let limitType = $state<LimitType>('none');
+    let fixedLimit = $state('');
+    let percentLimit = $state('');
+    let limitSaving = $state(false);
+    let limitError = $state('');
+
+    $effect(() => {
+        const limit = projectData?.ingest_limit;
+        if (!limit) {
+            limitType = 'none';
+            fixedLimit = '';
+            percentLimit = '';
+        } else if (limit.type === 0) {
+            limitType = 'fixed';
+            fixedLimit = limit.fixed_limit?.toString() ?? '';
+            percentLimit = '';
+        } else {
+            limitType = 'percent';
+            percentLimit = limit.percent_of_organization_limit?.toString() ?? '';
+            fixedLimit = '';
+        }
+    });
+
+    const limitTypeItems = [
+        { value: 'none', label: 'No limit' },
+        { value: 'fixed', label: 'Fixed event count' },
+        { value: 'percent', label: 'Percentage of org limit' }
+    ];
+
+    async function saveIngestLimit() {
+        limitError = '';
+        toast.dismiss(toastId);
+        limitSaving = true;
+
+        try {
+            let ingest_limit: { type: number; fixed_limit?: number | null; percent_of_organization_limit?: number | null } | null = null;
+
+            if (limitType === 'fixed') {
+                const val = parseInt(fixedLimit, 10);
+                if (isNaN(val) || val < 1) {
+                    limitError = 'Fixed limit must be a positive integer.';
+                    limitSaving = false;
+                    return;
+                }
+                ingest_limit = { type: 0, fixed_limit: val };
+            } else if (limitType === 'percent') {
+                const val = parseFloat(percentLimit);
+                if (isNaN(val) || val <= 0) {
+                    limitError = 'Percentage must be a positive number.';
+                    limitSaving = false;
+                    return;
+                }
+                ingest_limit = { type: 1, percent_of_organization_limit: val };
+            }
+
+            await update.mutateAsync({ ingest_limit } as UpdateProject);
+            toastId = toast.success('Event ingest limit saved.');
+        } catch (error: unknown) {
+            const message = error instanceof ProblemDetails ? error.title : 'Please try again.';
+            toastId = toast.error(`Error saving ingest limit: ${message}`);
+        } finally {
+            limitSaving = false;
+        }
+    }
+
     // TODO: Add Skeleton
 </script>
 
-<div class="space-y-6">
+<div class="space-y-8">
     <Muted>General project settings</Muted>
 
     <form
@@ -167,6 +236,74 @@
         </form.Field>
     </form>
 
+    <section class="space-y-4" aria-labelledby="ingest-limit-heading">
+        <div class="space-y-1">
+            <h2 id="ingest-limit-heading" class="text-sm font-medium">Event ingest limit</h2>
+            <Muted class="text-xs">Restrict how many events this project can ingest per month.</Muted>
+        </div>
+
+        <div class="bg-card space-y-4 rounded-lg border p-4">
+            <Field.Field>
+                <Field.Label for="limit-type">Limit type</Field.Label>
+                <Select.Root
+                    type="single"
+                    value={limitType}
+                    onValueChange={(v) => {
+                        limitType = v as LimitType;
+                        limitError = '';
+                    }}
+                >
+                    <Select.Trigger id="limit-type" class="w-56">
+                        {limitTypeItems.find((i) => i.value === limitType)?.label ?? 'No limit'}
+                    </Select.Trigger>
+                    <Select.Content>
+                        {#each limitTypeItems as item (item.value)}
+                            <Select.Item value={item.value}>{item.label}</Select.Item>
+                        {/each}
+                    </Select.Content>
+                </Select.Root>
+            </Field.Field>
+
+            {#if limitType === 'fixed'}
+                <Field.Field>
+                    <Field.Label for="fixed-limit">Max events per month</Field.Label>
+                    <Input id="fixed-limit" type="number" min="1" placeholder="e.g. 100000" class="w-48" bind:value={fixedLimit} />
+                    <Field.Description>Events beyond this count will be blocked.</Field.Description>
+                </Field.Field>
+            {:else if limitType === 'percent'}
+                <Field.Field>
+                    <Field.Label for="percent-limit">Percentage of organization limit (%)</Field.Label>
+                    <Input id="percent-limit" type="number" min="1" max="999" step="0.1" placeholder="e.g. 50" class="w-48" bind:value={percentLimit} />
+                    <Field.Description>
+                        Percentage of the organization's monthly event allowance. Values above 100% allow this project to use more than its equal share.
+                        {#if projectData?.effective_ingest_limit != null}
+                            <span class="ml-1 font-medium">Current effective limit: {projectData.effective_ingest_limit.toLocaleString()} events.</span>
+                        {/if}
+                    </Field.Description>
+                </Field.Field>
+            {/if}
+
+            {#if limitError}
+                <p class="text-destructive text-xs">{limitError}</p>
+            {/if}
+
+            {#if projectData?.is_smart_throttled}
+                <div class="bg-muted rounded-md p-3 text-xs">
+                    <span class="font-medium">Smart throttle active</span> — this project is accepting {Math.round((projectData.smart_throttle_sample_rate ?? 1) * 100)}% of events due to disproportionate resource usage.
+                </div>
+            {/if}
+
+            <div class="flex justify-end border-t pt-3">
+                <Button type="button" onclick={saveIngestLimit} disabled={limitSaving || update.isPending} size="sm">
+                    {#if limitSaving || update.isPending}
+                        <Spinner class="mr-2 size-4" />
+                    {/if}
+                    Save ingest limit
+                </Button>
+            </div>
+        </div>
+    </section>
+
     <div class="flex w-full items-center justify-between">
         <div class="flex gap-2">
             <Button variant="secondary" href={`${resolve('/(app)/stacks')}?filter=project:${projectId}`}>
diff --git a/src/Exceptionless.Web/Controllers/OrganizationController.cs b/src/Exceptionless.Web/Controllers/OrganizationController.cs
index 7d11666508..ad03265873 100644
--- a/src/Exceptionless.Web/Controllers/OrganizationController.cs
+++ b/src/Exceptionless.Web/Controllers/OrganizationController.cs
@@ -30,7 +30,7 @@ namespace Exceptionless.Web.Controllers;
 
 [Route(API_PREFIX + "/organizations")]
 [Authorize(Policy = AuthorizationRoles.UserPolicy)]
-public class OrganizationController : RepositoryApiController<IOrganizationRepository, Organization, ViewOrganization, NewOrganization, NewOrganization>
+public class OrganizationController : RepositoryApiController<IOrganizationRepository, Organization, ViewOrganization, NewOrganization, UpdateOrganization>
 {
     private readonly OrganizationService _organizationService;
     private readonly ICacheClient _cacheClient;
@@ -180,7 +180,7 @@ public Task<ActionResult<ViewOrganization>> PostAsync(NewOrganization organizati
     [HttpPut]
     [Consumes("application/json")]
     [Route("{id:objectid}")]
-    public Task<ActionResult<ViewOrganization>> PatchAsync(string id, Delta<NewOrganization> changes)
+    public Task<ActionResult<ViewOrganization>> PatchAsync(string id, Delta<UpdateOrganization> changes)
     {
         return PatchImplAsync(id, changes);
     }
@@ -876,14 +876,16 @@ public async Task<IActionResult> IsNameAvailableAsync(string name)
         return StatusCode(StatusCodes.Status201Created);
     }
 
-    private async Task<bool> IsOrganizationNameAvailableInternalAsync(string name)
+    private async Task<bool> IsOrganizationNameAvailableInternalAsync(string name, string? excludeOrganizationId = null)
     {
         if (String.IsNullOrWhiteSpace(name))
             return false;
 
         string decodedName = Uri.UnescapeDataString(name).Trim().ToLowerInvariant();
         var results = await _repository.GetByIdsAsync(GetAssociatedOrganizationIds().ToArray(), o => o.Cache());
-        return !results.Any(o => String.Equals(o.Name.Trim().ToLowerInvariant(), decodedName, StringComparison.OrdinalIgnoreCase));
+        return !results.Any(o =>
+            o.Id != excludeOrganizationId &&
+            String.Equals(o.Name.Trim().ToLowerInvariant(), decodedName, StringComparison.OrdinalIgnoreCase));
     }
 
     protected override async Task<PermissionResult> CanAddAsync(Organization value)
@@ -922,10 +924,10 @@ await _messagePublisher.PublishAsync(new UserMembershipChanged
         return organization;
     }
 
-    protected override async Task<PermissionResult> CanUpdateAsync(Organization original, Delta<NewOrganization> changes)
+    protected override async Task<PermissionResult> CanUpdateAsync(Organization original, Delta<UpdateOrganization> changes)
     {
         var changed = changes.GetEntity();
-        if (!await IsOrganizationNameAvailableInternalAsync(changed.Name))
+        if (changes.ContainsChangedProperty(p => p.Name) && !await IsOrganizationNameAvailableInternalAsync(changed.Name, original.Id))
             return PermissionResult.DenyWithMessage("A organization with this name already exists.");
 
         return await base.CanUpdateAsync(original, changes);
diff --git a/src/Exceptionless.Web/Controllers/ProjectController.cs b/src/Exceptionless.Web/Controllers/ProjectController.cs
index 23d4690910..9b94a8ffbe 100644
--- a/src/Exceptionless.Web/Controllers/ProjectController.cs
+++ b/src/Exceptionless.Web/Controllers/ProjectController.cs
@@ -763,6 +763,17 @@ await _workItemQueue.EnqueueAsync(new SetProjectIsConfiguredWorkItem
             currentHourUsage.Discarded = realTimeUsage.CurrentHourUsage.Discarded;
             currentHourUsage.TooBig = realTimeUsage.CurrentHourUsage.TooBig;
             currentHourUsage.Deleted = realTimeUsage.CurrentHourUsage.Deleted;
+
+            // Populate computed budget/throttle properties
+            if (viewProject.IngestLimit is not null)
+            {
+                var allowance = await _usageService.GetEventIngestAllowanceAsync(organization.Id, viewProject.Id);
+                viewProject.EffectiveIngestLimit = allowance.EffectiveProjectLimit > 0 ? allowance.EffectiveProjectLimit : null;
+            }
+
+            var throttleResult = await _usageService.GetSmartThrottleRateAsync(organization.Id, viewProject.Id);
+            viewProject.IsSmartThrottled = throttleResult.IsThrottled;
+            viewProject.SmartThrottleSampleRate = throttleResult.IsThrottled ? throttleResult.SampleRate : null;
         }
     }
 
diff --git a/src/Exceptionless.Web/Mapping/OrganizationMapper.cs b/src/Exceptionless.Web/Mapping/OrganizationMapper.cs
index 09ace1eea4..6a24dbe67c 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 34b8e48b5e..12fa19230b 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 6f6270a1e5..23222e0460 100644
--- a/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs
+++ b/src/Exceptionless.Web/Models/Organization/ViewOrganization.cs
@@ -45,6 +45,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 8272ee7258..7ed35c8eee 100644
--- a/src/Exceptionless.Web/Models/Project/UpdateProject.cs
+++ b/src/Exceptionless.Web/Models/Project/UpdateProject.cs
@@ -1,7 +1,10 @@
-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; }
 }
diff --git a/src/Exceptionless.Web/Models/Project/ViewProject.cs b/src/Exceptionless.Web/Models/Project/ViewProject.cs
index c67f6b8f82..cb025d92c8 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/Delta/Delta.cs b/src/Exceptionless.Web/Utility/Delta/Delta.cs
index 38c402227e..5b5ad10b1d 100644
--- a/src/Exceptionless.Web/Utility/Delta/Delta.cs
+++ b/src/Exceptionless.Web/Utility/Delta/Delta.cs
@@ -275,6 +275,14 @@ public void CopyChangedValues(object target)
             if (!_propertyCache[targetType].TryGetValue(sourceProperty.Name, out var targetAccessor))
                 continue;
 
+            if (value is null)
+            {
+                // Propagate explicit null for nullable target properties (e.g. PATCH {"field": null} to clear a value)
+                if (IsNullable(targetAccessor.MemberType))
+                    targetAccessor.SetValue(target, null);
+                continue;
+            }
+
             if (!targetAccessor.MemberType.IsInstanceOfType(value))
                 continue;
 
diff --git a/tests/Exceptionless.Tests/Controllers/Data/openapi.json b/tests/Exceptionless.Tests/Controllers/Data/openapi.json
index 74b0d01dcc..6ef8893fd0 100644
--- a/tests/Exceptionless.Tests/Controllers/Data/openapi.json
+++ b/tests/Exceptionless.Tests/Controllers/Data/openapi.json
@@ -568,7 +568,7 @@
           "Token"
         ],
         "summary": "Create for organization",
-        "description": "This is a helper action that makes it easier to create a token for a specific organization.\r\nYou may also specify a scope when creating a token. There are three valid scopes: client, user and admin.",
+        "description": "This is a helper action that makes it easier to create a token for a specific organization.\nYou may also specify a scope when creating a token. There are three valid scopes: client, user and admin.",
         "parameters": [
           {
             "name": "organizationId",
@@ -692,7 +692,7 @@
           "Token"
         ],
         "summary": "Create for project",
-        "description": "This is a helper action that makes it easier to create a token for a specific project.\r\nYou may also specify a scope when creating a token. There are three valid scopes: client, user and admin.",
+        "description": "This is a helper action that makes it easier to create a token for a specific project.\nYou may also specify a scope when creating a token. There are three valid scopes: client, user and admin.",
         "parameters": [
           {
             "name": "projectId",
@@ -1199,7 +1199,7 @@
           "Auth"
         ],
         "summary": "Login",
-        "description": "Log in with your email address and password to generate a token scoped with your users roles.\r\n\r\n```{ \"email\": \"noreply@exceptionless.io\", \"password\": \"exceptionless\" }```\r\n\r\nThis token can then be used to access the api. You can use this token in the header (bearer authentication)\r\nor append it onto the query string: ?access_token=MY_TOKEN\r\n\r\nPlease note that you can also use this token on the documentation site by placing it in the\r\nheaders api_key input box.",
+        "description": "Log in with your email address and password to generate a token scoped with your users roles.\n\n```{ \"email\": \"noreply@exceptionless.io\", \"password\": \"exceptionless\" }```\n\nThis token can then be used to access the api. You can use this token in the header (bearer authentication)\nor append it onto the query string: ?access_token=MY_TOKEN\n\nPlease note that you can also use this token on the documentation site by placing it in the\nheaders api_key input box.",
         "requestBody": {
           "content": {
             "application/json": {
@@ -2056,7 +2056,7 @@
           "Event"
         ],
         "summary": "Submit event by POST",
-        "description": "      You can create an event by posting any uncompressed or compressed (gzip or deflate) string or json object. If we know how to handle it\r\n      we will create a new event. If none of the JSON properties match the event object then we will create a new event and place your JSON\r\n      object into the events data collection.\r\n\r\n      You can also post a multi-line string. We automatically split strings by the \\n character and create a new log event for every line.\r\n\r\n      Simple event:\r\n      ```{ \"message\": \"Exceptionless is amazing!\" }```\r\n\r\n      Simple log event with user identity:\r\n      ```{\r\n    \"type\": \"log\",\r\n    \"message\": \"Exceptionless is amazing!\",\r\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\r\n    \"@user\":{ \"identity\":\"123456789\", \"name\": \"Test User\" }\r\n}```\r\n\r\n      Multiple events from string content:\r\n      ```Exceptionless is amazing!\r\nExceptionless is really amazing!```\r\n\r\n      Simple error:\r\n      ```{\r\n    \"type\": \"error\",\r\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\r\n    \"@simple_error\": {\r\n        \"message\": \"Simple Exception\",\r\n        \"type\": \"System.Exception\",\r\n        \"stack_trace\": \"   at Client.Tests.ExceptionlessClientTests.CanSubmitSimpleException() in ExceptionlessClientTests.cs:line 77\"\r\n    }\r\n}```",
+        "description": "      You can create an event by posting any uncompressed or compressed (gzip or deflate) string or json object. If we know how to handle it\n      we will create a new event. If none of the JSON properties match the event object then we will create a new event and place your JSON\n      object into the events data collection.\n\n      You can also post a multi-line string. We automatically split strings by the \\n character and create a new log event for every line.\n\n      Simple event:\n      ```{ \"message\": \"Exceptionless is amazing!\" }```\n\n      Simple log event with user identity:\n      ```{\n    \"type\": \"log\",\n    \"message\": \"Exceptionless is amazing!\",\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\n    \"@user\":{ \"identity\":\"123456789\", \"name\": \"Test User\" }\n}```\n\n      Multiple events from string content:\n      ```Exceptionless is amazing!\nExceptionless is really amazing!```\n\n      Simple error:\n      ```{\n    \"type\": \"error\",\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\n    \"@simple_error\": {\n        \"message\": \"Simple Exception\",\n        \"type\": \"System.Exception\",\n        \"stack_trace\": \"   at Client.Tests.ExceptionlessClientTests.CanSubmitSimpleException() in ExceptionlessClientTests.cs:line 77\"\n    }\n}```",
         "parameters": [
           {
             "name": "userAgent",
@@ -2342,7 +2342,7 @@
           "Event"
         ],
         "summary": "Submit event by POST for a specific project",
-        "description": "      You can create an event by posting any uncompressed or compressed (gzip or deflate) string or json object. If we know how to handle it\r\n      we will create a new event. If none of the JSON properties match the event object then we will create a new event and place your JSON\r\n      object into the events data collection.\r\n\r\n      You can also post a multi-line string. We automatically split strings by the \\n character and create a new log event for every line.\r\n\r\n      Simple event:\r\n      ```{ \"message\": \"Exceptionless is amazing!\" }```\r\n\r\n      Simple log event with user identity:\r\n      ```{\r\n    \"type\": \"log\",\r\n    \"message\": \"Exceptionless is amazing!\",\r\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\r\n    \"@user\":{ \"identity\":\"123456789\", \"name\": \"Test User\" }\r\n}```\r\n\r\n      Multiple events from string content:\r\n      ```Exceptionless is amazing!\r\nExceptionless is really amazing!```\r\n\r\n      Simple error:\r\n      ```{\r\n    \"type\": \"error\",\r\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\r\n    \"@simple_error\": {\r\n        \"message\": \"Simple Exception\",\r\n        \"type\": \"System.Exception\",\r\n        \"stack_trace\": \"   at Client.Tests.ExceptionlessClientTests.CanSubmitSimpleException() in ExceptionlessClientTests.cs:line 77\"\r\n    }\r\n}```",
+        "description": "      You can create an event by posting any uncompressed or compressed (gzip or deflate) string or json object. If we know how to handle it\n      we will create a new event. If none of the JSON properties match the event object then we will create a new event and place your JSON\n      object into the events data collection.\n\n      You can also post a multi-line string. We automatically split strings by the \\n character and create a new log event for every line.\n\n      Simple event:\n      ```{ \"message\": \"Exceptionless is amazing!\" }```\n\n      Simple log event with user identity:\n      ```{\n    \"type\": \"log\",\n    \"message\": \"Exceptionless is amazing!\",\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\n    \"@user\":{ \"identity\":\"123456789\", \"name\": \"Test User\" }\n}```\n\n      Multiple events from string content:\n      ```Exceptionless is amazing!\nExceptionless is really amazing!```\n\n      Simple error:\n      ```{\n    \"type\": \"error\",\n    \"date\":\"2030-01-01T12:00:00.0000000-05:00\",\n    \"@simple_error\": {\n        \"message\": \"Simple Exception\",\n        \"type\": \"System.Exception\",\n        \"stack_trace\": \"   at Client.Tests.ExceptionlessClientTests.CanSubmitSimpleException() in ExceptionlessClientTests.cs:line 77\"\n    }\n}```",
         "parameters": [
           {
             "name": "projectId",
@@ -3675,7 +3675,7 @@
           "Event"
         ],
         "summary": "Submit event by GET",
-        "description": "You can submit an event using an HTTP GET and query string parameters. Any unknown query string parameters will be added to the extended data of the event.\r\n\r\nFeature usage named build with a duration of 10:\r\n```/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\r\n\r\nLog with message, geo and extended data\r\n```/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
+        "description": "You can submit an event using an HTTP GET and query string parameters. Any unknown query string parameters will be added to the extended data of the event.\n\nFeature usage named build with a duration of 10:\n```/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\n\nLog with message, geo and extended data\n```/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
         "parameters": [
           {
             "name": "type",
@@ -3809,7 +3809,7 @@
           "Event"
         ],
         "summary": "Submit event type by GET",
-        "description": "You can submit an event using an HTTP GET and query string parameters.\r\n\r\nFeature usage event named build with a value of 10:\r\n```/events/submit/usage?access_token=YOUR_API_KEY&amp;source=build&amp;value=10```\r\n\r\nLog event with message, geo and extended data\r\n```/events/submit/log?access_token=YOUR_API_KEY&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
+        "description": "You can submit an event using an HTTP GET and query string parameters.\n\nFeature usage event named build with a value of 10:\n```/events/submit/usage?access_token=YOUR_API_KEY&amp;source=build&amp;value=10```\n\nLog event with message, geo and extended data\n```/events/submit/log?access_token=YOUR_API_KEY&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
         "parameters": [
           {
             "name": "type",
@@ -3945,7 +3945,7 @@
           "Event"
         ],
         "summary": "Submit event type by GET for a specific project",
-        "description": "You can submit an event using an HTTP GET and query string parameters.\r\n\r\nFeature usage named build with a duration of 10:\r\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\r\n\r\nLog with message, geo and extended data\r\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
+        "description": "You can submit an event using an HTTP GET and query string parameters.\n\nFeature usage named build with a duration of 10:\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\n\nLog with message, geo and extended data\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
         "parameters": [
           {
             "name": "projectId",
@@ -4081,7 +4081,7 @@
           "Event"
         ],
         "summary": "Submit event type by GET for a specific project",
-        "description": "You can submit an event using an HTTP GET and query string parameters.\r\n\r\nFeature usage named build with a duration of 10:\r\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\r\n\r\nLog with message, geo and extended data\r\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
+        "description": "You can submit an event using an HTTP GET and query string parameters.\n\nFeature usage named build with a duration of 10:\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=usage&amp;source=build&amp;value=10```\n\nLog with message, geo and extended data\n```/projects/{projectId}/events/submit?access_token=YOUR_API_KEY&amp;type=log&amp;message=Hello World&amp;source=server01&amp;geo=32.85,-96.9613&amp;randomproperty=true```",
         "parameters": [
           {
             "name": "projectId",
@@ -4543,12 +4543,12 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             },
             "application/*+json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             }
           },
@@ -4595,12 +4595,12 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             },
             "application/*+json": {
               "schema": {
-                "$ref": "#/components/schemas/NewOrganization"
+                "$ref": "#/components/schemas/UpdateOrganization"
               }
             }
           },
@@ -4811,7 +4811,7 @@
           "Organization"
         ],
         "summary": "Change plan",
-        "description": "Upgrades or downgrades the organization's plan.\r\nAccepts parameters via JSON body (preferred) or query string (legacy).",
+        "description": "Upgrades or downgrades the organization's plan.\nAccepts parameters via JSON body (preferred) or query string (legacy).",
         "parameters": [
           {
             "name": "id",
@@ -7986,6 +7986,16 @@
           },
           "delete_bot_data_enabled": {
             "type": "boolean"
+          },
+          "ingest_limit": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/ProjectIngestLimit"
+              }
+            ]
           }
         }
       },
@@ -8236,6 +8246,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's effective monthly event allowance.\nExample: [50, 80, 90]."
+          }
+        }
+      },
       "PersistentEvent": {
         "required": [
           "organization_id",
@@ -8301,7 +8332,7 @@
               "null",
               "string"
             ],
-            "description": "The event type (ie. error, log message, feature usage). Check KnownTypes for standard event types.\r\nNullable in transit; the pipeline infers a default before save. Validated as required on repository save."
+            "description": "The event type (ie. error, log message, feature usage). Check KnownTypes for standard event types.\nNullable in transit; the pipeline infers a default before save. Validated as required on repository save."
           },
           "source": {
             "maxLength": 2000,
@@ -8458,6 +8489,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"
+        ]
+      },
       "ResetPasswordModel": {
         "required": [
           "password_reset_token",
@@ -8758,6 +8825,18 @@
         },
         "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
       },
+      "UpdateOrganization": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "budget_alert_settings": {
+            "$ref": "#/components/schemas/OrganizationBudgetAlertSettings"
+          }
+        },
+        "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
+      },
       "UpdateProject": {
         "type": "object",
         "properties": {
@@ -8766,6 +8845,9 @@
           },
           "delete_bot_data_enabled": {
             "type": "boolean"
+          },
+          "ingest_limit": {
+            "$ref": "#/components/schemas/ProjectIngestLimit"
           }
         },
         "description": "A class the tracks changes (i.e. the Delta) for a particular TEntityType."
@@ -9350,6 +9432,16 @@
           },
           "is_over_request_limit": {
             "type": "boolean"
+          },
+          "budget_alert_settings": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/OrganizationBudgetAlertSettings"
+              }
+            ]
           }
         }
       },
@@ -9366,6 +9458,7 @@
           "event_count",
           "has_premium_features",
           "has_slack_integration",
+          "is_smart_throttled",
           "usage_hours",
           "usage"
         ],
@@ -9430,6 +9523,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/Controllers/OrganizationControllerTests.cs b/tests/Exceptionless.Tests/Controllers/OrganizationControllerTests.cs
index 93c4faf491..74f61a0881 100644
--- a/tests/Exceptionless.Tests/Controllers/OrganizationControllerTests.cs
+++ b/tests/Exceptionless.Tests/Controllers/OrganizationControllerTests.cs
@@ -1566,4 +1566,27 @@ public async Task PatchAsync_EmptyJsonBody_ReturnsOriginalOrganizationUnchanged(
         Assert.Equal(originalOrganization.Name, updated.Name);
         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);
+
+        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);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Controllers/ProjectControllerTests.cs b/tests/Exceptionless.Tests/Controllers/ProjectControllerTests.cs
index 3859a0f3ac..628f876d2f 100644
--- a/tests/Exceptionless.Tests/Controllers/ProjectControllerTests.cs
+++ b/tests/Exceptionless.Tests/Controllers/ProjectControllerTests.cs
@@ -1116,4 +1116,93 @@ 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 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);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs b/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
index fb07d885e1..2dfb03fb5e 100644
--- a/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
+++ b/tests/Exceptionless.Tests/Jobs/EventPostJobTests.cs
@@ -268,4 +268,63 @@ 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 = 0 };
+        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_DiscardsEvents()
+    {
+        // Add a second project so smart throttle's projectCount > 1 condition is met
+        var secondProject = _projectData.GenerateProject(generateId: true, organizationId: TestConstants.OrganizationId);
+        await _projectRepository.AddAsync(secondProject, o => o.ImmediateConsistency().Cache());
+
+        var organization = await _organizationRepository.GetByIdAsync(TestConstants.OrganizationId);
+        Assert.NotNull(organization);
+        // Set a finite plan limit so smart throttle can activate (UnlimitedPlan has -1 which bypasses throttle)
+        organization.MaxEventsPerMonth = 750;
+        // usageRatio = 650/750 = 0.867 > 0.8 — triggers smart throttle evaluation
+        organization.GetCurrentUsage(TimeProvider).Total = 650;
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache());
+
+        var project = await _projectRepository.GetByIdAsync(TestConstants.ProjectId);
+        Assert.NotNull(project);
+        // fairShare = 750/2 = 375; fairShareRatio = 800/375 = 2.13 > 2.0 — throttle applies
+        project.GetCurrentUsage(TimeProvider).Total = 800;
+        await _projectRepository.SaveAsync(project, o => o.ImmediateConsistency().Cache());
+
+        // Verify smart throttle conditions are met before running the job
+        var throttleResult = await _usageService.GetSmartThrottleRateAsync(TestConstants.OrganizationId, TestConstants.ProjectId);
+        Assert.True(throttleResult.IsThrottled, $"Smart throttle should be active (fairShareRatio={throttleResult.FairShareRatio:F2}, sampleRate={throttleResult.SampleRate:F2})");
+
+        var events = Enumerable.Range(0, 5).Select(_ => GenerateEvent()).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.Discarded > 0, $"Expected discarded events, but got: total={usage.CurrentUsage.Total}, blocked={usage.CurrentUsage.Blocked}, discarded={usage.CurrentUsage.Discarded}");
+
+        await RefreshDataAsync();
+        Assert.True(await _eventRepository.CountAsync() < 5);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Mail/CountingMailer.cs b/tests/Exceptionless.Tests/Mail/CountingMailer.cs
index 96d5671c3f..e8d6cb8b19 100644
--- a/tests/Exceptionless.Tests/Mail/CountingMailer.cs
+++ b/tests/Exceptionless.Tests/Mail/CountingMailer.cs
@@ -50,6 +50,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/Mail/NullMailer.cs b/tests/Exceptionless.Tests/Mail/NullMailer.cs
index 826be1324d..38b1bb04ad 100644
--- a/tests/Exceptionless.Tests/Mail/NullMailer.cs
+++ b/tests/Exceptionless.Tests/Mail/NullMailer.cs
@@ -30,6 +30,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/Services/UsageServiceTests.cs b/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
index 8a54c6cbd7..473708cca5 100644
--- a/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
+++ b/tests/Exceptionless.Tests/Services/UsageServiceTests.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using Exceptionless.Core.Billing;
 using Exceptionless.Core.Extensions;
@@ -655,4 +656,516 @@ public async Task RunBenchmarkAsync()
         sw.Stop();
         _logger.LogInformation("Time: {Duration:g}, Avg: ({AverageTickDuration:g}ticks | {AverageDuration}ms)", sw.Elapsed, sw.ElapsedTicks / iterations, sw.ElapsedMilliseconds / iterations);
     }
+
+    [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 nonExistentOrgId = "000000000000000000000099";
+        string nonExistentProjectId = "000000000000000000000098";
+
+        // Act - this would divide by zero before the fix (maxEventsPerMonth=0 returned for missing org)
+        var result = await _usageService.GetSmartThrottleRateAsync(nonExistentOrgId, 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_ReturnsOrgLimit()
+    {
+        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.IsOverOrgLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithFixedIngestLimit_BelowOrgLimit_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.IsOverOrgLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithFixedIngestLimit_AboveOrgLimit_ReturnsOrgLimit()
+    {
+        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(10000, result.EffectiveProjectLimit);
+        Assert.False(result.IsOverOrgLimit);
+        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.IsOverOrgLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Project_WithPercentageIngestLimit_150Percent_CappedAtOrgLimit()
+    {
+        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 = 150 }
+        }, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetEventIngestAllowanceAsync(organization.Id, project.Id);
+
+        Assert.Equal(1500, result.EffectiveProjectLimit);
+        Assert.True(result.EventsLeft <= 1000);
+        Assert.False(result.IsOverOrgLimit);
+        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.IsOverOrgLimit);
+        Assert.Equal(100, result.EffectiveProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_Organization_OverLimit_IsOverOrgLimitTrue()
+    {
+        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.IsOverOrgLimit);
+        Assert.False(result.IsOverProjectLimit);
+    }
+
+    [Fact]
+    public async Task GetEventIngestAllowanceAsync_UnlimitedOrg_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.IsOverOrgLimit);
+        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_SingleProjectInOrg_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_NoOrgUsage_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_AboveThreshold_2xFairShare_SampleRateHalf()
+    {
+        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 = 1250 → fairShareRatio = 2.5; sampleRate = 1/2.5 = 0.4
+        project1.GetCurrentUsage(TimeProvider).Total = 1250;
+        await _projectRepository.SaveAsync(project1, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.True(result.IsThrottled);
+        Assert.InRange(result.SampleRate, 0.35, 0.55);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_AboveThreshold_4xFairShare_SampleRateQuarter()
+    {
+        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 = 2000 → fairShareRatio = 4.0; sampleRate = 1/4 = 0.25
+        project1.GetCurrentUsage(TimeProvider).Total = 2000;
+        await _projectRepository.SaveAsync(project1, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.True(result.IsThrottled);
+        Assert.Equal(0.25, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_AboveThreshold_10xFairShare_SampleRateMin()
+    {
+        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 = 5000 → fairShareRatio = 10.0; sampleRate = max(0.1, 0.1) = 0.1
+        project1.GetCurrentUsage(TimeProvider).Total = 5000;
+        await _projectRepository.SaveAsync(project1, o => o.ImmediateConsistency().Cache());
+
+        var result = await _usageService.GetSmartThrottleRateAsync(organization.Id, project1.Id);
+
+        Assert.True(result.IsThrottled);
+        Assert.Equal(0.1, result.SampleRate);
+        _ = project2;
+    }
+
+    [Fact]
+    public async Task GetSmartThrottleRateAsync_UnlimitedOrg_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 =>
+        {
+            alertCount++;
+            if (alertCount == 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 IncrementAsync (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>(_ =>
+        {
+            alertCount++;
+            if (alertCount == 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>(_ => { 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)");
+    }
 }