diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6346714..4546a0d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,9 +1,6 @@
 name: CI
 
 on:
-  push:
-    branches:
-      - "**"
   pull_request:
     branches:
       - "**"
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 0ee3a5c..2a77d19 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -10,7 +10,7 @@
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="[10.0.0, 11.0.0)" />
     <PackageVersion Include="Microsoft.Extensions.Options" Version="[10.0.0, 11.0.0)" />
     <PackageVersion Include="Microsoft.Extensions.TimeProvider.Testing" Version="10.5.0" />
-    <PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="[10.0.0, 11.0.0)" />
     <PackageVersion Include="Microsoft.Testing.Extensions.CodeCoverage" Version="18.6.2" />
     <PackageVersion Include="Microsoft.Testing.Platform" Version="2.2.1" />
     <PackageVersion Include="Cronos" Version="0.12.0" />
@@ -19,4 +19,4 @@
     <PackageVersion Include="Testcontainers.PostgreSql" Version="4.11.0" />
     <PackageVersion Include="xunit.v3.mtp-v2" Version="3.2.2" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/README.md b/README.md
index 4fb2f26..8455f2d 100644
--- a/README.md
+++ b/README.md
@@ -69,28 +69,37 @@ dotnet add package Sheddueller.Testing
 
 Register `AddSheddueller(...)` in processes that only submit work or manage schedules. Register `AddShedduellerWorker(...)` in processes that should also execute jobs.
 
+`WorkerOptions` below is an application options type; the callback can read any service registered with DI.
+
 ```csharp
-using Npgsql;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using Sheddueller;
 using Sheddueller.Postgres;
 
-var dataSource = NpgsqlDataSource.Create(
-    builder.Configuration.GetConnectionString("Sheddueller")
-        ?? throw new InvalidOperationException("Missing Sheddueller connection string."));
-
-builder.Services.AddSingleton(dataSource);
+builder.Services.Configure<WorkerOptions>(
+    builder.Configuration.GetSection("Worker"));
 builder.Services.AddTransient<EmailJobs>();
 
 builder.Services.AddShedduellerWorker(sheddueller => sheddueller
-    .UsePostgres(postgres =>
-    {
-        postgres.DataSource = dataSource;
-        postgres.SchemaName = "sheddueller";
-    })
-    .ConfigureOptions(options =>
+    .UsePostgres(
+        serviceProvider =>
+        {
+            var configuration = serviceProvider.GetRequiredService<IConfiguration>();
+            return configuration.GetConnectionString("Sheddueller")
+                ?? throw new InvalidOperationException("Connection string 'ConnectionStrings:Sheddueller' is required.");
+        },
+        (serviceProvider, postgres) =>
+        {
+            var configuration = serviceProvider.GetRequiredService<IConfiguration>();
+            postgres.SchemaName = configuration["Sheddueller:Postgres:SchemaName"] ?? "sheddueller";
+        })
+    .ConfigureOptions((serviceProvider, options) =>
     {
+        var worker = serviceProvider.GetRequiredService<IOptions<WorkerOptions>>().Value;
         options.NodeId = Environment.MachineName;
-        options.MaxConcurrentExecutionsPerNode = 8;
+        options.MaxConcurrentExecutionsPerNode = worker.MaxConcurrentExecutions;
         options.DefaultRetryPolicy = new RetryPolicy(
             MaxAttempts: 3,
             BackoffKind: RetryBackoffKind.Exponential,
@@ -102,11 +111,13 @@ builder.Services.AddShedduellerWorker(sheddueller => sheddueller
 Schema migrations are explicit:
 
 ```csharp
-await app.Services.GetRequiredService<IPostgresMigrator>().ApplyAsync();
+await app.ApplyShedduellerPostgresMigrationsAsync();
 ```
 
 Run migrations during deployment or before starting workers against a new schema. Normal startup validates the configured provider; it does not silently create the schema.
 
+Use `UsePostgres(postgres => postgres.DataSource = dataSource)` when an application needs to share or own a prebuilt `NpgsqlDataSource`; in that mode, the application also owns disposal.
+
 ## Enqueue Jobs
 
 Job methods return `Task` or `ValueTask` and receive the scheduler-owned `CancellationToken`. Use `Job.Context` when a handler needs durable logs, progress events, the job id, or the attempt number.
@@ -164,7 +175,7 @@ builder.Services.AddShedduellerDashboard(options =>
 });
 
 app.UseAntiforgery();
-((IApplicationBuilder)app).MapShedduellerDashboard("/sheddueller");
+app.MapShedduellerDashboard("/sheddueller");
 ```
 
 The dashboard uses the configured Sheddueller provider and can be hosted by a worker process or a client-only web process.
diff --git a/docs/.gitkeep b/docs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/samples/Sheddueller.SampleHost/Program.cs b/samples/Sheddueller.SampleHost/Program.cs
index 9687f39..f30c2eb 100644
--- a/samples/Sheddueller.SampleHost/Program.cs
+++ b/samples/Sheddueller.SampleHost/Program.cs
@@ -1,5 +1,3 @@
-using Npgsql;
-
 using Sheddueller;
 using Sheddueller.Inspection.Jobs;
 using Sheddueller.Postgres;
@@ -9,21 +7,22 @@
 
 var builder = WebApplication.CreateBuilder(args);
 
-var connectionString = builder.Configuration.GetConnectionString("Sheddueller")
-    ?? throw new InvalidOperationException("Connection string 'ConnectionStrings:Sheddueller' is required.");
-var schemaName = builder.Configuration["Sheddueller:Postgres:SchemaName"] ?? "sheddueller";
-await using var dataSource = NpgsqlDataSource.Create(connectionString);
-
-builder.Services.AddSingleton(dataSource);
 builder.Services.AddSingleton<DemoJobState>();
 builder.Services.AddTransient<DemoJobService>();
 
 builder.Services.AddShedduellerWorker(sheddueller => sheddueller
-  .UsePostgres(options =>
-  {
-      options.DataSource = dataSource;
-      options.SchemaName = schemaName;
-  })
+  .UsePostgres(
+    serviceProvider =>
+    {
+        var configuration = serviceProvider.GetRequiredService<IConfiguration>();
+        return configuration.GetConnectionString("Sheddueller")
+          ?? throw new InvalidOperationException("Connection string 'ConnectionStrings:Sheddueller' is required.");
+    },
+    (serviceProvider, options) =>
+    {
+        var configuration = serviceProvider.GetRequiredService<IConfiguration>();
+        options.SchemaName = configuration["Sheddueller:Postgres:SchemaName"] ?? "sheddueller";
+    })
   .ConfigureOptions(options =>
   {
       options.NodeId = "sample-host";
@@ -37,7 +36,7 @@
 
 var app = builder.Build();
 
-await app.Services.GetRequiredService<IPostgresMigrator>().ApplyAsync();
+await app.ApplyShedduellerPostgresMigrationsAsync();
 
 app.UseAntiforgery();
 
@@ -170,7 +169,7 @@
     return RedirectWithMessage($"Queued cancelable delayed job {jobId:D} for {notBeforeUtc:O}.");
 });
 
-((IApplicationBuilder)app).MapShedduellerDashboard("/sheddueller");
+app.MapShedduellerDashboard("/sheddueller");
 
 await app.RunAsync();
 
diff --git a/samples/Sheddueller.SampleHost/Sheddueller.SampleHost.csproj b/samples/Sheddueller.SampleHost/Sheddueller.SampleHost.csproj
index 20b8cb6..1955927 100644
--- a/samples/Sheddueller.SampleHost/Sheddueller.SampleHost.csproj
+++ b/samples/Sheddueller.SampleHost/Sheddueller.SampleHost.csproj
@@ -10,8 +10,4 @@
     <ProjectReference Include="..\..\src\Sheddueller.Postgres\Sheddueller.Postgres.csproj" />
     <ProjectReference Include="..\..\src\Sheddueller.Worker\Sheddueller.Worker.csproj" />
   </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Npgsql" />
-  </ItemGroup>
 </Project>
diff --git a/samples/Sheddueller.SampleHost/appsettings.Development.json b/samples/Sheddueller.SampleHost/appsettings.Development.json
index 34f00ef..c39a972 100644
--- a/samples/Sheddueller.SampleHost/appsettings.Development.json
+++ b/samples/Sheddueller.SampleHost/appsettings.Development.json
@@ -1,4 +1,5 @@
 {
+  "DetailedErrors": true,
   "Logging": {
     "LogLevel": {
       "Default": "Debug",
diff --git a/src/Sheddueller.Dashboard/Components/DashboardApp.razor b/src/Sheddueller.Dashboard/Components/DashboardApp.razor
index 17f11a6..1175756 100644
--- a/src/Sheddueller.Dashboard/Components/DashboardApp.razor
+++ b/src/Sheddueller.Dashboard/Components/DashboardApp.razor
@@ -1,4 +1,5 @@
 @inject NavigationManager Navigation
+@inject Microsoft.Extensions.Options.IOptions<ShedduellerDashboardOptions> DashboardOptions
 
 <!DOCTYPE html>
 <html lang="en">
@@ -13,7 +14,14 @@
     <link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:wght,FILL@100..700,0..1&amp;display=swap" rel="stylesheet" />
 </head>
 <body>
-    <Routes @rendermode="InteractiveServer" />
+    <Routes @rendermode="DashboardRenderMode" />
     <script src="_framework/blazor.web.js"></script>
 </body>
 </html>
+
+@code {
+    private IComponentRenderMode DashboardRenderMode
+      => DashboardOptions.Value.Prerender
+        ? InteractiveServer
+        : new InteractiveServerRenderMode(prerender: false);
+}
diff --git a/src/Sheddueller.Dashboard/Components/Pages/Schedules.razor b/src/Sheddueller.Dashboard/Components/Pages/Schedules.razor
index 8e80127..b6085ae 100644
--- a/src/Sheddueller.Dashboard/Components/Pages/Schedules.razor
+++ b/src/Sheddueller.Dashboard/Components/Pages/Schedules.razor
@@ -44,6 +44,10 @@
         {
             <DashboardInlineAlert CssClass="@ActionAlertClass" Icon="@ActionAlertIcon">
                 <span>@_actionMessage</span>
+                @if (_triggeredJobId is { } triggeredJobId)
+                {
+                    <a class="schedules-action-alert__job" href="@JobHref(triggeredJobId)">@triggeredJobId.ToString("D")</a>
+                }
             </DashboardInlineAlert>
         }
 
@@ -140,6 +144,11 @@
                                     </td>
                                     <td>
                                         <div class="schedules-actions">
+                                            <button class="schedules-icon-button" type="button" title="Trigger Now"
+                                                    aria-label="@TriggerLabel(schedule)"
+                                                    @onclick="@(() => TriggerNowAsync(schedule))" disabled="@IsActionDisabled">
+                                                <span class="material-symbols-outlined" aria-hidden="true">play_arrow</span>
+                                            </button>
                                             <button class="schedules-icon-button" type="button" title="@PauseResumeTitle(schedule)"
                                                     aria-label="@PauseResumeLabel(schedule)"
                                                     @onclick="@(() => PauseOrResumeAsync(schedule))" disabled="@IsActionDisabled">
@@ -171,6 +180,10 @@
         align-items: center;
     }
 
+    .schedules-actions {
+        gap: 4px;
+    }
+
     .schedules-header {
         justify-content: space-between;
         gap: 16px;
@@ -234,7 +247,18 @@
         color: var(--sd-success);
     }
 
+    .schedules-inline-alert--warning {
+        border-color: var(--sd-warning);
+        background: var(--sd-warning-container);
+        color: var(--sd-warning);
+    }
+
+    .schedules-inline-alert--warning .material-symbols-outlined {
+        color: var(--sd-warning);
+    }
+
     .schedules-action-alert__job {
+        color: inherit;
         font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
         text-decoration: underline;
         text-underline-offset: 2px;
@@ -311,7 +335,7 @@
     }
 
     .schedules-table__col--actions {
-        width: 96px;
+        width: 112px;
     }
 
     .schedules-table thead {
@@ -504,24 +528,34 @@
 @code {
     private static readonly TimeSpan PageRefreshInterval = TimeSpan.FromSeconds(5);
     private const int DefaultPageSize = 25;
+    internal const string ScheduleNotFoundActionFailureMessage = "Schedule action failed: Schedule was not found.";
 
     private readonly DashboardScheduleFilters _filters = new();
     private readonly List<ScheduleInspectionSummary> _schedules = [];
     private ScheduleInspectionPage? _page;
     private string? _loadError;
     private string? _actionMessage;
-    private bool _actionSucceeded;
+    private Guid? _triggeredJobId;
+    private ScheduleActionSeverity _actionSeverity = ScheduleActionSeverity.Success;
     private bool _isLoading;
     private bool _isLoadingMore;
     private bool _isActionRunning;
 
     private string ActionAlertClass
-      => this._actionSucceeded
-        ? "schedules-inline-alert schedules-inline-alert--success"
-        : "schedules-inline-alert schedules-inline-alert--error";
+      => this._actionSeverity switch
+      {
+          ScheduleActionSeverity.Success => "schedules-inline-alert schedules-inline-alert--success",
+          ScheduleActionSeverity.Warning => "schedules-inline-alert schedules-inline-alert--warning",
+          _ => "schedules-inline-alert schedules-inline-alert--error",
+      };
 
     private string ActionAlertIcon
-      => this._actionSucceeded ? "check_circle" : "warning";
+      => this._actionSeverity switch
+      {
+          ScheduleActionSeverity.Success => "check_circle",
+          ScheduleActionSeverity.Warning => "info",
+          _ => "warning",
+      };
 
     private bool IsActionDisabled
       => this._isActionRunning || this._isLoading || this._isLoadingMore;
@@ -674,6 +708,48 @@
         }
     }
 
+    private async Task TriggerNowAsync(ScheduleInspectionSummary schedule)
+    {
+        if (this._isActionRunning)
+        {
+            return;
+        }
+
+        this._isActionRunning = true;
+        this.ClearActionAlert();
+
+        try
+        {
+            var result = await ScheduleManager.TriggerAsync(schedule.ScheduleKey);
+            switch (result.Status)
+            {
+                case RecurringScheduleTriggerStatus.Enqueued:
+                    this.SetActionSuccess(CreateTriggerSuccessMessage(schedule.ScheduleKey), result.JobId);
+                    await this.LiveRefresh.RefreshNowAsync();
+                    break;
+                case RecurringScheduleTriggerStatus.SkippedActiveOccurrence:
+                    this.SetActionWarning(CreateTriggerSkippedMessage(schedule.ScheduleKey));
+                    break;
+                case RecurringScheduleTriggerStatus.NotFound:
+                    this.SetActionFailure(ScheduleNotFoundActionFailureMessage);
+                    break;
+                default:
+                    this.SetActionFailure(string.Create(
+                      CultureInfo.InvariantCulture,
+                      $"Schedule action failed: Trigger returned unsupported status {result.Status}."));
+                    break;
+            }
+        }
+        catch (Exception exception)
+        {
+            this.SetActionFailure(string.Create(CultureInfo.InvariantCulture, $"Schedule action failed: {exception.Message}"));
+        }
+        finally
+        {
+            this._isActionRunning = false;
+        }
+    }
+
     private async Task RefreshCurrentQueryAsync(CancellationToken cancellationToken)
     {
         var visiblePageSize = Math.Max(DefaultPageSize, this._schedules.Count);
@@ -696,20 +772,32 @@ cancellationToken);
         this._loadError = null;
     }
 
-    private void SetActionSuccess(string message)
+    private void SetActionSuccess(string message, Guid? triggeredJobId = null)
     {
-        this._actionSucceeded = true;
+        this._actionSeverity = ScheduleActionSeverity.Success;
         this._actionMessage = message;
+        this._triggeredJobId = triggeredJobId;
+    }
+
+    private void SetActionWarning(string message)
+    {
+        this._actionSeverity = ScheduleActionSeverity.Warning;
+        this._actionMessage = message;
+        this._triggeredJobId = null;
     }
 
     private void SetActionFailure(string message)
     {
-        this._actionSucceeded = false;
+        this._actionSeverity = ScheduleActionSeverity.Error;
         this._actionMessage = message;
+        this._triggeredJobId = null;
     }
 
     private void ClearActionAlert()
-      => this._actionMessage = null;
+    {
+        this._actionMessage = null;
+        this._triggeredJobId = null;
+    }
 
     private static string FullHandler(ScheduleInspectionSummary schedule)
       => string.Concat(schedule.ServiceType, ".", schedule.MethodName);
@@ -758,4 +846,23 @@ cancellationToken);
 
     private static string PauseResumeLabel(ScheduleInspectionSummary schedule)
       => string.Create(CultureInfo.InvariantCulture, $"{PauseResumeTitle(schedule)} {schedule.ScheduleKey}");
+
+    private static string TriggerLabel(ScheduleInspectionSummary schedule)
+      => string.Create(CultureInfo.InvariantCulture, $"Trigger Now {schedule.ScheduleKey}");
+
+    internal static string CreateTriggerSuccessMessage(string scheduleKey)
+      => string.Create(CultureInfo.InvariantCulture, $"Schedule {scheduleKey} triggered as job");
+
+    internal static string CreateTriggerSkippedMessage(string scheduleKey)
+      => string.Create(CultureInfo.InvariantCulture, $"Schedule {scheduleKey} already has an active occurrence.");
+
+    private static string JobHref(Guid jobId)
+      => string.Create(CultureInfo.InvariantCulture, $"jobs/{jobId:D}");
+
+    private enum ScheduleActionSeverity
+    {
+        Success,
+        Warning,
+        Error,
+    }
 }
diff --git a/src/Sheddueller.Dashboard/ShedduellerDashboardEndpointRouteBuilderExtensions.cs b/src/Sheddueller.Dashboard/ShedduellerDashboardEndpointRouteBuilderExtensions.cs
index 335d630..45c2140 100644
--- a/src/Sheddueller.Dashboard/ShedduellerDashboardEndpointRouteBuilderExtensions.cs
+++ b/src/Sheddueller.Dashboard/ShedduellerDashboardEndpointRouteBuilderExtensions.cs
@@ -18,6 +18,22 @@ namespace Microsoft.AspNetCore.Builder;
 /// </summary>
 public static class ShedduellerDashboardEndpointRouteBuilderExtensions
 {
+    /// <summary>
+    /// Maps the dashboard UI and live update hub under the supplied path using minimal hosting.
+    /// </summary>
+    /// <param name="app">The web application to map the dashboard branch on.</param>
+    /// <param name="path">The absolute route path for the dashboard root.</param>
+    /// <returns>The same web application for chained registration.</returns>
+    public static WebApplication MapShedduellerDashboard(
+        this WebApplication app,
+        string path = "/sheddueller")
+    {
+        ArgumentNullException.ThrowIfNull(app);
+
+        ((IApplicationBuilder)app).MapShedduellerDashboard(path);
+        return app;
+    }
+
     /// <summary>
     /// Maps the dashboard UI and live update hub under the supplied path using an application branch.
     /// </summary>
diff --git a/src/Sheddueller.Dashboard/ShedduellerDashboardOptions.cs b/src/Sheddueller.Dashboard/ShedduellerDashboardOptions.cs
index b514e92..6e81e33 100644
--- a/src/Sheddueller.Dashboard/ShedduellerDashboardOptions.cs
+++ b/src/Sheddueller.Dashboard/ShedduellerDashboardOptions.cs
@@ -5,6 +5,14 @@ namespace Sheddueller.Dashboard;
 /// </summary>
 public sealed class ShedduellerDashboardOptions
 {
+    /// <summary>
+    /// Gets or sets whether dashboard routes are prerendered into the initial HTTP response.
+    /// Defaults to <see langword="false" />.
+    /// Prerendering can conflict with certain browser extensions, such as React Developer Tools,
+    /// and may cause the dashboard to fail to load.
+    /// </summary>
+    public bool Prerender { get; set; }
+
     /// <summary>
     /// Gets or sets how long job events are retained after their owning job reaches a terminal state.
     /// </summary>
diff --git a/src/Sheddueller.Postgres/Internal/Operations/PostgresSchedules.cs b/src/Sheddueller.Postgres/Internal/Operations/PostgresSchedules.cs
index 47e6214..e8c978a 100644
--- a/src/Sheddueller.Postgres/Internal/Operations/PostgresSchedules.cs
+++ b/src/Sheddueller.Postgres/Internal/Operations/PostgresSchedules.cs
@@ -321,7 +321,7 @@ select 1
         return (bool)(await command.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) ?? false);
     }
 
-    public static async ValueTask InsertMaterializedJobAsync(
+    public static async ValueTask<long> InsertMaterializedJobAsync(
         PostgresOperationContext context,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction,
@@ -332,9 +332,9 @@ public static async ValueTask InsertMaterializedJobAsync(
         ScheduleOccurrenceKind occurrenceKind,
         CancellationToken cancellationToken)
     {
-        await PostgresOperationContext.ExecuteCountAsync(
-          connection,
-          transaction,
+        await using var command = connection.CreateCommand();
+        command.Transaction = transaction;
+        command.CommandText =
           $"""
           insert into {context.Names.Jobs} (
               job_id,
@@ -375,32 +375,32 @@ await PostgresOperationContext.ExecuteCountAsync(
               @retry_max_delay_ms,
               @source_schedule_key,
               @scheduled_fire_at_utc,
-              @schedule_occurrence_kind);
-          """,
-          command =>
-          {
-              command.Parameters.AddWithValue("job_id", jobId);
-              command.Parameters.AddWithValue("priority", schedule.Priority);
-              command.Parameters.AddWithValue("service_type", schedule.ServiceType);
-              command.Parameters.AddWithValue("method_name", schedule.MethodName);
-              command.Parameters.AddWithValue("method_parameter_types", schedule.MethodParameterTypes.ToArray());
-              command.Parameters.AddWithValue("invocation_target_kind", PostgresConversion.ToText(schedule.InvocationTargetKind));
-              command.Parameters.AddWithValue(
-                "method_parameter_bindings",
-                NpgsqlDbType.Array | NpgsqlDbType.Text,
-                PostgresOperationContext.ToDbValue(schedule.MethodParameterBindings?.Select(PostgresConversion.ToText).ToArray()));
-              command.Parameters.AddWithValue("serialized_arguments_content_type", schedule.SerializedArguments.ContentType);
-              command.Parameters.AddWithValue("serialized_arguments", schedule.SerializedArguments.Data);
-              command.Parameters.AddWithValue("max_attempts", retry.MaxAttempts);
-              command.Parameters.AddWithValue("retry_backoff_kind", PostgresOperationContext.ToDbValue(PostgresConversion.ToText(retry.BackoffKind)));
-              command.Parameters.AddWithValue("retry_base_delay_ms", PostgresOperationContext.ToDbValue(PostgresConversion.ToMilliseconds(retry.BaseDelay)));
-              command.Parameters.AddWithValue("retry_max_delay_ms", PostgresOperationContext.ToDbValue(PostgresConversion.ToMilliseconds(retry.MaxDelay)));
-              command.Parameters.AddWithValue("source_schedule_key", schedule.ScheduleKey);
-              command.Parameters.AddWithValue("scheduled_fire_at_utc", PostgresOperationContext.ToDbValue(scheduledFireAtUtc));
-              command.Parameters.AddWithValue("schedule_occurrence_kind", PostgresConversion.ToText(occurrenceKind));
-          },
-          cancellationToken)
-          .ConfigureAwait(false);
+              @schedule_occurrence_kind)
+          returning enqueue_sequence;
+          """;
+        command.Parameters.AddWithValue("job_id", jobId);
+        command.Parameters.AddWithValue("priority", schedule.Priority);
+        command.Parameters.AddWithValue("service_type", schedule.ServiceType);
+        command.Parameters.AddWithValue("method_name", schedule.MethodName);
+        command.Parameters.AddWithValue("method_parameter_types", schedule.MethodParameterTypes.ToArray());
+        command.Parameters.AddWithValue("invocation_target_kind", PostgresConversion.ToText(schedule.InvocationTargetKind));
+        command.Parameters.AddWithValue(
+          "method_parameter_bindings",
+          NpgsqlDbType.Array | NpgsqlDbType.Text,
+          PostgresOperationContext.ToDbValue(schedule.MethodParameterBindings?.Select(PostgresConversion.ToText).ToArray()));
+        command.Parameters.AddWithValue("serialized_arguments_content_type", schedule.SerializedArguments.ContentType);
+        command.Parameters.AddWithValue("serialized_arguments", schedule.SerializedArguments.Data);
+        command.Parameters.AddWithValue("max_attempts", retry.MaxAttempts);
+        command.Parameters.AddWithValue("retry_backoff_kind", PostgresOperationContext.ToDbValue(PostgresConversion.ToText(retry.BackoffKind)));
+        command.Parameters.AddWithValue("retry_base_delay_ms", PostgresOperationContext.ToDbValue(PostgresConversion.ToMilliseconds(retry.BaseDelay)));
+        command.Parameters.AddWithValue("retry_max_delay_ms", PostgresOperationContext.ToDbValue(PostgresConversion.ToMilliseconds(retry.MaxDelay)));
+        command.Parameters.AddWithValue("source_schedule_key", schedule.ScheduleKey);
+        command.Parameters.AddWithValue("scheduled_fire_at_utc", PostgresOperationContext.ToDbValue(scheduledFireAtUtc));
+        command.Parameters.AddWithValue("schedule_occurrence_kind", PostgresConversion.ToText(occurrenceKind));
+
+        var enqueueSequence = (long)(await command.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false)
+          ?? throw new InvalidOperationException("PostgreSQL did not return an enqueue sequence for the materialized job."));
+
         await PostgresJobGroups.ReplaceJobGroupsAsync(context, connection, transaction, jobId, schedule.ConcurrencyGroupKeys, cancellationToken)
           .ConfigureAwait(false);
         await PostgresJobTags.ReplaceJobTagsAsync(context, connection, transaction, jobId, schedule.Tags, cancellationToken)
@@ -412,6 +412,8 @@ await PostgresJobEvents.AppendAndNotifyInTransactionAsync(
           new AppendJobEventRequest(jobId, JobEventKind.Lifecycle, AttemptNumber: 0, Message: "Queued"),
           cancellationToken)
           .ConfigureAwait(false);
+
+        return enqueueSequence;
     }
 
     private static async ValueTask ReplaceScheduleGroupsAsync(
diff --git a/src/Sheddueller.Postgres/Internal/Operations/TriggerRecurringScheduleOperation.cs b/src/Sheddueller.Postgres/Internal/Operations/TriggerRecurringScheduleOperation.cs
new file mode 100644
index 0000000..c675c8c
--- /dev/null
+++ b/src/Sheddueller.Postgres/Internal/Operations/TriggerRecurringScheduleOperation.cs
@@ -0,0 +1,56 @@
+namespace Sheddueller.Postgres.Internal.Operations;
+
+using Sheddueller;
+using Sheddueller.Storage;
+
+internal static class TriggerRecurringScheduleOperation
+{
+    public static async ValueTask<RecurringScheduleTriggerResult> ExecuteAsync(
+        PostgresOperationContext context,
+        TriggerRecurringScheduleRequest request,
+        CancellationToken cancellationToken)
+    {
+        await using var connection = await context.OpenConnectionAsync(cancellationToken).ConfigureAwait(false);
+        await using var transaction = await connection.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
+        var schedule = await PostgresSchedules.ReadScheduleDefinitionForUpdateAsync(
+          context,
+          connection,
+          transaction,
+          request.ScheduleKey,
+          cancellationToken)
+          .ConfigureAwait(false);
+
+        if (schedule is null)
+        {
+            await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
+            return new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.NotFound);
+        }
+
+        if (schedule.OverlapMode == RecurringOverlapMode.Skip
+          && await PostgresSchedules.HasNonTerminalOccurrenceAsync(context, connection, transaction, schedule.ScheduleKey, cancellationToken)
+            .ConfigureAwait(false))
+        {
+            await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
+            return new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.SkippedActiveOccurrence);
+        }
+
+        var retry = PostgresRetryPolicies.Normalize(schedule.RetryPolicy ?? request.DefaultRetryPolicy);
+        var jobId = Guid.NewGuid();
+        var enqueueSequence = await PostgresSchedules.InsertMaterializedJobAsync(
+          context,
+          connection,
+          transaction,
+          schedule,
+          retry,
+          jobId,
+          scheduledFireAtUtc: null,
+          occurrenceKind: ScheduleOccurrenceKind.ManualTrigger,
+          cancellationToken)
+          .ConfigureAwait(false);
+
+        await context.NotifyAsync(connection, transaction, cancellationToken).ConfigureAwait(false);
+        await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
+
+        return new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.Enqueued, jobId, enqueueSequence);
+    }
+}
diff --git a/src/Sheddueller.Postgres/Internal/OwnedPostgresDataSource.cs b/src/Sheddueller.Postgres/Internal/OwnedPostgresDataSource.cs
new file mode 100644
index 0000000..1194e58
--- /dev/null
+++ b/src/Sheddueller.Postgres/Internal/OwnedPostgresDataSource.cs
@@ -0,0 +1,18 @@
+namespace Sheddueller.Postgres.Internal;
+
+using Npgsql;
+
+internal sealed class OwnedPostgresDataSource(
+    NpgsqlDataSource dataSource,
+    string schemaName) : IDisposable, IAsyncDisposable
+{
+    public NpgsqlDataSource DataSource { get; } = dataSource;
+
+    public string SchemaName { get; } = schemaName;
+
+    public void Dispose()
+      => this.DataSource.Dispose();
+
+    public ValueTask DisposeAsync()
+      => this.DataSource.DisposeAsync();
+}
diff --git a/src/Sheddueller.Postgres/Internal/PostgresJobStore.cs b/src/Sheddueller.Postgres/Internal/PostgresJobStore.cs
index 79b0026..eefa7fc 100644
--- a/src/Sheddueller.Postgres/Internal/PostgresJobStore.cs
+++ b/src/Sheddueller.Postgres/Internal/PostgresJobStore.cs
@@ -157,6 +157,15 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateRecurringScheduleA
         return CreateOrUpdateRecurringScheduleOperation.ExecuteAsync(this._context, request, cancellationToken);
     }
 
+    public ValueTask<RecurringScheduleTriggerResult> TriggerRecurringScheduleAsync(
+        TriggerRecurringScheduleRequest request,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        return TriggerRecurringScheduleOperation.ExecuteAsync(this._context, request, cancellationToken);
+    }
+
     public ValueTask<bool> DeleteRecurringScheduleAsync(
         string scheduleKey,
         CancellationToken cancellationToken = default)
diff --git a/src/Sheddueller.Postgres/Sheddueller.Postgres.csproj b/src/Sheddueller.Postgres/Sheddueller.Postgres.csproj
index 7ccd99e..37f28c5 100644
--- a/src/Sheddueller.Postgres/Sheddueller.Postgres.csproj
+++ b/src/Sheddueller.Postgres/Sheddueller.Postgres.csproj
@@ -8,6 +8,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
     <PackageReference Include="Npgsql" />
     <PackageReference Include="Microsoft.SourceLink.GitHub">
       <PrivateAssets>all</PrivateAssets>
diff --git a/src/Sheddueller.Postgres/ShedduellerPostgresBuilderExtensions.cs b/src/Sheddueller.Postgres/ShedduellerPostgresBuilderExtensions.cs
index 36e3a3d..9c9e1db 100644
--- a/src/Sheddueller.Postgres/ShedduellerPostgresBuilderExtensions.cs
+++ b/src/Sheddueller.Postgres/ShedduellerPostgresBuilderExtensions.cs
@@ -4,6 +4,8 @@ namespace Microsoft.Extensions.DependencyInjection;
 
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
+using Npgsql;
+
 using Sheddueller;
 using Sheddueller.Inspection.ConcurrencyGroups;
 using Sheddueller.Inspection.Jobs;
@@ -20,6 +22,79 @@ namespace Microsoft.Extensions.DependencyInjection;
 /// </summary>
 public static class ShedduellerPostgresBuilderExtensions
 {
+    /// <summary>
+    /// Uses the PostgreSQL job store provider with a Sheddueller-owned data source.
+    /// </summary>
+    /// <param name="builder">The Sheddueller builder being configured.</param>
+    /// <param name="connectionString">The PostgreSQL connection string.</param>
+    /// <param name="configure">An optional callback for configuring the provider-owned data source.</param>
+    /// <returns>The same builder for chained configuration.</returns>
+    /// <remarks>
+    /// The created <see cref="NpgsqlDataSource"/> is owned by dependency injection and disposed with the
+    /// service provider. Apply provider migrations explicitly before starting workers against a new schema.
+    /// </remarks>
+    public static ShedduellerBuilder UsePostgres(
+        this ShedduellerBuilder builder,
+        string connectionString,
+        Action<ShedduellerPostgresDataSourceOptions>? configure = null)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
+
+        return builder.UsePostgres(
+          _ => connectionString,
+          (_, options) => configure?.Invoke(options));
+    }
+
+    /// <summary>
+    /// Uses the PostgreSQL job store provider with a Sheddueller-owned data source.
+    /// </summary>
+    /// <param name="builder">The Sheddueller builder being configured.</param>
+    /// <param name="connectionStringFactory">A callback that resolves the PostgreSQL connection string from the service provider.</param>
+    /// <param name="configure">An optional callback for configuring the provider-owned data source.</param>
+    /// <returns>The same builder for chained configuration.</returns>
+    /// <remarks>
+    /// The created <see cref="NpgsqlDataSource"/> is owned by dependency injection and disposed with the
+    /// service provider. Apply provider migrations explicitly before starting workers against a new schema.
+    /// </remarks>
+    public static ShedduellerBuilder UsePostgres(
+        this ShedduellerBuilder builder,
+        Func<IServiceProvider, string> connectionStringFactory,
+        Action<IServiceProvider, ShedduellerPostgresDataSourceOptions>? configure = null)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(connectionStringFactory);
+
+        builder.Services.Replace(ServiceDescriptor.Singleton(serviceProvider =>
+        {
+            var options = new ShedduellerPostgresDataSourceOptions();
+            configure?.Invoke(serviceProvider, options);
+            ValidateDataSourceOptions(options);
+
+            var connectionString = connectionStringFactory(serviceProvider);
+            ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
+
+            var dataSourceBuilder = new NpgsqlDataSourceBuilder(connectionString);
+            options.ConfigureDataSourceBuilder?.Invoke(dataSourceBuilder);
+
+            return new OwnedPostgresDataSource(dataSourceBuilder.Build(), options.SchemaName);
+        }));
+        builder.Services.Replace(ServiceDescriptor.Singleton(serviceProvider =>
+        {
+            var dataSource = serviceProvider.GetRequiredService<OwnedPostgresDataSource>();
+            var options = new ShedduellerPostgresOptions
+            {
+                DataSource = dataSource.DataSource,
+                SchemaName = dataSource.SchemaName,
+            };
+            PostgresOptionsValidator.Validate(options);
+            return options;
+        }));
+        RegisterProviderServices(builder.Services);
+
+        return builder;
+    }
+
     /// <summary>
     /// Uses the PostgreSQL job store provider.
     /// </summary>
@@ -41,21 +116,40 @@ public static ShedduellerBuilder UsePostgres(
         configure(options);
         PostgresOptionsValidator.Validate(options);
 
+        builder.Services.RemoveAll<OwnedPostgresDataSource>();
         builder.Services.Replace(ServiceDescriptor.Singleton(options));
-        builder.Services.Replace(ServiceDescriptor.Singleton<PostgresJobStore, PostgresJobStore>());
-        builder.Services.Replace(ServiceDescriptor.Singleton<IJobStore>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IJobInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IJobEventSink>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IJobEventRetentionStore>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IScheduleInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IConcurrencyGroupInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<INodeInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IMetricsInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
-        builder.Services.Replace(ServiceDescriptor.Singleton<IPostgresMigrator, PostgresMigrator>());
-        builder.Services.Replace(ServiceDescriptor.Singleton<IShedduellerWakeSignal, PostgresWakeSignal>());
-        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IShedduellerStartupValidator, PostgresStartupValidator>());
-        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IShedduellerJobEventListener, PostgresJobEventListener>());
+        RegisterProviderServices(builder.Services);
 
         return builder;
     }
+
+    private static void ValidateDataSourceOptions(ShedduellerPostgresDataSourceOptions options)
+    {
+        if (string.IsNullOrWhiteSpace(options.SchemaName))
+        {
+            throw new InvalidOperationException("ShedduellerPostgresDataSourceOptions.SchemaName must be a non-empty PostgreSQL schema name.");
+        }
+
+        if (options.SchemaName.Contains('\0', StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException("ShedduellerPostgresDataSourceOptions.SchemaName cannot contain null characters.");
+        }
+    }
+
+    private static void RegisterProviderServices(IServiceCollection services)
+    {
+        services.Replace(ServiceDescriptor.Singleton<PostgresJobStore, PostgresJobStore>());
+        services.Replace(ServiceDescriptor.Singleton<IJobStore>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IJobInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IJobEventSink>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IJobEventRetentionStore>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IScheduleInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IConcurrencyGroupInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<INodeInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IMetricsInspectionReader>(serviceProvider => serviceProvider.GetRequiredService<PostgresJobStore>()));
+        services.Replace(ServiceDescriptor.Singleton<IPostgresMigrator, PostgresMigrator>());
+        services.Replace(ServiceDescriptor.Singleton<IShedduellerWakeSignal, PostgresWakeSignal>());
+        services.TryAddEnumerable(ServiceDescriptor.Singleton<IShedduellerStartupValidator, PostgresStartupValidator>());
+        services.TryAddEnumerable(ServiceDescriptor.Singleton<IShedduellerJobEventListener, PostgresJobEventListener>());
+    }
 }
diff --git a/src/Sheddueller.Postgres/ShedduellerPostgresDataSourceOptions.cs b/src/Sheddueller.Postgres/ShedduellerPostgresDataSourceOptions.cs
new file mode 100644
index 0000000..3fc2cf9
--- /dev/null
+++ b/src/Sheddueller.Postgres/ShedduellerPostgresDataSourceOptions.cs
@@ -0,0 +1,23 @@
+namespace Sheddueller.Postgres;
+
+using Npgsql;
+
+/// <summary>
+/// Options for a Sheddueller-owned PostgreSQL data source.
+/// </summary>
+/// <remarks>
+/// These options are used by connection-string registration overloads. Use
+/// <see cref="ShedduellerPostgresOptions"/> when supplying a caller-owned data source.
+/// </remarks>
+public sealed class ShedduellerPostgresDataSourceOptions
+{
+    /// <summary>
+    /// Gets or sets the PostgreSQL schema used by one logical Sheddueller cluster.
+    /// </summary>
+    public string SchemaName { get; set; } = "sheddueller";
+
+    /// <summary>
+    /// Gets or sets a callback for configuring the underlying Npgsql data source builder.
+    /// </summary>
+    public Action<NpgsqlDataSourceBuilder>? ConfigureDataSourceBuilder { get; set; }
+}
diff --git a/src/Sheddueller.Postgres/ShedduellerPostgresMigrationExtensions.cs b/src/Sheddueller.Postgres/ShedduellerPostgresMigrationExtensions.cs
new file mode 100644
index 0000000..aabda1b
--- /dev/null
+++ b/src/Sheddueller.Postgres/ShedduellerPostgresMigrationExtensions.cs
@@ -0,0 +1,42 @@
+namespace Sheddueller.Postgres;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+/// <summary>
+/// Convenience extensions for applying Sheddueller PostgreSQL migrations explicitly.
+/// </summary>
+public static class ShedduellerPostgresMigrationExtensions
+{
+    /// <summary>
+    /// Applies provider-owned PostgreSQL schema migrations through the host service provider.
+    /// </summary>
+    /// <param name="host">The host whose service provider contains the PostgreSQL provider.</param>
+    /// <param name="cancellationToken">A token for canceling migration work.</param>
+    /// <returns>A task that completes when schema migration has finished.</returns>
+    public static ValueTask ApplyShedduellerPostgresMigrationsAsync(
+        this IHost host,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(host);
+
+        return host.Services.ApplyShedduellerPostgresMigrationsAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Applies provider-owned PostgreSQL schema migrations through a scoped migrator.
+    /// </summary>
+    /// <param name="services">The service provider containing the PostgreSQL provider.</param>
+    /// <param name="cancellationToken">A token for canceling migration work.</param>
+    /// <returns>A task that completes when schema migration has finished.</returns>
+    public static async ValueTask ApplyShedduellerPostgresMigrationsAsync(
+        this IServiceProvider services,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        using var scope = services.CreateScope();
+        var migrator = scope.ServiceProvider.GetRequiredService<IPostgresMigrator>();
+        await migrator.ApplyAsync(cancellationToken).ConfigureAwait(false);
+    }
+}
diff --git a/src/Sheddueller.Testing/CapturingRecurringScheduleManager.cs b/src/Sheddueller.Testing/CapturingRecurringScheduleManager.cs
index a854fa1..70b77c5 100644
--- a/src/Sheddueller.Testing/CapturingRecurringScheduleManager.cs
+++ b/src/Sheddueller.Testing/CapturingRecurringScheduleManager.cs
@@ -67,6 +67,12 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateAsync<TService>(
       CancellationToken cancellationToken = default)
       => this.CurrentOrDiscardingFake().CreateOrUpdateAsync(scheduleKey, cronExpression, work, options, cancellationToken);
 
+    /// <inheritdoc />
+    public ValueTask<RecurringScheduleTriggerResult> TriggerAsync(
+      string scheduleKey,
+      CancellationToken cancellationToken = default)
+      => this.CurrentOrDiscardingFake().TriggerAsync(scheduleKey, cancellationToken);
+
     /// <inheritdoc />
     public ValueTask<bool> DeleteAsync(
       string scheduleKey,
diff --git a/src/Sheddueller.Testing/FakeRecurringScheduleManager.cs b/src/Sheddueller.Testing/FakeRecurringScheduleManager.cs
index 8028c1c..1acf85e 100644
--- a/src/Sheddueller.Testing/FakeRecurringScheduleManager.cs
+++ b/src/Sheddueller.Testing/FakeRecurringScheduleManager.cs
@@ -16,6 +16,8 @@ public sealed class FakeRecurringScheduleManager : IRecurringScheduleManager
     private readonly IJobPayloadSerializer _serializer;
     private readonly TimeProvider _timeProvider;
     private readonly Dictionary<string, FakeRecurringSchedule> _schedules = new(StringComparer.Ordinal);
+    private readonly List<FakeTriggeredJob> _triggeredJobs = [];
+    private long _nextEnqueueSequence;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="FakeRecurringScheduleManager"/> class.
@@ -64,6 +66,20 @@ public IReadOnlyList<FakeRecurringSchedule> Schedules
         }
     }
 
+    /// <summary>
+    /// Gets a snapshot of jobs created by manual schedule triggers.
+    /// </summary>
+    public IReadOnlyList<FakeTriggeredJob> TriggeredJobs
+    {
+        get
+        {
+            lock (this._syncRoot)
+            {
+                return Array.AsReadOnly([.. this._triggeredJobs]);
+            }
+        }
+    }
+
     /// <inheritdoc />
     public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateAsync(
       string scheduleKey,
@@ -100,6 +116,37 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateAsync<TService>(
       CancellationToken cancellationToken = default)
       => this.CreateOrUpdateCoreAsync(scheduleKey, cronExpression, JobExpressionParser.Parse(work), options, cancellationToken);
 
+    /// <inheritdoc />
+    public ValueTask<RecurringScheduleTriggerResult> TriggerAsync(
+      string scheduleKey,
+      CancellationToken cancellationToken = default)
+    {
+        SubmissionValidator.ValidateScheduleKey(scheduleKey);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        lock (this._syncRoot)
+        {
+            if (!this._schedules.TryGetValue(scheduleKey, out var schedule))
+            {
+                return ValueTask.FromResult(new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.NotFound));
+            }
+
+            if (schedule.OverlapMode == RecurringOverlapMode.Skip
+              && this._triggeredJobs.Any(job => string.Equals(job.SourceScheduleKey, scheduleKey, StringComparison.Ordinal)))
+            {
+                return ValueTask.FromResult(new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.SkippedActiveOccurrence));
+            }
+
+            var triggeredJob = this.CreateTriggeredJob(schedule);
+            this._triggeredJobs.Add(triggeredJob);
+
+            return ValueTask.FromResult(new RecurringScheduleTriggerResult(
+              RecurringScheduleTriggerStatus.Enqueued,
+              triggeredJob.JobId,
+              triggeredJob.EnqueueSequence));
+        }
+    }
+
     /// <inheritdoc />
     public ValueTask<bool> DeleteAsync(
       string scheduleKey,
@@ -231,6 +278,8 @@ public void Clear()
         lock (this._syncRoot)
         {
             this._schedules.Clear();
+            this._triggeredJobs.Clear();
+            this._nextEnqueueSequence = 0;
         }
     }
 
@@ -325,6 +374,9 @@ [.. schedule.ParsedJob.MethodParameterTypeNames.Select(TypeNameFormatter.Resolve
     private DateTimeOffset GetNextFireAtUtc(string cronExpression)
       => CronSchedule.GetNextOccurrenceAfter(cronExpression, this._timeProvider.GetUtcNow());
 
+    private FakeTriggeredJob CreateTriggeredJob(FakeRecurringSchedule schedule)
+      => new(Guid.NewGuid(), this._nextEnqueueSequence++, schedule);
+
     private static bool Matches(
       FakeRecurringSchedule schedule,
       string scheduleKey,
diff --git a/src/Sheddueller.Testing/FakeTriggeredJob.cs b/src/Sheddueller.Testing/FakeTriggeredJob.cs
new file mode 100644
index 0000000..5266d4a
--- /dev/null
+++ b/src/Sheddueller.Testing/FakeTriggeredJob.cs
@@ -0,0 +1,116 @@
+namespace Sheddueller.Testing;
+
+using System.Collections.ObjectModel;
+
+using Sheddueller.Serialization;
+using Sheddueller.Storage;
+
+/// <summary>
+/// Recorded job created by manually triggering a recurring schedule in <see cref="FakeRecurringScheduleManager"/>.
+/// </summary>
+public sealed class FakeTriggeredJob
+{
+    internal FakeTriggeredJob(
+      Guid jobId,
+      long enqueueSequence,
+      FakeRecurringSchedule schedule)
+    {
+        this.JobId = jobId;
+        this.EnqueueSequence = enqueueSequence;
+        this.SourceScheduleKey = schedule.ScheduleKey;
+        this.ServiceType = schedule.ServiceType;
+        this.MethodName = schedule.MethodName;
+        this.MethodParameterTypes = ToReadOnlyCollection(schedule.MethodParameterTypes);
+        this.MethodParameterBindings = ToReadOnlyCollection(schedule.MethodParameterBindings);
+        this.InvocationTargetKind = schedule.InvocationTargetKind;
+        this.SerializableParameterTypes = ToReadOnlyCollection(schedule.SerializableParameterTypes);
+        this.SerializableArguments = ToReadOnlyCollection(schedule.SerializableArguments);
+        this.SerializedArgumentsStorage = FakeEnqueuedJob.ClonePayload(schedule.StoredSerializedArguments);
+        this.Priority = schedule.Priority;
+        this.ConcurrencyGroupKeys = ToReadOnlyCollection(schedule.ConcurrencyGroupKeys);
+        this.RetryPolicy = schedule.RetryPolicy;
+        this.Tags = ToReadOnlyCollection(schedule.Tags);
+    }
+
+    /// <summary>
+    /// Gets the job identifier returned by the trigger call.
+    /// </summary>
+    public Guid JobId { get; }
+
+    /// <summary>
+    /// Gets the zero-based enqueue sequence for this fake instance.
+    /// </summary>
+    public long EnqueueSequence { get; }
+
+    /// <summary>
+    /// Gets the source recurring schedule key.
+    /// </summary>
+    public string SourceScheduleKey { get; }
+
+    /// <summary>
+    /// Gets the service type that owns the triggered job method.
+    /// </summary>
+    public Type ServiceType { get; }
+
+    /// <summary>
+    /// Gets the triggered job method name.
+    /// </summary>
+    public string MethodName { get; }
+
+    /// <summary>
+    /// Gets the target method parameter types.
+    /// </summary>
+    public IReadOnlyList<Type> MethodParameterTypes { get; }
+
+    /// <summary>
+    /// Gets how each target method parameter is supplied when the job runs.
+    /// </summary>
+    public IReadOnlyList<JobMethodParameterBinding> MethodParameterBindings { get; }
+
+    /// <summary>
+    /// Gets how the target method is invoked.
+    /// </summary>
+    public JobInvocationTargetKind InvocationTargetKind { get; }
+
+    /// <summary>
+    /// Gets the parameter types included in the serialized argument payload.
+    /// </summary>
+    public IReadOnlyList<Type> SerializableParameterTypes { get; }
+
+    /// <summary>
+    /// Gets the evaluated argument values included in the serialized argument payload.
+    /// </summary>
+    public IReadOnlyList<object?> SerializableArguments { get; }
+
+    /// <summary>
+    /// Gets a copy of the serialized argument payload.
+    /// </summary>
+    public SerializedJobPayload SerializedArguments => FakeEnqueuedJob.ClonePayload(this.SerializedArgumentsStorage);
+
+    /// <summary>
+    /// Gets the priority cloned from the schedule template.
+    /// </summary>
+    public int Priority { get; }
+
+    /// <summary>
+    /// Gets the concurrency group keys cloned from the schedule template.
+    /// </summary>
+    public IReadOnlyList<string> ConcurrencyGroupKeys { get; }
+
+    /// <summary>
+    /// Gets the retry policy cloned from the schedule template.
+    /// </summary>
+    public RetryPolicy? RetryPolicy { get; }
+
+    /// <summary>
+    /// Gets the tags cloned from the schedule template.
+    /// </summary>
+    public IReadOnlyList<JobTag> Tags { get; }
+
+    internal SerializedJobPayload StoredSerializedArguments => this.SerializedArgumentsStorage;
+
+    private SerializedJobPayload SerializedArgumentsStorage { get; }
+
+    private static ReadOnlyCollection<T> ToReadOnlyCollection<T>(IReadOnlyList<T> values)
+      => Array.AsReadOnly([.. values]);
+}
diff --git a/src/Sheddueller/IRecurringScheduleManager.cs b/src/Sheddueller/IRecurringScheduleManager.cs
index d4e22cb..abb33b7 100644
--- a/src/Sheddueller/IRecurringScheduleManager.cs
+++ b/src/Sheddueller/IRecurringScheduleManager.cs
@@ -77,6 +77,16 @@ ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateAsync<TService>(
         RecurringScheduleOptions? options = null,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Manually triggers a recurring schedule by cloning its current stored template into one queued job.
+    /// </summary>
+    /// <param name="scheduleKey">The stable unique key for the schedule.</param>
+    /// <param name="cancellationToken">A token for canceling the storage operation.</param>
+    /// <returns>The trigger outcome, including the created job id when a job was enqueued.</returns>
+    ValueTask<RecurringScheduleTriggerResult> TriggerAsync(
+        string scheduleKey,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Deletes a recurring schedule definition.
     /// </summary>
diff --git a/src/Sheddueller/RecurringScheduleTriggerResult.cs b/src/Sheddueller/RecurringScheduleTriggerResult.cs
new file mode 100644
index 0000000..90acbf2
--- /dev/null
+++ b/src/Sheddueller/RecurringScheduleTriggerResult.cs
@@ -0,0 +1,12 @@
+namespace Sheddueller;
+
+/// <summary>
+/// Result of manually triggering a recurring schedule.
+/// </summary>
+/// <param name="Status">The trigger outcome.</param>
+/// <param name="JobId">The created job id when the trigger enqueued a job.</param>
+/// <param name="EnqueueSequence">The created job enqueue sequence when supplied by storage.</param>
+public sealed record RecurringScheduleTriggerResult(
+    RecurringScheduleTriggerStatus Status,
+    Guid? JobId = null,
+    long? EnqueueSequence = null);
diff --git a/src/Sheddueller/RecurringScheduleTriggerStatus.cs b/src/Sheddueller/RecurringScheduleTriggerStatus.cs
new file mode 100644
index 0000000..5899b64
--- /dev/null
+++ b/src/Sheddueller/RecurringScheduleTriggerStatus.cs
@@ -0,0 +1,22 @@
+namespace Sheddueller;
+
+/// <summary>
+/// Result classification for a manual recurring schedule trigger.
+/// </summary>
+public enum RecurringScheduleTriggerStatus
+{
+    /// <summary>
+    /// The schedule template was cloned into a queued job.
+    /// </summary>
+    Enqueued,
+
+    /// <summary>
+    /// No recurring schedule exists for the supplied key.
+    /// </summary>
+    NotFound,
+
+    /// <summary>
+    /// The schedule uses skip-overlap semantics and already has a queued or claimed occurrence.
+    /// </summary>
+    SkippedActiveOccurrence,
+}
diff --git a/src/Sheddueller/Runtime/RecurringScheduleManager.cs b/src/Sheddueller/Runtime/RecurringScheduleManager.cs
index de6ca43..3b87387 100644
--- a/src/Sheddueller/Runtime/RecurringScheduleManager.cs
+++ b/src/Sheddueller/Runtime/RecurringScheduleManager.cs
@@ -3,6 +3,8 @@ namespace Sheddueller.Runtime;
 using System.Linq.Expressions;
 using System.Runtime.CompilerServices;
 
+using Microsoft.Extensions.Options;
+
 using Sheddueller.Enqueueing;
 using Sheddueller.Scheduling;
 using Sheddueller.Serialization;
@@ -11,6 +13,7 @@ namespace Sheddueller.Runtime;
 internal sealed class RecurringScheduleManager(
     IJobStore store,
     IJobPayloadSerializer serializer,
+    IOptions<ShedduellerOptions> options,
     TimeProvider timeProvider,
     IShedduellerWakeSignal wakeSignal) : IRecurringScheduleManager
 {
@@ -46,6 +49,25 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateAsync<TService>(
         CancellationToken cancellationToken = default)
       => this.CreateOrUpdateCoreAsync(scheduleKey, cronExpression, work, options, cancellationToken);
 
+    public async ValueTask<RecurringScheduleTriggerResult> TriggerAsync(
+        string scheduleKey,
+        CancellationToken cancellationToken = default)
+    {
+        SubmissionValidator.ValidateScheduleKey(scheduleKey);
+
+        var result = await store.TriggerRecurringScheduleAsync(
+          new TriggerRecurringScheduleRequest(scheduleKey, options.Value.DefaultRetryPolicy),
+          cancellationToken)
+          .ConfigureAwait(false);
+
+        if (result.Status == RecurringScheduleTriggerStatus.Enqueued)
+        {
+            wakeSignal.Notify();
+        }
+
+        return result;
+    }
+
     public ValueTask<bool> DeleteAsync(string scheduleKey, CancellationToken cancellationToken = default)
     {
         SubmissionValidator.ValidateScheduleKey(scheduleKey);
diff --git a/src/Sheddueller/ShedduellerBuilder.cs b/src/Sheddueller/ShedduellerBuilder.cs
index d89729b..35717bd 100644
--- a/src/Sheddueller/ShedduellerBuilder.cs
+++ b/src/Sheddueller/ShedduellerBuilder.cs
@@ -34,6 +34,20 @@ public ShedduellerBuilder ConfigureOptions(Action<ShedduellerOptions> configure)
         return this;
     }
 
+    /// <summary>
+    /// Configures Sheddueller runtime options with access to the final service provider.
+    /// </summary>
+    /// <param name="configure">The options callback to apply through the host options system.</param>
+    /// <returns>The same builder for chained configuration.</returns>
+    public ShedduellerBuilder ConfigureOptions(Action<IServiceProvider, ShedduellerOptions> configure)
+    {
+        ArgumentNullException.ThrowIfNull(configure);
+
+        this.Services.AddOptions<ShedduellerOptions>()
+          .Configure<IServiceProvider>((options, serviceProvider) => configure(serviceProvider, options));
+        return this;
+    }
+
     /// <summary>
     /// Replaces the job payload serializer with a singleton implementation type.
     /// </summary>
diff --git a/src/Sheddueller/Storage/IJobStore.cs b/src/Sheddueller/Storage/IJobStore.cs
index 1ca7602..3dd38ce 100644
--- a/src/Sheddueller/Storage/IJobStore.cs
+++ b/src/Sheddueller/Storage/IJobStore.cs
@@ -110,6 +110,13 @@ ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateRecurringScheduleAsync(
         UpsertRecurringScheduleRequest request,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Manually clones a recurring schedule definition into one queued job.
+    /// </summary>
+    ValueTask<RecurringScheduleTriggerResult> TriggerRecurringScheduleAsync(
+        TriggerRecurringScheduleRequest request,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Deletes a recurring schedule definition.
     /// </summary>
diff --git a/src/Sheddueller/Storage/TriggerRecurringScheduleRequest.cs b/src/Sheddueller/Storage/TriggerRecurringScheduleRequest.cs
new file mode 100644
index 0000000..b1f1387
--- /dev/null
+++ b/src/Sheddueller/Storage/TriggerRecurringScheduleRequest.cs
@@ -0,0 +1,8 @@
+namespace Sheddueller.Storage;
+
+/// <summary>
+/// Store request for manually triggering a recurring schedule.
+/// </summary>
+public sealed record TriggerRecurringScheduleRequest(
+    string ScheduleKey,
+    RetryPolicy? DefaultRetryPolicy);
diff --git a/test/Sheddueller.Dashboard.Tests/DashboardEndpointTests.cs b/test/Sheddueller.Dashboard.Tests/DashboardEndpointTests.cs
index b715f96..42f5c75 100644
--- a/test/Sheddueller.Dashboard.Tests/DashboardEndpointTests.cs
+++ b/test/Sheddueller.Dashboard.Tests/DashboardEndpointTests.cs
@@ -20,10 +20,12 @@ namespace Sheddueller.Dashboard.Tests;
 
 using Shouldly;
 
+using SchedulesPage = Sheddueller.Dashboard.Components.Pages.Schedules;
+
 public sealed class DashboardEndpointTests
 {
     [Fact]
-    public async Task MapShedduellerDashboard_ApplicationBranch_RedirectsToCanonicalRoot()
+    public async Task MapShedduellerDashboard_MinimalHosting_RedirectsToCanonicalRoot()
     {
         await using var app = await CreateStartedDashboardAsync();
         var client = app.GetTestClient();
@@ -34,6 +36,29 @@ public async Task MapShedduellerDashboard_ApplicationBranch_RedirectsToCanonical
         response.Headers.Location?.OriginalString.ShouldBe("/sheddueller/");
     }
 
+    [Fact]
+    public async Task MapShedduellerDashboard_ApplicationBranch_RedirectsToCanonicalRoot()
+    {
+        await using var app = await CreateStartedDashboardAsync(mapWithWebApplication: false);
+        var client = app.GetTestClient();
+
+        var response = await client.GetAsync(new Uri("/sheddueller", UriKind.Relative));
+
+        response.StatusCode.ShouldBe(HttpStatusCode.Redirect);
+        response.Headers.Location?.OriginalString.ShouldBe("/sheddueller/");
+    }
+
+    [Fact]
+    public async Task MapShedduellerDashboard_DefaultOptions_DoesNotPrerenderRouteContent()
+    {
+        await using var app = await CreateStartedDashboardAsync(prerender: false);
+        var html = await GetOkHtmlAsync(app, "/sheddueller/");
+
+        html.ShouldContain("base href=\"http://localhost/sheddueller/\"");
+        html.ShouldContain("_framework/blazor.web.js");
+        html.ShouldNotContain("Operational Control");
+    }
+
     [Fact]
     public async Task Overview_KnownData_RendersOperationalSummary()
     {
@@ -146,14 +171,26 @@ public async Task Schedules_KnownData_RendersRegistry()
         html.ShouldContain("tenant:acme");
         html.ShouldContain("schedule:nightly");
         html.ShouldContain("2026-04-20 12:03:00 UTC");
+        html.ShouldContain("Trigger Now etl_nightly_sync");
+        html.ShouldContain("Trigger Now cache_eviction_hourly");
         html.ShouldContain("Pause Schedule etl_nightly_sync");
         html.ShouldContain("Resume Schedule cache_eviction_hourly");
-        html.ShouldNotContain("Trigger Now etl_nightly_sync");
         html.ShouldContain("Load More Records");
         html.ShouldContain("Showing 1-3 of 3 schedules with more available");
         AssertShellRefresh(html);
     }
 
+    [Fact]
+    public void Schedules_TriggerActionMessages_FormatSuccessSkippedAndMissingCases()
+    {
+        SchedulesPage.CreateTriggerSuccessMessage("etl_nightly_sync")
+          .ShouldBe("Schedule etl_nightly_sync triggered as job");
+        SchedulesPage.CreateTriggerSkippedMessage("etl_nightly_sync")
+          .ShouldBe("Schedule etl_nightly_sync already has an active occurrence.");
+        SchedulesPage.ScheduleNotFoundActionFailureMessage
+          .ShouldBe("Schedule action failed: Schedule was not found.");
+    }
+
     [Fact]
     public async Task ConcurrencyGroups_KnownData_RendersRegistry()
     {
@@ -351,7 +388,9 @@ public async Task JobDetail_MissingJob_RendersNotFoundWithDisabledCancelAction()
           disabled: true);
     }
 
-    private static async Task<WebApplication> CreateStartedDashboardAsync()
+    private static async Task<WebApplication> CreateStartedDashboardAsync(
+        bool prerender = true,
+        bool mapWithWebApplication = true)
     {
         var builder = WebApplication.CreateBuilder();
         builder.WebHost.UseTestServer();
@@ -363,10 +402,18 @@ private static async Task<WebApplication> CreateStartedDashboardAsync()
         builder.Services.AddSingleton<IConcurrencyGroupInspectionReader, StubConcurrencyGroupInspectionReader>();
         builder.Services.AddSingleton<INodeInspectionReader, StubNodeInspectionReader>();
         builder.Services.AddSingleton<IMetricsInspectionReader, StubMetricsInspectionReader>();
-        builder.Services.AddShedduellerDashboard();
+        builder.Services.AddShedduellerDashboard(options => options.Prerender = prerender);
 
         var app = builder.Build();
-        ((IApplicationBuilder)app).MapShedduellerDashboard("/sheddueller");
+        if (mapWithWebApplication)
+        {
+            app.MapShedduellerDashboard("/sheddueller");
+        }
+        else
+        {
+            ((IApplicationBuilder)app).MapShedduellerDashboard("/sheddueller");
+        }
+
         await app.StartAsync();
 
         return app;
@@ -834,6 +881,20 @@ public ValueTask<bool> DeleteAsync(
             CancellationToken cancellationToken = default)
           => throw new NotSupportedException();
 
+        public ValueTask<RecurringScheduleTriggerResult> TriggerAsync(
+            string scheduleKey,
+            CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            return ValueTask.FromResult(string.Equals(scheduleKey, "etl_nightly_sync", StringComparison.Ordinal)
+              ? new RecurringScheduleTriggerResult(
+                RecurringScheduleTriggerStatus.Enqueued,
+                Guid.Parse("5a8f55df-9d29-47c1-8510-cebe102502bf"),
+                EnqueueSequence: 42)
+              : new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.NotFound));
+        }
+
         public ValueTask<bool> PauseAsync(
             string scheduleKey,
             CancellationToken cancellationToken = default)
diff --git a/test/Sheddueller.Postgres.Tests/Operations/TriggerRecurringScheduleOperationTests.cs b/test/Sheddueller.Postgres.Tests/Operations/TriggerRecurringScheduleOperationTests.cs
new file mode 100644
index 0000000..be71397
--- /dev/null
+++ b/test/Sheddueller.Postgres.Tests/Operations/TriggerRecurringScheduleOperationTests.cs
@@ -0,0 +1,227 @@
+namespace Sheddueller.Postgres.Tests.Operations;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using Sheddueller.Inspection.Jobs;
+using Sheddueller.Runtime;
+using Sheddueller.Storage;
+
+using Shouldly;
+
+public sealed class TriggerRecurringScheduleOperationTests(PostgresFixture fixture) : IClassFixture<PostgresFixture>
+{
+    [Fact]
+    public async Task TriggerRecurringSchedule_MissingSchedule_ReturnsNotFound()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("missing", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.NotFound);
+        result.JobId.ShouldBeNull();
+        result.EnqueueSequence.ShouldBeNull();
+        (await context.CountJobsAsync()).ShouldBe(0);
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_ExistingSchedule_InsertsClaimableManualJob()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        var retryPolicy = new RetryPolicy(3, RetryBackoffKind.Fixed, TimeSpan.FromSeconds(2));
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule(
+          "schedule-a",
+          priority: 9,
+          groupKeys: ["shared"],
+          retryPolicy,
+          tags: [new JobTag("tenant", "acme")],
+          invocationTargetKind: JobInvocationTargetKind.Static,
+          methodParameterBindings:
+          [
+              new JobMethodParameterBinding(JobMethodParameterBindingKind.CancellationToken),
+          ]));
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        result.JobId.ShouldNotBeNull();
+        result.EnqueueSequence.ShouldNotBeNull();
+
+        var jobId = result.JobId.Value;
+        var job = await context.ReadJobAsync(jobId);
+        job.EnqueueSequence.ShouldBe(result.EnqueueSequence.Value);
+        job.SourceScheduleKey.ShouldBe("schedule-a");
+        job.ScheduledFireAtUtc.ShouldBeNull();
+        job.ScheduleOccurrenceKind.ShouldBe(nameof(ScheduleOccurrenceKind.ManualTrigger));
+        job.Priority.ShouldBe(9);
+        job.MaxAttempts.ShouldBe(3);
+        job.RetryBackoffKind.ShouldBe(nameof(RetryBackoffKind.Fixed));
+        job.RetryBaseDelayMs.ShouldBe(2000);
+        job.InvocationTargetKind.ShouldBe(nameof(JobInvocationTargetKind.Static));
+        job.MethodParameterBindings.ShouldBe([nameof(JobMethodParameterBindingKind.CancellationToken)]);
+        (await context.ReadJobGroupKeysAsync(jobId)).ShouldBe(["shared"]);
+        (await context.ReadJobTagsAsync(jobId)).ShouldBe([new JobTag("tenant", "acme")]);
+
+        var inspectionReader = context.Store.ShouldBeAssignableTo<IJobInspectionReader>();
+        var inspected = await inspectionReader.GetJobAsync(jobId);
+        inspected.ShouldNotBeNull();
+        inspected.ScheduledFireAtUtc.ShouldBeNull();
+        inspected.Summary.ScheduleOccurrenceKind.ShouldBe(ScheduleOccurrenceKind.ManualTrigger);
+
+        var claimed = await PostgresTestData.ClaimAsync(context.Store);
+        claimed.JobId.ShouldBe(jobId);
+        claimed.SourceScheduleKey.ShouldBe("schedule-a");
+        claimed.ScheduledFireAtUtc.ShouldBeNull();
+        claimed.Priority.ShouldBe(9);
+        claimed.ConcurrencyGroupKeys.ShouldBe(["shared"]);
+        claimed.MaxAttempts.ShouldBe(3);
+        claimed.RetryBackoffKind.ShouldBe(RetryBackoffKind.Fixed);
+        claimed.RetryBaseDelay.ShouldBe(TimeSpan.FromSeconds(2));
+        claimed.InvocationTargetKind.ShouldBe(JobInvocationTargetKind.Static);
+        claimed.MethodParameterBindings.ShouldBe([
+            new JobMethodParameterBinding(JobMethodParameterBindingKind.CancellationToken),
+        ]);
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_PausedSchedule_EnqueuesJobWithoutResuming()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a"));
+        await context.Store.PauseRecurringScheduleAsync("schedule-a", DateTimeOffset.UtcNow);
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await context.ReadScheduleAsync("schedule-a")).IsPaused.ShouldBeTrue();
+        (await PostgresTestData.ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_SkipOverlap_DoesNotInsertSecondActiveOccurrence()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a", overlapMode: RecurringOverlapMode.Skip));
+
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        var skipped = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        skipped.Status.ShouldBe(RecurringScheduleTriggerStatus.SkippedActiveOccurrence);
+        skipped.JobId.ShouldBeNull();
+        skipped.EnqueueSequence.ShouldBeNull();
+        (await context.CountJobsForScheduleAsync("schedule-a")).ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_AllowOverlap_InsertsSecondActiveOccurrence()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a", overlapMode: RecurringOverlapMode.Allow));
+
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+
+        (await context.CountJobsForScheduleAsync("schedule-a")).ShouldBe(2);
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_ExistingSchedule_DoesNotAdvanceNextFire()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a"));
+        var before = await context.ReadScheduleAsync("schedule-a");
+
+        await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        var after = await context.ReadScheduleAsync("schedule-a");
+        after.NextFireAtUtc.ShouldBe(before.NextFireAtUtc);
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_DefaultRetryPolicy_AppliesWhenScheduleHasNoRetry()
+    {
+        await using var context = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a"));
+
+        await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest(
+          "schedule-a",
+          new RetryPolicy(5, RetryBackoffKind.Exponential, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(4))));
+
+        var claimed = await PostgresTestData.ClaimAsync(context.Store);
+        claimed.MaxAttempts.ShouldBe(5);
+        claimed.RetryBackoffKind.ShouldBe(RetryBackoffKind.Exponential);
+        claimed.RetryBaseDelay.ShouldBe(TimeSpan.FromSeconds(1));
+        claimed.RetryMaxDelay.ShouldBe(TimeSpan.FromSeconds(4));
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_EnqueuedJob_NotifiesWaitingProvider()
+    {
+        await using var firstContext = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await using var secondProvider = PostgresTestContext.CreateProvider(fixture.DataSource, firstContext.SchemaName);
+        await secondProvider.GetRequiredService<IJobStore>()
+          .CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a"));
+
+        var notified = await ObserveWakeAsync(
+          firstContext.Provider.GetRequiredService<IShedduellerWakeSignal>(),
+          () => secondProvider.GetRequiredService<IJobStore>()
+            .TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)));
+
+        notified.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_NotFound_DoesNotNotifyWaitingProvider()
+    {
+        await using var firstContext = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await using var secondProvider = PostgresTestContext.CreateProvider(fixture.DataSource, firstContext.SchemaName);
+
+        var notified = await ObserveWakeAsync(
+          firstContext.Provider.GetRequiredService<IShedduellerWakeSignal>(),
+          () => secondProvider.GetRequiredService<IJobStore>()
+            .TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("missing", DefaultRetryPolicy: null)));
+
+        notified.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task TriggerRecurringSchedule_SkippedOccurrence_DoesNotNotifyWaitingProvider()
+    {
+        await using var firstContext = await PostgresTestContext.CreateMigratedAsync(fixture);
+        await using var secondProvider = PostgresTestContext.CreateProvider(fixture.DataSource, firstContext.SchemaName);
+        var store = secondProvider.GetRequiredService<IJobStore>();
+        await store.CreateOrUpdateRecurringScheduleAsync(PostgresTestData.CreateSchedule("schedule-a"));
+        await store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        var notified = await ObserveWakeAsync(
+          firstContext.Provider.GetRequiredService<IShedduellerWakeSignal>(),
+          () => store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)));
+
+        notified.ShouldBeFalse();
+    }
+
+    private static async ValueTask<bool> ObserveWakeAsync(
+        IShedduellerWakeSignal wakeSignal,
+        Func<ValueTask<RecurringScheduleTriggerResult>> action)
+    {
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        var waitTask = wakeSignal.WaitAsync(TimeSpan.FromSeconds(5), timeout.Token).AsTask();
+        await Task.Delay(TimeSpan.FromMilliseconds(100), CancellationToken.None);
+
+        _ = await action().ConfigureAwait(false);
+
+        var completedTask = await Task.WhenAny(waitTask, Task.Delay(TimeSpan.FromMilliseconds(300), CancellationToken.None))
+          .ConfigureAwait(false);
+        if (completedTask == waitTask)
+        {
+            await waitTask.ConfigureAwait(false);
+            return true;
+        }
+
+        await timeout.CancelAsync();
+        await Should.ThrowAsync<OperationCanceledException>(() => waitTask);
+        return false;
+    }
+}
diff --git a/test/Sheddueller.Postgres.Tests/PostgresFixture.cs b/test/Sheddueller.Postgres.Tests/PostgresFixture.cs
index 2d816c5..202fd32 100644
--- a/test/Sheddueller.Postgres.Tests/PostgresFixture.cs
+++ b/test/Sheddueller.Postgres.Tests/PostgresFixture.cs
@@ -10,6 +10,8 @@ public sealed class PostgresFixture : IAsyncLifetime
 
     public NpgsqlDataSource DataSource { get; private set; } = null!;
 
+    public string ConnectionString { get; private set; } = string.Empty;
+
     public async ValueTask InitializeAsync()
     {
         var image = Environment.GetEnvironmentVariable("SHEDDUELLER_POSTGRES_IMAGE");
@@ -25,7 +27,8 @@ public async ValueTask InitializeAsync()
           .Build();
 
         await this._container.StartAsync();
-        this.DataSource = NpgsqlDataSource.Create(this._container.GetConnectionString());
+        this.ConnectionString = this._container.GetConnectionString();
+        this.DataSource = NpgsqlDataSource.Create(this.ConnectionString);
     }
 
     public async ValueTask DisposeAsync()
diff --git a/test/Sheddueller.Postgres.Tests/PostgresMigrationHelperTests.cs b/test/Sheddueller.Postgres.Tests/PostgresMigrationHelperTests.cs
new file mode 100644
index 0000000..e778dc8
--- /dev/null
+++ b/test/Sheddueller.Postgres.Tests/PostgresMigrationHelperTests.cs
@@ -0,0 +1,90 @@
+namespace Sheddueller.Postgres.Tests;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+using Sheddueller.Postgres;
+
+using Shouldly;
+
+public sealed class PostgresMigrationHelperTests
+{
+    [Fact]
+    public async Task ApplyShedduellerPostgresMigrationsAsync_ServiceProvider_UsesScopedMigrator()
+    {
+        var recorder = new MigrationRecorder();
+        await using var provider = CreateProvider(recorder);
+        using var cancellationTokenSource = new CancellationTokenSource();
+
+        await provider.ApplyShedduellerPostgresMigrationsAsync(cancellationTokenSource.Token);
+
+        recorder.ApplyCount.ShouldBe(1);
+        recorder.CancellationToken.ShouldBe(cancellationTokenSource.Token);
+        recorder.ScopeWasDisposedDuringApply.ShouldBeFalse();
+        recorder.ScopeWasDisposed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApplyShedduellerPostgresMigrationsAsync_Host_UsesScopedMigrator()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        var recorder = new MigrationRecorder();
+        RegisterMigrator(builder.Services, recorder);
+        using var host = builder.Build();
+        using var cancellationTokenSource = new CancellationTokenSource();
+
+        await host.ApplyShedduellerPostgresMigrationsAsync(cancellationTokenSource.Token);
+
+        recorder.ApplyCount.ShouldBe(1);
+        recorder.CancellationToken.ShouldBe(cancellationTokenSource.Token);
+        recorder.ScopeWasDisposedDuringApply.ShouldBeFalse();
+        recorder.ScopeWasDisposed.ShouldBeTrue();
+    }
+
+    private static ServiceProvider CreateProvider(MigrationRecorder recorder)
+    {
+        var services = new ServiceCollection();
+        RegisterMigrator(services, recorder);
+        return services.BuildServiceProvider();
+    }
+
+    private static void RegisterMigrator(
+        IServiceCollection services,
+        MigrationRecorder recorder)
+    {
+        services.AddSingleton(recorder);
+        services.AddScoped<ScopeMarker>();
+        services.AddScoped<IPostgresMigrator, RecordingMigrator>();
+    }
+
+    private sealed class MigrationRecorder
+    {
+        public int ApplyCount { get; set; }
+
+        public CancellationToken CancellationToken { get; set; }
+
+        public bool ScopeWasDisposed { get; set; }
+
+        public bool ScopeWasDisposedDuringApply { get; set; }
+    }
+
+    private sealed class ScopeMarker(MigrationRecorder recorder) : IDisposable
+    {
+        public void Dispose()
+          => recorder.ScopeWasDisposed = true;
+    }
+
+    private sealed class RecordingMigrator(
+        MigrationRecorder recorder,
+        ScopeMarker scopeMarker) : IPostgresMigrator
+    {
+        public ValueTask ApplyAsync(CancellationToken cancellationToken = default)
+        {
+            _ = scopeMarker;
+            recorder.ApplyCount++;
+            recorder.CancellationToken = cancellationToken;
+            recorder.ScopeWasDisposedDuringApply = recorder.ScopeWasDisposed;
+            return ValueTask.CompletedTask;
+        }
+    }
+}
diff --git a/test/Sheddueller.Postgres.Tests/PostgresRegistrationTests.cs b/test/Sheddueller.Postgres.Tests/PostgresRegistrationTests.cs
new file mode 100644
index 0000000..bf027c0
--- /dev/null
+++ b/test/Sheddueller.Postgres.Tests/PostgresRegistrationTests.cs
@@ -0,0 +1,110 @@
+namespace Sheddueller.Postgres.Tests;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using Npgsql;
+
+using Sheddueller.Inspection.Jobs;
+using Sheddueller.Postgres;
+using Sheddueller.Postgres.Internal;
+using Sheddueller.Runtime;
+using Sheddueller.Storage;
+
+using Shouldly;
+
+public sealed class PostgresRegistrationTests
+{
+    private const string TestConnectionString = "Host=127.0.0.1;Port=1;Username=postgres;Password=postgres;Database=sheddueller;Timeout=1";
+
+    [Fact]
+    public async Task UsePostgres_ConnectionString_RegistersProviderServices()
+    {
+        var services = new ServiceCollection();
+        services.AddSheddueller(builder => builder.UsePostgres(TestConnectionString));
+
+        await using var provider = services.BuildServiceProvider();
+
+        provider.GetRequiredService<ShedduellerPostgresOptions>().SchemaName.ShouldBe("sheddueller");
+        provider.GetRequiredService<IJobStore>().ShouldBeSameAs(provider.GetRequiredService<PostgresJobStore>());
+        provider.GetRequiredService<IJobInspectionReader>().ShouldBeSameAs(provider.GetRequiredService<PostgresJobStore>());
+        provider.GetRequiredService<IPostgresMigrator>().ShouldBeOfType<PostgresMigrator>();
+        provider.GetRequiredService<IShedduellerWakeSignal>().ShouldBeOfType<PostgresWakeSignal>();
+    }
+
+    [Fact]
+    public async Task UsePostgres_ServiceProviderFactory_CanReadRegisteredServices()
+    {
+        var schemaName = "sheddueller_" + Guid.NewGuid().ToString("N");
+        var services = new ServiceCollection();
+        services.AddSingleton(new PostgresRegistrationSettings(TestConnectionString, schemaName));
+        services.AddSheddueller(builder => builder.UsePostgres(
+          serviceProvider => serviceProvider.GetRequiredService<PostgresRegistrationSettings>().ConnectionString,
+          (serviceProvider, options) =>
+          {
+              options.SchemaName = serviceProvider.GetRequiredService<PostgresRegistrationSettings>().SchemaName;
+          }));
+
+        await using var provider = services.BuildServiceProvider();
+
+        provider.GetRequiredService<ShedduellerPostgresOptions>().SchemaName.ShouldBe(schemaName);
+    }
+
+    [Fact]
+    public async Task UsePostgres_ConfigureDataSourceBuilder_IsInvoked()
+    {
+        var configured = false;
+        var services = new ServiceCollection();
+        services.AddSheddueller(builder => builder.UsePostgres(
+          TestConnectionString,
+          options =>
+          {
+              options.ConfigureDataSourceBuilder = _ => configured = true;
+          }));
+
+        await using var provider = services.BuildServiceProvider();
+
+        provider.GetRequiredService<ShedduellerPostgresOptions>().ShouldNotBeNull();
+        configured.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task UsePostgres_ConnectionString_DisposesOwnedDataSourceWithProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddSheddueller(builder => builder.UsePostgres(TestConnectionString));
+        var provider = services.BuildServiceProvider();
+        var options = provider.GetRequiredService<ShedduellerPostgresOptions>();
+
+        await provider.DisposeAsync();
+
+        await Should.ThrowAsync<ObjectDisposedException>(async () =>
+        {
+            await using var connection = await options.DataSource.OpenConnectionAsync();
+        });
+    }
+
+    [Fact]
+    public async Task UsePostgres_CallerOwnedDataSource_IsNotDisposedWithProvider()
+    {
+        await using var dataSource = NpgsqlDataSource.Create(TestConnectionString);
+        var services = new ServiceCollection();
+        services.AddSheddueller(builder => builder.UsePostgres(options =>
+        {
+            options.DataSource = dataSource;
+        }));
+        var provider = services.BuildServiceProvider();
+
+        provider.GetRequiredService<ShedduellerPostgresOptions>().DataSource.ShouldBeSameAs(dataSource);
+
+        await provider.DisposeAsync();
+
+        await Should.ThrowAsync<NpgsqlException>(async () =>
+        {
+            await using var connection = await dataSource.OpenConnectionAsync();
+        });
+    }
+
+    private sealed record PostgresRegistrationSettings(
+        string ConnectionString,
+        string SchemaName);
+}
diff --git a/test/Sheddueller.Postgres.Tests/PostgresTestContext.cs b/test/Sheddueller.Postgres.Tests/PostgresTestContext.cs
index 08c13ed..163b1da 100644
--- a/test/Sheddueller.Postgres.Tests/PostgresTestContext.cs
+++ b/test/Sheddueller.Postgres.Tests/PostgresTestContext.cs
@@ -112,6 +112,7 @@ public async ValueTask<PostgresJobRow> ReadJobAsync(Guid jobId)
               failure_stack_trace,
               source_schedule_key,
               scheduled_fire_at_utc,
+              schedule_occurrence_kind,
               cancellation_requested_at_utc,
               cancellation_observed_at_utc,
               idempotency_key
@@ -158,9 +159,10 @@ public async ValueTask<PostgresJobRow> ReadJobAsync(Guid jobId)
           reader.IsDBNull(28) ? null : reader.GetString(28),
           reader.IsDBNull(29) ? null : reader.GetString(29),
           reader.IsDBNull(30) ? null : ToDateTimeOffset(reader.GetValue(30)),
-          reader.IsDBNull(31) ? null : ToDateTimeOffset(reader.GetValue(31)),
+          reader.IsDBNull(31) ? null : reader.GetString(31),
           reader.IsDBNull(32) ? null : ToDateTimeOffset(reader.GetValue(32)),
-          reader.IsDBNull(33) ? null : reader.GetString(33));
+          reader.IsDBNull(33) ? null : ToDateTimeOffset(reader.GetValue(33)),
+          reader.IsDBNull(34) ? null : reader.GetString(34));
     }
 
     public async ValueTask<PostgresScheduleRow> ReadScheduleAsync(string scheduleKey)
@@ -409,6 +411,7 @@ internal sealed record PostgresJobRow(
     string? FailureStackTrace,
     string? SourceScheduleKey,
     DateTimeOffset? ScheduledFireAtUtc,
+    string? ScheduleOccurrenceKind,
     DateTimeOffset? CancellationRequestedAtUtc,
     DateTimeOffset? CancellationObservedAtUtc,
     string? IdempotencyKey);
diff --git a/test/Sheddueller.Postgres.Tests/PostgresTestData.cs b/test/Sheddueller.Postgres.Tests/PostgresTestData.cs
index c3fc948..27ce009 100644
--- a/test/Sheddueller.Postgres.Tests/PostgresTestData.cs
+++ b/test/Sheddueller.Postgres.Tests/PostgresTestData.cs
@@ -69,6 +69,7 @@ public static UpsertRecurringScheduleRequest CreateSchedule(
         IReadOnlyList<string>? groupKeys = null,
         RetryPolicy? retryPolicy = null,
         RecurringOverlapMode overlapMode = RecurringOverlapMode.Skip,
+        IReadOnlyList<JobTag>? tags = null,
         JobInvocationTargetKind invocationTargetKind = JobInvocationTargetKind.Instance,
         IReadOnlyList<JobMethodParameterBinding>? methodParameterBindings = null)
       => new(
@@ -83,6 +84,7 @@ public static UpsertRecurringScheduleRequest CreateSchedule(
         retryPolicy,
         overlapMode,
         DateTimeOffset.UtcNow,
+        Tags: tags,
         InvocationTargetKind: invocationTargetKind,
         MethodParameterBindings: methodParameterBindings);
 
diff --git a/test/Sheddueller.ProviderContracts/JobStoreContractTests.cs b/test/Sheddueller.ProviderContracts/JobStoreContractTests.cs
index eaaed57..273848a 100644
--- a/test/Sheddueller.ProviderContracts/JobStoreContractTests.cs
+++ b/test/Sheddueller.ProviderContracts/JobStoreContractTests.cs
@@ -605,6 +605,138 @@ public async Task RecurringOverlap_Allow_MaterializesMultipleNonTerminalOccurren
         (await ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
     }
 
+    [Fact]
+    public async Task RecurringScheduleTrigger_MissingSchedule_ReturnsNotFound()
+    {
+        await using var context = await this.CreateContextAsync();
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("missing", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.NotFound);
+        result.JobId.ShouldBeNull();
+        result.EnqueueSequence.ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_ExistingSchedule_ClonesTemplateIntoClaimableJob()
+    {
+        await using var context = await this.CreateContextAsync();
+        var retryPolicy = new RetryPolicy(4, RetryBackoffKind.Fixed, TimeSpan.FromSeconds(3));
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule(
+          "schedule-a",
+          priority: 7,
+          groupKeys: ["group-a"],
+          retryPolicy,
+          invocationTargetKind: JobInvocationTargetKind.Static,
+          methodParameterBindings:
+          [
+              new JobMethodParameterBinding(JobMethodParameterBindingKind.CancellationToken),
+          ]));
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        result.JobId.ShouldNotBeNull();
+        result.EnqueueSequence.ShouldNotBeNull();
+        result.EnqueueSequence.Value.ShouldBeGreaterThan(0);
+
+        var claimed = await ClaimAsync(context.Store);
+        claimed.JobId.ShouldBe(result.JobId.Value);
+        claimed.EnqueueSequence.ShouldBe(result.EnqueueSequence.Value);
+        claimed.SourceScheduleKey.ShouldBe("schedule-a");
+        claimed.ScheduledFireAtUtc.ShouldBeNull();
+        claimed.Priority.ShouldBe(7);
+        claimed.ConcurrencyGroupKeys.ShouldBe(["group-a"]);
+        claimed.MaxAttempts.ShouldBe(4);
+        claimed.RetryBackoffKind.ShouldBe(RetryBackoffKind.Fixed);
+        claimed.RetryBaseDelay.ShouldBe(TimeSpan.FromSeconds(3));
+        claimed.ServiceType.ShouldBe(typeof(JobStoreContractService).AssemblyQualifiedName);
+        claimed.MethodName.ShouldBe(nameof(JobStoreContractService.RunAsync));
+        claimed.MethodParameterTypes.ShouldBe([typeof(CancellationToken).AssemblyQualifiedName!]);
+        claimed.InvocationTargetKind.ShouldBe(JobInvocationTargetKind.Static);
+        claimed.MethodParameterBindings.ShouldBe([
+            new JobMethodParameterBinding(JobMethodParameterBindingKind.CancellationToken),
+        ]);
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_DefaultRetryPolicy_AppliesWhenScheduleHasNoRetry()
+    {
+        await using var context = await this.CreateContextAsync();
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule("schedule-a"));
+
+        await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest(
+          "schedule-a",
+          new RetryPolicy(3, RetryBackoffKind.Exponential, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(8))));
+
+        var claimed = await ClaimAsync(context.Store);
+        claimed.MaxAttempts.ShouldBe(3);
+        claimed.RetryBackoffKind.ShouldBe(RetryBackoffKind.Exponential);
+        claimed.RetryBaseDelay.ShouldBe(TimeSpan.FromSeconds(2));
+        claimed.RetryMaxDelay.ShouldBe(TimeSpan.FromSeconds(8));
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_PausedSchedule_EnqueuesJob()
+    {
+        await using var context = await this.CreateContextAsync();
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule("schedule-a"));
+        await context.Store.PauseRecurringScheduleAsync("schedule-a", ContractClock);
+
+        var result = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_SkipOverlap_ReturnsSkippedWhenEarlierOccurrenceIsNonTerminal()
+    {
+        await using var context = await this.CreateContextAsync();
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule("schedule-a", overlapMode: RecurringOverlapMode.Skip));
+
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        var skipped = await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        skipped.Status.ShouldBe(RecurringScheduleTriggerStatus.SkippedActiveOccurrence);
+        skipped.JobId.ShouldBeNull();
+        skipped.EnqueueSequence.ShouldBeNull();
+        (await ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
+        (await context.Store.TryClaimNextAsync(CreateClaimRequest("node-1"))).ShouldBeOfType<ClaimJobResult.NoJobAvailable>();
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_AllowOverlap_EnqueuesMultipleNonTerminalOccurrences()
+    {
+        await using var context = await this.CreateContextAsync();
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule("schedule-a", overlapMode: RecurringOverlapMode.Allow));
+
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null)))
+          .Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+
+        (await ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
+        (await ClaimAsync(context.Store)).SourceScheduleKey.ShouldBe("schedule-a");
+    }
+
+    [Fact]
+    public async Task RecurringScheduleTrigger_ExistingSchedule_DoesNotAdvanceScheduleOrChangePausedState()
+    {
+        await using var context = await this.CreateContextAsync();
+        await context.Store.CreateOrUpdateRecurringScheduleAsync(CreateSchedule("schedule-a"));
+        var before = await context.Store.GetRecurringScheduleAsync("schedule-a");
+        before.ShouldNotBeNull();
+
+        await context.Store.TriggerRecurringScheduleAsync(new TriggerRecurringScheduleRequest("schedule-a", DefaultRetryPolicy: null));
+
+        var after = await context.Store.GetRecurringScheduleAsync("schedule-a");
+        after.ShouldNotBeNull();
+        after.NextFireAtUtc.ShouldBe(before.NextFireAtUtc);
+        after.IsPaused.ShouldBe(before.IsPaused);
+    }
+
     protected static async ValueTask<ClaimedJob> ClaimAsync(
         IJobStore store,
         string nodeId = "node-1",
@@ -656,7 +788,9 @@ protected static UpsertRecurringScheduleRequest CreateSchedule(
         IReadOnlyList<string>? groupKeys = null,
         RetryPolicy? retryPolicy = null,
         RecurringOverlapMode overlapMode = RecurringOverlapMode.Skip,
-        DateTimeOffset? upsertedAtUtc = null)
+        DateTimeOffset? upsertedAtUtc = null,
+        JobInvocationTargetKind invocationTargetKind = JobInvocationTargetKind.Instance,
+        IReadOnlyList<JobMethodParameterBinding>? methodParameterBindings = null)
       => new(
         scheduleKey,
         "* * * * *",
@@ -668,7 +802,9 @@ protected static UpsertRecurringScheduleRequest CreateSchedule(
         groupKeys ?? [],
         retryPolicy,
         overlapMode,
-        upsertedAtUtc ?? DateTimeOffset.UtcNow);
+        upsertedAtUtc ?? DateTimeOffset.UtcNow,
+        InvocationTargetKind: invocationTargetKind,
+        MethodParameterBindings: methodParameterBindings);
 
     protected static UpsertRecurringScheduleRequest CreateDueSchedule(
         string scheduleKey,
diff --git a/test/Sheddueller.Testing.Tests/CapturingRecurringScheduleManagerTests.cs b/test/Sheddueller.Testing.Tests/CapturingRecurringScheduleManagerTests.cs
index fa54002..6ffdf4f 100644
--- a/test/Sheddueller.Testing.Tests/CapturingRecurringScheduleManagerTests.cs
+++ b/test/Sheddueller.Testing.Tests/CapturingRecurringScheduleManagerTests.cs
@@ -44,6 +44,23 @@ public async Task Capture_AwaitBoundary_FlowsCurrentCapture()
         (await capture.Fake.GetAsync("schedule-a")).ShouldNotBeNull();
     }
 
+    [Fact]
+    public async Task Capture_Trigger_RecordsThroughInjectedInterface()
+    {
+        var capturingManager = CreateCapturingManager();
+
+        using var capture = capturingManager.Capture();
+
+        await ((IRecurringScheduleManager)capturingManager).CreateOrUpdateAsync<TestScheduleService>(
+          "schedule-a",
+          "* * * * *",
+          (s, ct) => s.HandleStringAsync("alpha", ct));
+        var result = await capturingManager.TriggerAsync("schedule-a");
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        capture.Fake.TriggeredJobs.ShouldHaveSingleItem().SourceScheduleKey.ShouldBe("schedule-a");
+    }
+
     [Fact]
     public async Task CreateOrUpdate_NoActiveCapture_SucceedsAndDiscardsRecording()
     {
@@ -69,6 +86,7 @@ public async Task NoActiveCapture_ReadAndCommands_ReturnDefaultEmptyState()
         var capturingManager = CreateCapturingManager();
 
         (await capturingManager.DeleteAsync("schedule-a")).ShouldBeFalse();
+        (await capturingManager.TriggerAsync("schedule-a")).Status.ShouldBe(RecurringScheduleTriggerStatus.NotFound);
         (await capturingManager.PauseAsync("schedule-a")).ShouldBeFalse();
         (await capturingManager.ResumeAsync("schedule-a")).ShouldBeFalse();
         (await capturingManager.GetAsync("schedule-a")).ShouldBeNull();
diff --git a/test/Sheddueller.Testing.Tests/FakeRecurringScheduleManagerTests.cs b/test/Sheddueller.Testing.Tests/FakeRecurringScheduleManagerTests.cs
index 382c9ef..f3a3388 100644
--- a/test/Sheddueller.Testing.Tests/FakeRecurringScheduleManagerTests.cs
+++ b/test/Sheddueller.Testing.Tests/FakeRecurringScheduleManagerTests.cs
@@ -119,6 +119,68 @@ await fake.CreateOrUpdateAsync<TestScheduleService>(
         (await fake.ResumeAsync("schedule-a")).ShouldBeFalse();
     }
 
+    [Fact]
+    public async Task Trigger_ExistingSchedule_RecordsTriggeredJobFromTemplate()
+    {
+        var fake = new FakeRecurringScheduleManager();
+        await fake.CreateOrUpdateAsync<TestScheduleService>(
+          "schedule-a",
+          "* * * * *",
+          (s, ct) => s.HandleStringAsync("alpha", ct),
+          new RecurringScheduleOptions(
+            Priority: 7,
+            ConcurrencyGroupKeys: ["group-a"],
+            RetryPolicy: new RetryPolicy(3, RetryBackoffKind.Fixed, TimeSpan.FromSeconds(2)),
+            OverlapMode: RecurringOverlapMode.Allow,
+            Tags: [new JobTag("tenant", "acme")]));
+
+        var result = await fake.TriggerAsync("schedule-a");
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        result.JobId.ShouldNotBeNull();
+        result.EnqueueSequence.ShouldBe(0);
+        fake.TriggeredJobs.Count.ShouldBe(1);
+        fake.TriggeredJobs[0].JobId.ShouldBe(result.JobId.Value);
+        fake.TriggeredJobs[0].SourceScheduleKey.ShouldBe("schedule-a");
+        fake.TriggeredJobs[0].Priority.ShouldBe(7);
+        fake.TriggeredJobs[0].ConcurrencyGroupKeys.ShouldBe(["group-a"]);
+        fake.TriggeredJobs[0].RetryPolicy.ShouldBe(new RetryPolicy(3, RetryBackoffKind.Fixed, TimeSpan.FromSeconds(2)));
+        fake.TriggeredJobs[0].Tags.ShouldBe([new JobTag("tenant", "acme")]);
+    }
+
+    [Fact]
+    public async Task Trigger_MissingPausedSkipAndAllowSchedules_ReturnsMatchingStatus()
+    {
+        var fake = new FakeRecurringScheduleManager();
+        await fake.CreateOrUpdateAsync<TestScheduleService>(
+          "skip-schedule",
+          "* * * * *",
+          (s, ct) => s.HandleStringAsync("skip", ct));
+        await fake.CreateOrUpdateAsync<TestScheduleService>(
+          "allow-schedule",
+          "* * * * *",
+          (s, ct) => s.HandleStringAsync("allow", ct),
+          new RecurringScheduleOptions(OverlapMode: RecurringOverlapMode.Allow));
+        await fake.CreateOrUpdateAsync<TestScheduleService>(
+          "paused-schedule",
+          "* * * * *",
+          (s, ct) => s.HandleStringAsync("paused", ct));
+        await fake.PauseAsync("paused-schedule");
+
+        (await fake.TriggerAsync("missing")).Status.ShouldBe(RecurringScheduleTriggerStatus.NotFound);
+        (await fake.TriggerAsync("paused-schedule")).Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await fake.TriggerAsync("skip-schedule")).Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await fake.TriggerAsync("skip-schedule")).Status.ShouldBe(RecurringScheduleTriggerStatus.SkippedActiveOccurrence);
+        (await fake.TriggerAsync("allow-schedule")).Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        (await fake.TriggerAsync("allow-schedule")).Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        fake.TriggeredJobs.Select(job => job.SourceScheduleKey).ShouldBe([
+            "paused-schedule",
+            "skip-schedule",
+            "allow-schedule",
+            "allow-schedule",
+        ]);
+    }
+
     [Fact]
     public async Task Delete_ExistingSchedule_RemovesScheduleFromMatches()
     {
diff --git a/test/Sheddueller.Tests/RecordingJobStore.cs b/test/Sheddueller.Tests/RecordingJobStore.cs
index 90fe332..4e627ce 100644
--- a/test/Sheddueller.Tests/RecordingJobStore.cs
+++ b/test/Sheddueller.Tests/RecordingJobStore.cs
@@ -5,10 +5,15 @@ namespace Sheddueller.Tests;
 internal sealed class RecordingJobStore : IJobStore
 {
     private readonly List<EnqueueJobRequest> enqueuedRequests = [];
+    private readonly List<TriggerRecurringScheduleRequest> triggerRequests = [];
     private long nextSequence;
 
     public IReadOnlyList<EnqueueJobRequest> EnqueuedRequests => this.enqueuedRequests;
 
+    public IReadOnlyList<TriggerRecurringScheduleRequest> TriggerRequests => this.triggerRequests;
+
+    public RecurringScheduleTriggerResult TriggerResult { get; set; } = new(RecurringScheduleTriggerStatus.NotFound);
+
     public EnqueueJobRequest GetRequest(Guid jobId)
       => this.enqueuedRequests.Single(request => request.JobId == jobId);
 
@@ -105,6 +110,16 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateRecurringScheduleA
         CancellationToken cancellationToken = default)
       => throw CreateUnsupportedException();
 
+    public ValueTask<RecurringScheduleTriggerResult> TriggerRecurringScheduleAsync(
+        TriggerRecurringScheduleRequest request,
+        CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        this.triggerRequests.Add(request);
+
+        return ValueTask.FromResult(this.TriggerResult);
+    }
+
     public ValueTask<bool> DeleteRecurringScheduleAsync(
         string scheduleKey,
         CancellationToken cancellationToken = default)
diff --git a/test/Sheddueller.Tests/RecurringScheduleManagerTests.cs b/test/Sheddueller.Tests/RecurringScheduleManagerTests.cs
new file mode 100644
index 0000000..7b95ccb
--- /dev/null
+++ b/test/Sheddueller.Tests/RecurringScheduleManagerTests.cs
@@ -0,0 +1,90 @@
+namespace Sheddueller.Tests;
+
+using Microsoft.Extensions.Options;
+
+using Sheddueller.Runtime;
+using Sheddueller.Serialization;
+
+using Shouldly;
+
+public sealed class RecurringScheduleManagerTests
+{
+    [Fact]
+    public async Task Trigger_InvalidScheduleKey_ThrowsWithoutCallingStore()
+    {
+        var store = new RecordingJobStore();
+        var wakeSignal = new RecordingWakeSignal();
+        var manager = CreateManager(store, wakeSignal);
+
+        await Should.ThrowAsync<ArgumentException>(() => manager.TriggerAsync(string.Empty).AsTask());
+
+        store.TriggerRequests.ShouldBeEmpty();
+        wakeSignal.NotifyCount.ShouldBe(0);
+    }
+
+    [Fact]
+    public async Task Trigger_ValidScheduleKey_PassesDefaultRetryPolicyToStore()
+    {
+        var store = new RecordingJobStore
+        {
+            TriggerResult = new RecurringScheduleTriggerResult(
+              RecurringScheduleTriggerStatus.Enqueued,
+              Guid.Parse("2964dcd3-4dc9-4762-a8f7-3d5da608b1ed"),
+              EnqueueSequence: 12),
+        };
+        var defaultRetryPolicy = new RetryPolicy(4, RetryBackoffKind.Fixed, TimeSpan.FromSeconds(2));
+        var manager = CreateManager(
+          store,
+          new RecordingWakeSignal(),
+          new ShedduellerOptions { DefaultRetryPolicy = defaultRetryPolicy });
+
+        var result = await manager.TriggerAsync("schedule-a");
+
+        result.Status.ShouldBe(RecurringScheduleTriggerStatus.Enqueued);
+        store.TriggerRequests.ShouldHaveSingleItem().DefaultRetryPolicy.ShouldBe(defaultRetryPolicy);
+    }
+
+    [Theory]
+    [InlineData(RecurringScheduleTriggerStatus.Enqueued, 1)]
+    [InlineData(RecurringScheduleTriggerStatus.NotFound, 0)]
+    [InlineData(RecurringScheduleTriggerStatus.SkippedActiveOccurrence, 0)]
+    public async Task Trigger_Result_WakesOnlyWhenJobWasEnqueued(
+        RecurringScheduleTriggerStatus status,
+        int expectedNotifyCount)
+    {
+        var store = new RecordingJobStore
+        {
+            TriggerResult = status == RecurringScheduleTriggerStatus.Enqueued
+              ? new RecurringScheduleTriggerResult(status, Guid.NewGuid(), EnqueueSequence: 1)
+              : new RecurringScheduleTriggerResult(status),
+        };
+        var wakeSignal = new RecordingWakeSignal();
+        var manager = CreateManager(store, wakeSignal);
+
+        await manager.TriggerAsync("schedule-a");
+
+        wakeSignal.NotifyCount.ShouldBe(expectedNotifyCount);
+    }
+
+    private static RecurringScheduleManager CreateManager(
+        RecordingJobStore store,
+        RecordingWakeSignal wakeSignal,
+        ShedduellerOptions? options = null)
+      => new(
+        store,
+        new SystemTextJsonJobPayloadSerializer(),
+        Options.Create(options ?? new ShedduellerOptions()),
+        TimeProvider.System,
+        wakeSignal);
+
+    private sealed class RecordingWakeSignal : IShedduellerWakeSignal
+    {
+        public int NotifyCount { get; private set; }
+
+        public void Notify()
+          => this.NotifyCount++;
+
+        public ValueTask WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
+          => ValueTask.CompletedTask;
+    }
+}
diff --git a/test/Sheddueller.Tests/RegistrationTests.cs b/test/Sheddueller.Tests/RegistrationTests.cs
index 808ac48..a09ef9f 100644
--- a/test/Sheddueller.Tests/RegistrationTests.cs
+++ b/test/Sheddueller.Tests/RegistrationTests.cs
@@ -2,6 +2,7 @@ namespace Sheddueller.Tests;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
 
 using Sheddueller.Runtime;
 using Sheddueller.Serialization;
@@ -55,6 +56,20 @@ public void AddSheddueller_WorkerOnlyOptions_AreNotHostedValidated()
         provider.GetServices<IHostedService>().ShouldBeEmpty();
     }
 
+    [Fact]
+    public void AddSheddueller_ServiceProviderAwareOptions_CanReadRegisteredServices()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton(new NodeConfiguration("node-from-di"));
+        services.AddSheddueller(builder => builder.ConfigureOptions((serviceProvider, options) =>
+        {
+            options.NodeId = serviceProvider.GetRequiredService<NodeConfiguration>().NodeId;
+        }));
+        using var provider = services.BuildServiceProvider();
+
+        provider.GetRequiredService<IOptions<ShedduellerOptions>>().Value.NodeId.ShouldBe("node-from-di");
+    }
+
     private sealed class PassThroughSerializer : IJobPayloadSerializer
     {
         public ValueTask<SerializedJobPayload> SerializeAsync(
@@ -73,4 +88,6 @@ public ValueTask<SerializedJobPayload> SerializeAsync(
             return ValueTask.FromResult<IReadOnlyList<object?>>(Array.Empty<object?>());
         }
     }
+
+    private sealed record NodeConfiguration(string NodeId);
 }
diff --git a/test/Sheddueller.Worker.Tests/RegistrationTests.cs b/test/Sheddueller.Worker.Tests/RegistrationTests.cs
index 87caf0c..1f36fac 100644
--- a/test/Sheddueller.Worker.Tests/RegistrationTests.cs
+++ b/test/Sheddueller.Worker.Tests/RegistrationTests.cs
@@ -127,6 +127,11 @@ public ValueTask<RecurringScheduleUpsertResult> CreateOrUpdateRecurringScheduleA
             CancellationToken cancellationToken = default)
           => ValueTask.FromResult(RecurringScheduleUpsertResult.Created);
 
+        public ValueTask<RecurringScheduleTriggerResult> TriggerRecurringScheduleAsync(
+            TriggerRecurringScheduleRequest request,
+            CancellationToken cancellationToken = default)
+          => ValueTask.FromResult(new RecurringScheduleTriggerResult(RecurringScheduleTriggerStatus.NotFound));
+
         public ValueTask<bool> DeleteRecurringScheduleAsync(
             string scheduleKey,
             CancellationToken cancellationToken = default)