diff --git a/TickerQ.sln b/TickerQ.sln
index c448310a..ef9bb45b 100644
--- a/TickerQ.sln
+++ b/TickerQ.sln
@@ -40,6 +40,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TickerQ.Caching.StackExchan
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TickerQ.Instrumentation.OpenTelemetry", "src\TickerQ.Instrumentation.OpenTelemetry\TickerQ.Instrumentation.OpenTelemetry.csproj", "{D87B9599-22C7-4E82-B300-1239E504E097}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TickerQ.Sample.WebApi", "samples\TickerQ.Sample.WebApi\TickerQ.Sample.WebApi.csproj", "{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TickerQ.Sample.Console", "samples\TickerQ.Sample.Console\TickerQ.Sample.Console.csproj", "{723F26D9-C675-4883-8B62-AEBA370566D4}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -146,6 +150,30 @@ Global
 		{D87B9599-22C7-4E82-B300-1239E504E097}.Release|x64.Build.0 = Release|Any CPU
 		{D87B9599-22C7-4E82-B300-1239E504E097}.Release|x86.ActiveCfg = Release|Any CPU
 		{D87B9599-22C7-4E82-B300-1239E504E097}.Release|x86.Build.0 = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|x64.Build.0 = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Debug|x86.Build.0 = Debug|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|x64.ActiveCfg = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|x64.Build.0 = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|x86.ActiveCfg = Release|Any CPU
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E}.Release|x86.Build.0 = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|x64.Build.0 = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Debug|x86.Build.0 = Debug|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|x64.ActiveCfg = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|x64.Build.0 = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|x86.ActiveCfg = Release|Any CPU
+		{723F26D9-C675-4883-8B62-AEBA370566D4}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -160,5 +188,7 @@ Global
 		{9E6EC713-AD6D-4909-8617-B909D76A6E3A} = {9A4EB4A4-FB92-477C-A6D8-0735579B7BAB}
 		{B3049104-9C15-4933-A440-CA62CFBC5F70} = {BA086F2D-2778-4F58-A9AA-45F560CE3504}
 		{D87B9599-22C7-4E82-B300-1239E504E097} = {BA086F2D-2778-4F58-A9AA-45F560CE3504}
+		{4DC9FE10-966F-4C8A-B7D2-1215DC319B9E} = {45D577FA-DB7A-4B96-BB3F-97DDA0A929D5}
+		{723F26D9-C675-4883-8B62-AEBA370566D4} = {45D577FA-DB7A-4B96-BB3F-97DDA0A929D5}
 	EndGlobalSection
 EndGlobal
diff --git a/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.Designer.cs b/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.Designer.cs
new file mode 100644
index 00000000..09958c0f
--- /dev/null
+++ b/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.Designer.cs
@@ -0,0 +1,229 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+
+#nullable disable
+
+namespace TickerQ.Sample.Console.Migrations
+{
+    [DbContext(typeof(TickerQDbContext))]
+    [Migration("20251123154004_InitialTickerQOperationalStore")]
+    partial class InitialTickerQOperationalStore
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.0");
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.HasIndex("Function", "Expression")
+                        .HasDatabaseName("IX_Function_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RunCondition")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.TimeTickerEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("Children");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.cs b/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.cs
new file mode 100644
index 00000000..9768f32d
--- /dev/null
+++ b/samples/TickerQ.Sample.Console/Migrations/20251123154004_InitialTickerQOperationalStore.cs
@@ -0,0 +1,178 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TickerQ.Sample.Console.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialTickerQOperationalStore : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "ticker");
+
+            migrationBuilder.CreateTable(
+                name: "CronTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Expression = table.Column<string>(type: "TEXT", nullable: true),
+                    Request = table.Column<byte[]>(type: "BLOB", nullable: true),
+                    Retries = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryIntervals = table.Column<string>(type: "TEXT", nullable: true),
+                    Function = table.Column<string>(type: "TEXT", nullable: true),
+                    Description = table.Column<string>(type: "TEXT", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickers", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TimeTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Function = table.Column<string>(type: "TEXT", nullable: true),
+                    Description = table.Column<string>(type: "TEXT", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
+                    LockHolder = table.Column<string>(type: "TEXT", nullable: true),
+                    Request = table.Column<byte[]>(type: "BLOB", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    LockedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExceptionMessage = table.Column<string>(type: "TEXT", nullable: true),
+                    SkippedReason = table.Column<string>(type: "TEXT", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "INTEGER", nullable: false),
+                    Retries = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryCount = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryIntervals = table.Column<string>(type: "TEXT", nullable: true),
+                    ParentId = table.Column<Guid>(type: "TEXT", nullable: true),
+                    RunCondition = table.Column<int>(type: "INTEGER", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TimeTickers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TimeTickers_TimeTickers_ParentId",
+                        column: x => x.ParentId,
+                        principalSchema: "ticker",
+                        principalTable: "TimeTickers",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
+                    LockHolder = table.Column<string>(type: "TEXT", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    CronTickerId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    LockedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExceptionMessage = table.Column<string>(type: "TEXT", nullable: true),
+                    SkippedReason = table.Column<string>(type: "TEXT", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "INTEGER", nullable: false),
+                    RetryCount = table.Column<int>(type: "INTEGER", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickerOccurrences", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_CronTickerOccurrences_CronTickers_CronTickerId",
+                        column: x => x.CronTickerId,
+                        principalSchema: "ticker",
+                        principalTable: "CronTickers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_CronTickerId",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "CronTickerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_Status_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "UQ_CronTickerId_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "CronTickerId", "ExecutionTime" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickers_Expression",
+                schema: "ticker",
+                table: "CronTickers",
+                column: "Expression");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Function_Expression",
+                schema: "ticker",
+                table: "CronTickers",
+                columns: new[] { "Function", "Expression" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_Status_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTickers_ParentId",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "ParentId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "TimeTickers",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "CronTickers",
+                schema: "ticker");
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.Console/Migrations/TickerQDbContextModelSnapshot.cs b/samples/TickerQ.Sample.Console/Migrations/TickerQDbContextModelSnapshot.cs
new file mode 100644
index 00000000..63d648cd
--- /dev/null
+++ b/samples/TickerQ.Sample.Console/Migrations/TickerQDbContextModelSnapshot.cs
@@ -0,0 +1,226 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+
+#nullable disable
+
+namespace TickerQ.Sample.Console.Migrations
+{
+    [DbContext(typeof(TickerQDbContext))]
+    partial class TickerQDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.0");
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.HasIndex("Function", "Expression")
+                        .HasDatabaseName("IX_Function_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RunCondition")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.TimeTickerEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("Children");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.Console/Program.cs b/samples/TickerQ.Sample.Console/Program.cs
new file mode 100644
index 00000000..a04d5a9e
--- /dev/null
+++ b/samples/TickerQ.Sample.Console/Program.cs
@@ -0,0 +1,84 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using TickerQ.DependencyInjection;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+using TickerQ.EntityFrameworkCore.DependencyInjection;
+using TickerQ.Utilities;
+using TickerQ.Utilities.Base;
+using TickerQ.Utilities.Entities;
+using TickerQ.Utilities.Interfaces.Managers;
+
+var host = Host.CreateDefaultBuilder(args)
+    .ConfigureServices((context, services) =>
+    {
+        // Configure TickerQ with SQLite operational store (file-based)
+        services.AddTickerQ(options =>
+        {
+            options.AddOperationalStore(efOptions =>
+            {
+                efOptions.UseTickerQDbContext<TickerQDbContext>(dbOptions =>
+                {
+                    dbOptions.UseSqlite(
+                        "Data Source=tickerq-console.db",
+                        b => b.MigrationsAssembly("TickerQ.Sample.Console"));
+                });
+            });
+        });
+
+        services.AddHostedService<SampleScheduler>();
+    })
+    .Build();
+
+// Ensure TickerQ operational store schema is applied
+using (var scope = host.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<TickerQDbContext>();
+    db.Database.Migrate();
+}
+
+// Build function metadata so TickerFunctionProvider.TickerFunctions is initialized
+TickerFunctionProvider.Build();
+
+await host.RunAsync();
+
+// Simple sample job
+public class ConsoleSampleJobs
+{
+    [TickerFunction("ConsoleSample_HelloWorld")]
+    public Task HelloWorldAsync(TickerFunctionContext context, CancellationToken cancellationToken)
+    {
+        Console.WriteLine($"[Console] Hello from TickerQ! Id={context.Id}, ScheduledFor={context.ScheduledFor:O}");
+        return Task.CompletedTask;
+    }
+}
+
+// Hosted service that schedules a single job on startup
+public class SampleScheduler : IHostedService
+{
+    private readonly ITimeTickerManager<TimeTickerEntity> _timeTickerManager;
+
+    public SampleScheduler(ITimeTickerManager<TimeTickerEntity> timeTickerManager)
+    {
+        _timeTickerManager = timeTickerManager;
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        var result = await _timeTickerManager.AddAsync(new TimeTickerEntity
+        {
+            Function = "ConsoleSample_HelloWorld",
+            ExecutionTime = DateTime.UtcNow.AddSeconds(5)
+        }, cancellationToken);
+
+        if (!result.IsSucceeded)
+        {
+            Console.WriteLine($"Failed to schedule console sample job. Exception: {result.Exception}");
+            return;
+        }
+
+        Console.WriteLine($"Scheduled console sample job with Id={result.Result.Id}, ScheduledFor={result.Result.ExecutionTime:O}");
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
diff --git a/samples/TickerQ.Sample.Console/TickerQ.Sample.Console.csproj b/samples/TickerQ.Sample.Console/TickerQ.Sample.Console.csproj
new file mode 100644
index 00000000..ed863b6f
--- /dev/null
+++ b/samples/TickerQ.Sample.Console/TickerQ.Sample.Console.csproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="[9.0.0,10.0.0)" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="[9.0.0,10.0.0)" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\TickerQ.SourceGenerator\TickerQ.SourceGenerator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+    <ProjectReference Include="..\..\src\TickerQ\TickerQ.csproj" />
+    <ProjectReference Include="..\..\src\TickerQ.EntityFrameworkCore\TickerQ.EntityFrameworkCore.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.Designer.cs b/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.Designer.cs
new file mode 100644
index 00000000..87405b90
--- /dev/null
+++ b/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.Designer.cs
@@ -0,0 +1,229 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+
+#nullable disable
+
+namespace TickerQ.Sample.WebApi.Migrations
+{
+    [DbContext(typeof(TickerQDbContext))]
+    [Migration("20251123154016_InitialTickerQOperationalStore")]
+    partial class InitialTickerQOperationalStore
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.0");
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.HasIndex("Function", "Expression")
+                        .HasDatabaseName("IX_Function_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RunCondition")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.TimeTickerEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("Children");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.cs b/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.cs
new file mode 100644
index 00000000..6c94dd30
--- /dev/null
+++ b/samples/TickerQ.Sample.WebApi/Migrations/20251123154016_InitialTickerQOperationalStore.cs
@@ -0,0 +1,178 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TickerQ.Sample.WebApi.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialTickerQOperationalStore : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "ticker");
+
+            migrationBuilder.CreateTable(
+                name: "CronTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Expression = table.Column<string>(type: "TEXT", nullable: true),
+                    Request = table.Column<byte[]>(type: "BLOB", nullable: true),
+                    Retries = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryIntervals = table.Column<string>(type: "TEXT", nullable: true),
+                    Function = table.Column<string>(type: "TEXT", nullable: true),
+                    Description = table.Column<string>(type: "TEXT", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickers", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TimeTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Function = table.Column<string>(type: "TEXT", nullable: true),
+                    Description = table.Column<string>(type: "TEXT", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
+                    LockHolder = table.Column<string>(type: "TEXT", nullable: true),
+                    Request = table.Column<byte[]>(type: "BLOB", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    LockedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExceptionMessage = table.Column<string>(type: "TEXT", nullable: true),
+                    SkippedReason = table.Column<string>(type: "TEXT", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "INTEGER", nullable: false),
+                    Retries = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryCount = table.Column<int>(type: "INTEGER", nullable: false),
+                    RetryIntervals = table.Column<string>(type: "TEXT", nullable: true),
+                    ParentId = table.Column<Guid>(type: "TEXT", nullable: true),
+                    RunCondition = table.Column<int>(type: "INTEGER", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TimeTickers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TimeTickers_TimeTickers_ParentId",
+                        column: x => x.ParentId,
+                        principalSchema: "ticker",
+                        principalTable: "TimeTickers",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
+                    LockHolder = table.Column<string>(type: "TEXT", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    CronTickerId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    LockedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    ExceptionMessage = table.Column<string>(type: "TEXT", nullable: true),
+                    SkippedReason = table.Column<string>(type: "TEXT", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "INTEGER", nullable: false),
+                    RetryCount = table.Column<int>(type: "INTEGER", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickerOccurrences", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_CronTickerOccurrences_CronTickers_CronTickerId",
+                        column: x => x.CronTickerId,
+                        principalSchema: "ticker",
+                        principalTable: "CronTickers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_CronTickerId",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "CronTickerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_Status_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "UQ_CronTickerId_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "CronTickerId", "ExecutionTime" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickers_Expression",
+                schema: "ticker",
+                table: "CronTickers",
+                column: "Expression");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Function_Expression",
+                schema: "ticker",
+                table: "CronTickers",
+                columns: new[] { "Function", "Expression" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_Status_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTickers_ParentId",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "ParentId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "TimeTickers",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "CronTickers",
+                schema: "ticker");
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.WebApi/Migrations/TickerQDbContextModelSnapshot.cs b/samples/TickerQ.Sample.WebApi/Migrations/TickerQDbContextModelSnapshot.cs
new file mode 100644
index 00000000..81c3d049
--- /dev/null
+++ b/samples/TickerQ.Sample.WebApi/Migrations/TickerQDbContextModelSnapshot.cs
@@ -0,0 +1,226 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+
+#nullable disable
+
+namespace TickerQ.Sample.WebApi.Migrations
+{
+    [DbContext(typeof(TickerQDbContext))]
+    partial class TickerQDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.0");
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.HasIndex("Function", "Expression")
+                        .HasDatabaseName("IX_Function_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExceptionMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("BLOB");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("INTEGER");
+
+                    b.PrimitiveCollection<string>("RetryIntervals")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RunCondition")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SkippedReason")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.CronTickerOccurrenceEntity<TickerQ.Utilities.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.Utilities.Entities.TimeTickerEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("TickerQ.Utilities.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("Children");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/samples/TickerQ.Sample.WebApi/Program.cs b/samples/TickerQ.Sample.WebApi/Program.cs
new file mode 100644
index 00000000..44c56e5f
--- /dev/null
+++ b/samples/TickerQ.Sample.WebApi/Program.cs
@@ -0,0 +1,61 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using TickerQ.DependencyInjection;
+using TickerQ.EntityFrameworkCore.DbContextFactory;
+using TickerQ.EntityFrameworkCore.DependencyInjection;
+using TickerQ.Utilities.Base;
+using TickerQ.Utilities.Entities;
+using TickerQ.Utilities.Interfaces.Managers;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// TickerQ setup with SQLite operational store (file-based)
+builder.Services.AddTickerQ(options =>
+{
+    options.AddOperationalStore(efOptions =>
+    {
+        efOptions.UseTickerQDbContext<TickerQDbContext>(dbOptions =>
+        {
+            dbOptions.UseSqlite(
+                "Data Source=tickerq-webapi.db",
+                b => b.MigrationsAssembly("TickerQ.Sample.WebApi"));
+        });
+    });
+});
+
+var app = builder.Build();
+
+// Ensure TickerQ operational store schema is applied
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<TickerQDbContext>();
+    db.Database.Migrate();
+}
+
+// Activate TickerQ job processor (mirrors docs' minimal setup)
+app.UseTickerQ();
+
+// Minimal endpoint to schedule the sample job
+app.MapPost("/schedule-sample", async (ITimeTickerManager<TimeTickerEntity> manager) =>
+{
+    var result = await manager.AddAsync(new TimeTickerEntity
+    {
+        Function = "WebApiSample_HelloWorld",
+        ExecutionTime = DateTime.UtcNow.AddSeconds(5)
+    });
+
+    return Results.Ok(new { result.Result.Id, ScheduledFor = result.Result.ExecutionTime });
+});
+
+app.Run();
+
+// Simple sample job
+public class SampleJobs
+{
+    [TickerFunction("WebApiSample_HelloWorld")]
+    public Task HelloWorldAsync(TickerFunctionContext context, CancellationToken cancellationToken)
+    {
+        Console.WriteLine($"[WebApi] Hello from TickerQ! Id={context.Id}, ScheduledFor={context.ScheduledFor:O}");
+        return Task.CompletedTask;
+    }
+}
diff --git a/samples/TickerQ.Sample.WebApi/TickerQ.Sample.WebApi.csproj b/samples/TickerQ.Sample.WebApi/TickerQ.Sample.WebApi.csproj
new file mode 100644
index 00000000..fe4590fb
--- /dev/null
+++ b/samples/TickerQ.Sample.WebApi/TickerQ.Sample.WebApi.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="[9.0.0,10.0.0)" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="[9.0.0,10.0.0)" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\TickerQ.SourceGenerator\TickerQ.SourceGenerator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+    <ProjectReference Include="..\..\src\TickerQ\TickerQ.csproj" />
+    <ProjectReference Include="..\..\src\TickerQ.EntityFrameworkCore\TickerQ.EntityFrameworkCore.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/TickerQ.Dashboard/DependencyInjection/ServiceCollectionExtensions.cs b/src/TickerQ.Dashboard/DependencyInjection/ServiceCollectionExtensions.cs
index c1c28724..81a78c5e 100644
--- a/src/TickerQ.Dashboard/DependencyInjection/ServiceCollectionExtensions.cs
+++ b/src/TickerQ.Dashboard/DependencyInjection/ServiceCollectionExtensions.cs
@@ -127,7 +127,7 @@ internal static void UseDashboardWithEndpoints<TTimeTicker, TCronTicker>(this IA
                             var htmlContent = await reader.ReadToEndAsync();
 
                             // Inject the base tag and other replacements into the HTML
-                            htmlContent = ReplaceBasePath(htmlContent, basePath, config);
+                            htmlContent = ReplaceBasePath(htmlContent, context, basePath, config);
 
                             context.Response.ContentType = "text/html";
                             context.Response.StatusCode = 200;
@@ -149,11 +149,19 @@ private static string NormalizeBasePath(string basePath)
             return basePath.TrimEnd('/');
         }
 
-        private static string ReplaceBasePath(string htmlContent, string basePath, DashboardOptionsBuilder config)
+        private static string ReplaceBasePath(string htmlContent, HttpContext httpContext, string basePath, DashboardOptionsBuilder config)
         {
             if (string.IsNullOrEmpty(htmlContent))
                 return htmlContent ?? string.Empty;
 
+            // Compute the frontend base path as PathBase + backend basePath.
+            // This ensures correct URLs when the host app uses UsePathBase.
+            var pathBase = httpContext.Request.PathBase.HasValue
+                ? httpContext.Request.PathBase.Value
+                : string.Empty;
+
+            var frontendBasePath = CombinePathBase(pathBase, basePath);
+
             // Build the config object
             var authInfo = new
             {
@@ -164,7 +172,7 @@ private static string ReplaceBasePath(string htmlContent, string basePath, Dashb
             
             var envConfig = new
             {
-                basePath,
+                basePath = frontendBasePath,
                 backendDomain = config.BackendDomain,
                 auth = authInfo
             };
@@ -181,7 +189,7 @@ private static string ReplaceBasePath(string htmlContent, string basePath, Dashb
             json = SanitizeForInlineScript(json);
 
             // Add base tag for proper asset loading
-            var baseTag = $@"<base href=""{basePath}/"" />";
+            var baseTag = $@"<base href=""{frontendBasePath}/"" />";
 
             // Inline bootstrap: set TickerQConfig and derive __dynamic_base__ (vite-plugin-dynamic-base)
             var script = $@"<script>
@@ -215,6 +223,33 @@ private static string ReplaceBasePath(string htmlContent, string basePath, Dashb
             return fullInjection + htmlContent;
         }
 
+        private static string CombinePathBase(string pathBase, string basePath)
+        {
+            pathBase ??= string.Empty;
+            basePath ??= "/";
+
+            if (string.IsNullOrEmpty(basePath) || basePath == "/")
+            {
+                return string.IsNullOrEmpty(pathBase) ? "/" : pathBase;
+            }
+
+            if (string.IsNullOrEmpty(pathBase))
+                return basePath;
+
+            // If basePath already includes the pathBase prefix, treat it as the full frontend path
+            // This prevents /cool-app/cool-app/... and similar double-prefix issues when users
+            // configure BasePath with the full URL segment.
+            if (basePath.StartsWith(pathBase, StringComparison.OrdinalIgnoreCase))
+                return basePath;
+
+            // Normalize to avoid double slashes
+            if (pathBase.EndsWith("/"))
+                pathBase = pathBase.TrimEnd('/');
+
+            // basePath is already normalized to start with '/'
+            return pathBase + basePath;
+        }
+
         /// <summary>
         /// Prevents &lt;/script&gt; in JSON strings from prematurely closing the inline script.
         /// </summary>
diff --git a/src/TickerQ.Dashboard/Endpoints/DashboardEndpoints.cs b/src/TickerQ.Dashboard/Endpoints/DashboardEndpoints.cs
index c3baaa39..b70b36ae 100644
--- a/src/TickerQ.Dashboard/Endpoints/DashboardEndpoints.cs
+++ b/src/TickerQ.Dashboard/Endpoints/DashboardEndpoints.cs
@@ -1,17 +1,17 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Microsoft.AspNetCore.Authorization;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.Mvc;
 using TickerQ.Dashboard.Authentication;
 using TickerQ.Dashboard.Hubs;
 using TickerQ.Utilities;
-using TickerQ.Utilities.DashboardDtos;
 using TickerQ.Utilities.Entities;
 using TickerQ.Utilities.Enums;
 using TickerQ.Utilities.Interfaces;
@@ -85,6 +85,10 @@ public static void MapDashboardEndpoints<TTimeTicker, TCronTicker>(this IEndpoin
             .WithName("DeleteTimeTicker")
             .WithSummary("Delete time ticker");
 
+        apiGroup.MapDelete("/time-ticker/delete-batch", DeleteTimeTickersBatch<TTimeTicker, TCronTicker>)
+            .WithName("DeleteTimeTickersBatch")
+            .WithSummary("Delete multiple time tickers");
+
         // Cron Tickers endpoints
         apiGroup.MapGet("/cron-tickers", GetCronTickers<TTimeTicker, TCronTicker>)
             .WithName("GetCronTickers")
@@ -190,13 +194,6 @@ public static void MapDashboardEndpoints<TTimeTicker, TCronTicker>(this IEndpoin
             .AllowAnonymous();
 
     }
-
-    // Authorization policy helper for host authentication
-    private static Action<AuthorizationPolicyBuilder> GetHostAuthorizationPolicy()
-    {
-        return policy => policy.RequireAuthenticatedUser();
-    }
-
     #region Endpoint Handlers
     
     private static IResult GetAuthInfo(IAuthService authService, DashboardOptionsBuilder dashboardOptions)
@@ -376,6 +373,23 @@ private static async Task<IResult> DeleteTimeTicker<TTimeTicker, TCronTicker>(
         }, dashboardOptions.DashboardJsonOptions);
     }
 
+    private static async Task<IResult> DeleteTimeTickersBatch<TTimeTicker, TCronTicker>(
+        [FromBody] Guid[] ids,
+        ITimeTickerManager<TTimeTicker> timeTickerManager,
+        DashboardOptionsBuilder dashboardOptions,
+        CancellationToken cancellationToken)
+        where TTimeTicker : TimeTickerEntity<TTimeTicker>, new()
+        where TCronTicker : CronTickerEntity, new()
+    {
+        var idList = ids is { Length: > 0 } ? new List<Guid>(ids) : new List<Guid>();
+        var result = await timeTickerManager.DeleteBatchAsync(idList, cancellationToken);
+        
+        return Results.Json(new { 
+            success = result.IsSucceeded, 
+            message = result.IsSucceeded ? "Time tickers deleted successfully" : "Failed to delete time tickers"
+        }, dashboardOptions.DashboardJsonOptions);
+    }
+
     private static async Task<IResult> GetCronTickers<TTimeTicker, TCronTicker>(
         ITickerDashboardRepository<TTimeTicker, TCronTicker> repository, DashboardOptionsBuilder dashboardOptions,
         CancellationToken cancellationToken)
diff --git a/src/TickerQ.Dashboard/Hubs/TickerQNotificationHubSender.cs b/src/TickerQ.Dashboard/Hubs/TickerQNotificationHubSender.cs
index 7b2f5ebc..9d9841c6 100644
--- a/src/TickerQ.Dashboard/Hubs/TickerQNotificationHubSender.cs
+++ b/src/TickerQ.Dashboard/Hubs/TickerQNotificationHubSender.cs
@@ -1,8 +1,8 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.SignalR;
 using TickerQ.Utilities.Entities;
-using TickerQ.Utilities.Enums;
 using TickerQ.Utilities.Interfaces;
 using TickerQ.Utilities.Models;
 
@@ -11,10 +11,14 @@ namespace TickerQ.Dashboard.Hubs
     internal class TickerQNotificationHubSender : ITickerQNotificationHubSender
     {
         private readonly IHubContext<TickerQNotificationHub> _hubContext;
+        private readonly Timer _timeTickerUpdateTimer;
+        private int _hasPendingTimeTickerUpdate;
+        private static readonly TimeSpan TimeTickerUpdateDebounce = TimeSpan.FromMilliseconds(100);
         
         public TickerQNotificationHubSender(IHubContext<TickerQNotificationHub> hubContext)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _timeTickerUpdateTimer = new Timer(TimeTickerUpdateCallback, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
         }
 
         public async Task AddCronTickerNotifyAsync(object cronTicker)
@@ -32,9 +36,14 @@ public async Task RemoveCronTickerNotifyAsync(Guid id)
             await _hubContext.Clients.All.SendAsync("RemoveCronTickerNotification", id);
         }
 
-        public async Task AddTimeTickerNotifyAsync(object timeTicker)
+        public async Task AddTimeTickerNotifyAsync(Guid id)
         {
-            await _hubContext.Clients.All.SendAsync("AddTimeTickerNotification", timeTicker);
+            await _hubContext.Clients.All.SendAsync("AddTimeTickerNotification", id);
+        }
+        
+        public async Task AddTimeTickersBatchNotifyAsync()
+        {
+            await _hubContext.Clients.All.SendAsync("AddTimeTickersBatchNotification");
         }
 
         public async Task UpdateTimeTickerNotifyAsync(object timeTicker)
@@ -83,39 +92,45 @@ public async Task UpdateCronOccurrenceAsync(Guid groupId, object occurrence)
             await _hubContext.Clients.Group(groupId.ToString()).SendAsync("UpdateCronOccurrenceNotification", occurrence);
         }
 
-        public async Task UpdateTimeTickerFromInternalFunctionContext<TTimeTicker>(InternalFunctionContext internalFunctionContext) where TTimeTicker : TimeTickerEntity<TTimeTicker>, new()
+        public Task UpdateTimeTickerFromInternalFunctionContext<TTimeTicker>(InternalFunctionContext internalFunctionContext)
+            where TTimeTicker : TimeTickerEntity<TTimeTicker>, new()
         {
-            var timeTicker = new TTimeTicker
+            // Debounce high-frequency updates into a single notification
+            if (Interlocked.Exchange(ref _hasPendingTimeTickerUpdate, 1) == 0)
             {
-                Id = internalFunctionContext.TickerId,
-                Status = internalFunctionContext.Status,
-                ExecutedAt = internalFunctionContext.ExecutedAt,
-                ExceptionMessage = internalFunctionContext.Status != TickerStatus.Skipped ? internalFunctionContext.ExceptionDetails : null,
-                ElapsedTime = internalFunctionContext.ElapsedTime,
-                RetryCount = internalFunctionContext.RetryCount,
-                UpdatedAt = internalFunctionContext.ExecutedAt,
-                ParentId = internalFunctionContext.ParentId,
-                SkippedReason = internalFunctionContext.Status == TickerStatus.Skipped ? internalFunctionContext.ExceptionDetails : null
-            };
-            
-            await _hubContext.Clients.All.SendAsync("UpdateTimeTickerNotification", timeTicker);
+                _timeTickerUpdateTimer.Change(TimeTickerUpdateDebounce, Timeout.InfiniteTimeSpan);
+            }
+
+            return Task.CompletedTask;
         }
 
-        public async Task UpdateCronOccurrenceFromInternalFunctionContext<TCronTicker>(InternalFunctionContext internalFunctionContext) where TCronTicker : CronTickerEntity, new()
+        private void TimeTickerUpdateCallback(object _)
         {
-            var cronOccurrence = new CronTickerOccurrenceEntity<TCronTicker>
+            if (Interlocked.Exchange(ref _hasPendingTimeTickerUpdate, 0) == 0)
+                return;
+
+            _ = _hubContext.Clients.All.SendAsync("UpdateTimeTickerNotification");
+        }
+
+        public Task UpdateCronOccurrenceFromInternalFunctionContext<TCronTicker>(InternalFunctionContext internalFunctionContext)
+            where TCronTicker : CronTickerEntity, new()
+        {
+            var updatePayload = new
             {
-                Id = internalFunctionContext.TickerId,
-                Status = internalFunctionContext.Status,
-                CronTickerId = internalFunctionContext.ParentId!.Value,
-                ExecutedAt = internalFunctionContext.ExecutedAt,
-                ExceptionMessage = internalFunctionContext.ExceptionDetails,
-                ElapsedTime = internalFunctionContext.ElapsedTime,
-                RetryCount = internalFunctionContext.RetryCount,
-                UpdatedAt = internalFunctionContext.ExecutedAt
+                id = internalFunctionContext.TickerId,
+                status = internalFunctionContext.Status,
+                cronTickerId = internalFunctionContext.ParentId,
+                executedAt = internalFunctionContext.ExecutedAt,
+                elapsedTime = internalFunctionContext.ElapsedTime,
+                retryCount = internalFunctionContext.RetryCount,
+                exceptionMessage = internalFunctionContext.ExceptionDetails
             };
-            
-            await _hubContext.Clients.Group(internalFunctionContext.ParentId.ToString()).SendAsync("UpdateCronOccurrenceNotification", cronOccurrence);
+
+            _ = _hubContext.Clients
+                .Group(internalFunctionContext.ParentId?.ToString() ?? string.Empty)
+                .SendAsync("UpdateCronOccurrenceNotification", updatePayload);
+
+            return Task.CompletedTask;
         }
 
         public async Task CanceledTickerNotifyAsync(Guid id)
@@ -123,4 +138,4 @@ public async Task CanceledTickerNotifyAsync(Guid id)
             await _hubContext.Clients.All.SendAsync("CanceledTickerNotification", id);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Dashboard/Infrastructure/Dashboard/TickerDashboardRepository.cs b/src/TickerQ.Dashboard/Infrastructure/Dashboard/TickerDashboardRepository.cs
index 2e5b2519..1e46c266 100644
--- a/src/TickerQ.Dashboard/Infrastructure/Dashboard/TickerDashboardRepository.cs
+++ b/src/TickerQ.Dashboard/Infrastructure/Dashboard/TickerDashboardRepository.cs
@@ -19,6 +19,7 @@ internal class TickerDashboardRepository<TTimeTicker, TCronTicker> : ITickerDash
     {
         private readonly ITickerPersistenceProvider<TTimeTicker, TCronTicker> _persistenceProvider;
         private readonly ITickerQHostScheduler _tickerQHostScheduler;
+        private readonly ITickerQDispatcher _dispatcher;
         private readonly ITickerQNotificationHubSender _notificationHubSender;
         private readonly TickerExecutionContext _executionContext;
         private readonly DashboardOptionsBuilder _dashboardOptions;
@@ -27,13 +28,15 @@ public TickerDashboardRepository(
             ITickerPersistenceProvider<TTimeTicker, TCronTicker> persistenceProvider,
             ITickerQHostScheduler tickerQHostScheduler, 
             ITickerQNotificationHubSender notificationHubSender, 
-            DashboardOptionsBuilder dashboardOptions)
+            DashboardOptionsBuilder dashboardOptions,
+            ITickerQDispatcher dispatcher)
         {
             _persistenceProvider = persistenceProvider ?? throw new ArgumentNullException(nameof(persistenceProvider));
             _tickerQHostScheduler = tickerQHostScheduler ?? throw new ArgumentNullException(nameof(tickerQHostScheduler));
             _notificationHubSender = notificationHubSender ?? throw new ArgumentNullException(nameof(notificationHubSender));
             _executionContext = executionContext ??  throw new ArgumentNullException(nameof(executionContext));
             _dashboardOptions = dashboardOptions ?? throw new ArgumentNullException(nameof(dashboardOptions));
+            _dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         }
 
         public async Task<TTimeTicker[]> GetTimeTickersAsync(CancellationToken cancellationToken)
@@ -397,17 +400,48 @@ public async Task AddOnDemandCronTickerOccurrenceAsync(Guid id, CancellationToke
             {
                 Id = Guid.NewGuid(),
                 Status = TickerStatus.Idle,
-                ExecutionTime = now.AddSeconds(1),
-                LockedAt = now,
+                ExecutionTime = now,
+                LockedAt = null,
                 CronTickerId = id
             };
 
             await _persistenceProvider.InsertCronTickerOccurrences([onDemandOccurrence], cancellationToken);
 
-            _tickerQHostScheduler.RestartIfNeeded(onDemandOccurrence.ExecutionTime);
+            // Acquire and run immediately
+            var acquired = await _persistenceProvider
+                .AcquireImmediateCronOccurrencesAsync([onDemandOccurrence.Id], cancellationToken)
+                .ConfigureAwait(false);
 
+            CronTickerOccurrenceEntity<TCronTicker>? acquiredOccurrence = null;
+
+            if (acquired.Length > 0)
+            {
+                var occurrence = acquired[0];
+                acquiredOccurrence = occurrence;
+                var context = new InternalFunctionContext
+                {
+                    ParentId = occurrence.CronTickerId,
+                    FunctionName = occurrence.CronTicker.Function,
+                    TickerId = occurrence.Id,
+                    Type = TickerType.CronTickerOccurrence,
+                    Retries = occurrence.CronTicker.Retries,
+                    RetryIntervals = occurrence.CronTicker.RetryIntervals,
+                    ExecutionTime = occurrence.ExecutionTime
+                };
+
+                // Populate cached delegate and priority so the dispatcher can execute the job
+                if (TickerFunctionProvider.TickerFunctions.TryGetValue(context.FunctionName, out var tickerItem))
+                {
+                    context.CachedDelegate = tickerItem.Delegate;
+                    context.CachedPriority = tickerItem.Priority;
+                }
+
+                await _dispatcher.DispatchAsync([context], cancellationToken).ConfigureAwait(false);
+            }
+
+            // Notify dashboard about the new occurrence (prefer the acquired version if available)
             if (_notificationHubSender != null)
-                await _notificationHubSender.AddCronOccurrenceAsync(id, onDemandOccurrence);
+                await _notificationHubSender.AddCronOccurrenceAsync(id, acquiredOccurrence ?? onDemandOccurrence);
         }
 
         public async Task<CronTickerOccurrenceEntity<TCronTicker>[]> GetCronTickersOccurrencesAsync(Guid cronTickerId, CancellationToken cancellationToken)
@@ -607,4 +641,4 @@ public async Task DeleteCronTickerOccurrenceByIdAsync(Guid id, CancellationToken
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Dashboard/wwwroot/src/http/services/timeTickerService.ts b/src/TickerQ.Dashboard/wwwroot/src/http/services/timeTickerService.ts
index 9b8ba7f1..644a90d3 100644
--- a/src/TickerQ.Dashboard/wwwroot/src/http/services/timeTickerService.ts
+++ b/src/TickerQ.Dashboard/wwwroot/src/http/services/timeTickerService.ts
@@ -197,6 +197,18 @@ const deleteTimeTicker = () => {
     };
 }
 
+const deleteTimeTickersBatch = () => {
+    const baseHttp = useBaseHttpService<object, object>('single');
+
+    const requestAsync = async (ids: string[]) =>
+        await baseHttp.sendAsync("DELETE", "time-ticker/delete-batch", { bodyData: ids });
+
+    return {
+        ...baseHttp,
+        requestAsync
+    };
+}
+
 const addTimeTicker = () => {
     const baseHttp = useBaseHttpService<AddTimeTickerRequest, object>('single');
 
@@ -248,6 +260,7 @@ export const timeTickerService = {
     getTimeTickers,
     getTimeTickersPaginated,
     deleteTimeTicker,
+    deleteTimeTickersBatch,
     getTimeTickersGraphDataRange,
     getTimeTickersGraphData,
     addTimeTicker,
diff --git a/src/TickerQ.Dashboard/wwwroot/src/hub/tickerNotificationHub.ts b/src/TickerQ.Dashboard/wwwroot/src/hub/tickerNotificationHub.ts
index 9b3b9a78..e93c63d6 100644
--- a/src/TickerQ.Dashboard/wwwroot/src/hub/tickerNotificationHub.ts
+++ b/src/TickerQ.Dashboard/wwwroot/src/hub/tickerNotificationHub.ts
@@ -7,6 +7,7 @@ export const methodName = {
   onReceiveUpdateCronTickerOccurrence: "UpdateCronOccurrenceNotification",
   onReceiveAddCronTickerOccurrence: "AddCronOccurrenceNotification",
   onReceiveAddTimeTicker: "AddTimeTickerNotification",
+  onReceiveAddTimeTickersBatch: "AddTimeTickersBatchNotification",
   onReceiveUpdateTimeTicker: "UpdateTimeTickerNotification",
   onReceiveCancelledTicker: "CanceledTickerNotification",
   onReceiveDeleteTimeTicker: "RemoveTimeTickerNotification",
@@ -60,6 +61,13 @@ class TickerNotificationHub extends BaseHub {
     });
   }
 
+  // Batch add time tickers (used as a lightweight signal to refresh data)
+  onReceiveAddTimeTickersBatch(callback: () => void): void {
+    this.connection.on(methodName.onReceiveAddTimeTickersBatch, () => {
+      callback();
+    });
+  }
+
   onReceiveAddTimeTicker<T>(callback: (response: T) => void): void {
     this.onReceiveMessageAsSingle<T>(methodName.onReceiveAddTimeTicker, (responseFromHub: any) => {
       callback(responseFromHub);
@@ -115,4 +123,4 @@ class TickerNotificationHub extends BaseHub {
 }
 export type TickerNotificationHubType = InstanceType<typeof TickerNotificationHub>;
 // Export as a singleton instance
-export default new TickerNotificationHub();
\ No newline at end of file
+export default new TickerNotificationHub();
diff --git a/src/TickerQ.Dashboard/wwwroot/src/views/Dashboard.vue b/src/TickerQ.Dashboard/wwwroot/src/views/Dashboard.vue
index bbdf7c03..f1b25a8b 100644
--- a/src/TickerQ.Dashboard/wwwroot/src/views/Dashboard.vue
+++ b/src/TickerQ.Dashboard/wwwroot/src/views/Dashboard.vue
@@ -48,12 +48,14 @@ onMounted(async () => {
   await getJobStatusesPastWeek.requestAsync()
 
   await getMachineJobs.requestAsync().then((res) => {
+    machineItems.value = []
     res.forEach((item) => {
       machineItems.value.push({
         machine: item.item1,
         locked: `${item.item2} Jobs`,
       })
     })
+    currentMachinesPage.value = 1
   })
   await functionNamesStore.loadData().then((res) => {
     functionItems.value = [] // Clear existing items
@@ -162,6 +164,25 @@ const seriesColors: { [key: string]: string } = {
 
 const machineItems: Ref<Array<{ machine: string; locked: string }>> = ref([])
 
+// Machines pagination
+const machinesPerPage = ref(10)
+const currentMachinesPage = ref(1)
+
+const totalMachinePages = computed(() =>
+  Math.max(1, Math.ceil(machineItems.value.length / machinesPerPage.value)),
+)
+
+const pagedMachineItems = computed(() => {
+  const start = (currentMachinesPage.value - 1) * machinesPerPage.value
+  const end = start + machinesPerPage.value
+  return machineItems.value.slice(start, end)
+})
+
+const currentMachineName = computed(() => getOptions.response.value?.currentMachine ?? '')
+
+const isCurrentMachine = (name: string) =>
+  !!name && !!currentMachineName.value && name === currentMachineName.value
+
 const tickerTaskPriority: { [key: number]: string } = {
   0: 'LongRunning',
   1: 'High',
@@ -491,12 +512,45 @@ const getVisiblePageNumbers = () => {
 
           <div class="machines-list">
             <template v-if="machineItems.length > 0">
-              <div v-for="machine in machineItems" :key="machine.machine" class="machine-item">
+              <div
+                v-for="machine in pagedMachineItems"
+                :key="machine.machine"
+                class="machine-item"
+                :class="{ 'machine-item-current': isCurrentMachine(machine.machine) }"
+              >
                 <div class="machine-info">
-                  <span class="machine-name">{{ machine.machine }}</span>
+                  <span class="machine-name">
+                    {{ machine.machine }}
+                    <span
+                      v-if="isCurrentMachine(machine.machine)"
+                      class="machine-current-pill"
+                    >
+                      Current
+                    </span>
+                  </span>
                   <span class="machine-jobs">{{ machine.locked }}</span>
                 </div>
               </div>
+
+              <div class="machines-pagination" v-if="totalMachinePages > 1">
+                <v-btn
+                  size="x-small"
+                  variant="text"
+                  icon="mdi-chevron-left"
+                  :disabled="currentMachinesPage <= 1"
+                  @click="currentMachinesPage = Math.max(1, currentMachinesPage - 1)"
+                />
+                <span class="machines-page-label">
+                  Page {{ currentMachinesPage }} / {{ totalMachinePages }}
+                </span>
+                <v-btn
+                  size="x-small"
+                  variant="text"
+                  icon="mdi-chevron-right"
+                  :disabled="currentMachinesPage >= totalMachinePages"
+                  @click="currentMachinesPage = Math.min(totalMachinePages, currentMachinesPage + 1)"
+                />
+              </div>
             </template>
             <template v-else>
               <div v-for="i in 3" :key="i" class="machine-item">
diff --git a/src/TickerQ.Dashboard/wwwroot/src/views/TimeTicker.vue b/src/TickerQ.Dashboard/wwwroot/src/views/TimeTicker.vue
index 81c49304..2c5f753a 100644
--- a/src/TickerQ.Dashboard/wwwroot/src/views/TimeTicker.vue
+++ b/src/TickerQ.Dashboard/wwwroot/src/views/TimeTicker.vue
@@ -41,6 +41,7 @@ use([
 // Use paginated service instead of regular one
 const getTimeTickersPaginated = timeTickerService.getTimeTickersPaginated()
 const deleteTimeTicker = timeTickerService.deleteTimeTicker()
+const deleteTimeTickersBatch = timeTickerService.deleteTimeTickersBatch()
 const requestCancelTicker = tickerService.requestCancel()
 const getTimeTickersGraphDataRange = timeTickerService.getTimeTickersGraphDataRange()
 const getTimeTickersGraphData = timeTickerService.getTimeTickersGraphData()
@@ -149,6 +150,7 @@ onUnmounted(() => {
   TickerNotificationHub.stopReceiver(methodName.onReceiveAddTimeTicker)
   TickerNotificationHub.stopReceiver(methodName.onReceiveUpdateTimeTicker)
   TickerNotificationHub.stopReceiver(methodName.onReceiveDeleteTimeTicker)
+  TickerNotificationHub.stopReceiver(methodName.onReceiveAddTimeTickersBatch)
 })
 
 // Load page data with pagination
@@ -327,38 +329,26 @@ const processPieChartData = (data: any[]) => {
 }
 
 const addHubListeners = async () => {
-  TickerNotificationHub.onReceiveAddTimeTicker<GetTimeTickerResponse>((response) => {
-    console.log('Add Time Ticker', response)
-    // Reload current page when new item is added
-    loadPageData()
-    // Update charts
-    loadPieChartData()
-  })
+  // Debounce utility for view refreshes
+  function debounce<T extends (...args: any[]) => void>(fn: T, delay: number): T {
+    let timeout: ReturnType<typeof setTimeout>
+    return ((...args: any[]) => {
+      clearTimeout(timeout)
+      timeout = setTimeout(() => fn(...args), delay)
+    }) as T
+  }
 
-  TickerNotificationHub.onReceiveUpdateTimeTicker<GetTimeTickerResponse>((response) => {
-    // For paginated data, we need to refresh the current page
-    // instead of updating in-memory array
+  const debouncedRefresh = debounce(() => {
     loadPageData()
-    // Update charts
     loadPieChartData()
+  }, 200)
 
+  TickerNotificationHub.onReceiveAddTimeTicker<GetTimeTickerResponse>(() => {
+    debouncedRefresh()
+  })
 
-    if (crudTimeTickerDialog.isOpen && crudTimeTickerDialog.propData?.id == response.id) {
-      // Merge the update with existing data, preserving fields that aren't updated
-      const currentData = crudTimeTickerDialog.propData
-      crudTimeTickerDialog.setPropData({
-        ...currentData,  // Keep existing data (including lockHolder, function, etc.)
-        ...response,      // Apply updates (status, executedAt, etc.)
-        executionTime: response.executionTime ?? currentData.executionTime,
-        isFromDuplicate: false,
-        // Preserve fields that WebSocket updates don't include
-        lockHolder: response.lockHolder || currentData.lockHolder,
-        function: response.function || currentData.function,
-      })
-      nextTick(() => {
-        ;(crudTimeTickerDialogRef.value as any)?.resetForm()
-      })
-    }
+  TickerNotificationHub.onReceiveUpdateTimeTicker<void>(() => {
+    debouncedRefresh()
   })
 
   TickerNotificationHub.onReceiveDeleteTimeTicker<string>((id) => {
@@ -367,6 +357,13 @@ const addHubListeners = async () => {
     // Update charts
     loadPieChartData()
   })
+
+  // Batch insert notification: just refresh current view and charts once
+  TickerNotificationHub.onReceiveAddTimeTickersBatch(() => {
+    loadPageData()
+    loadTimeSeriesChartData(-3, 3)
+    loadPieChartData()
+  })
 }
 
 // Chart configurations
@@ -623,6 +620,28 @@ const clearSelection = () => {
   selectedItems.value.clear()
 }
 
+const selectAllVisible = () => {
+  const ids = processedTableData.value
+    .filter((item) => !item.isChild)
+    .map((item) => item.id as string)
+
+  selectedItems.value = new Set(ids)
+}
+
+const deleteSelected = async () => {
+  if (selectedItems.value.size === 0) return
+
+  const ids = Array.from(selectedItems.value)
+  try {
+    await deleteTimeTickersBatch.requestAsync(ids)
+    clearSelection()
+    await loadPageData()
+    await loadPieChartData()
+  } catch (error) {
+    console.error('Failed to delete selected time tickers:', error)
+  }
+}
+
 // Chain Jobs Modal Methods
 const openChainJobsModal = () => {
   chainJobsModal.value.isOpen = true
@@ -1016,6 +1035,18 @@ const canBeForceDeleted = ref<string[]>([])
 
             <!-- Utility Actions Group -->
             <div class="utility-actions">
+              <v-btn
+                v-if="processedTableData.length > 0"
+                size="small"
+                color="grey"
+                variant="text"
+                prepend-icon="mdi-select-all"
+                class="utility-btn"
+                @click="selectAllVisible"
+              >
+                Select All
+              </v-btn>
+
               <v-btn
                 icon
                 size="small"
@@ -1027,6 +1058,18 @@ const canBeForceDeleted = ref<string[]>([])
                 <v-icon>mdi-refresh</v-icon>
               </v-btn>
 
+              <v-btn
+                v-if="selectedItems.size > 0"
+                size="small"
+                color="error"
+                variant="text"
+                prepend-icon="mdi-trash-can"
+                class="utility-btn"
+                @click="deleteSelected"
+              >
+                Delete Selected ({{ selectedItems.size }})
+              </v-btn>
+
               <v-btn
                 v-if="selectedItems.size > 0"
                 size="small"
diff --git a/src/TickerQ.EntityFrameworkCore/Configurations/CronTickerConfigurations.cs b/src/TickerQ.EntityFrameworkCore/Configurations/CronTickerConfigurations.cs
index 74ddf731..94bd9d32 100644
--- a/src/TickerQ.EntityFrameworkCore/Configurations/CronTickerConfigurations.cs
+++ b/src/TickerQ.EntityFrameworkCore/Configurations/CronTickerConfigurations.cs
@@ -21,12 +21,12 @@ public void Configure(EntityTypeBuilder<TCronTicker> builder)
 
             builder.HasIndex("Expression")
                 .HasDatabaseName("IX_CronTickers_Expression");
-            
-            builder.HasIndex("Function","Expression", "Request")
-                .HasDatabaseName("IX_Function_Expression_Request")
-                .IsUnique();
+
+            // Index for common lookups by function + expression
+            builder.HasIndex("Function", "Expression")
+                .HasDatabaseName("IX_Function_Expression");
 
             builder.ToTable("CronTickers", _schema);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.EntityFrameworkCore/Configurations/TimeTickerConfigurations.cs b/src/TickerQ.EntityFrameworkCore/Configurations/TimeTickerConfigurations.cs
index 38012640..f5b2ee07 100644
--- a/src/TickerQ.EntityFrameworkCore/Configurations/TimeTickerConfigurations.cs
+++ b/src/TickerQ.EntityFrameworkCore/Configurations/TimeTickerConfigurations.cs
@@ -29,11 +29,11 @@ public void Configure(EntityTypeBuilder<TTimeTicker> builder)
             builder.HasIndex("ExecutionTime")
                 .HasDatabaseName("IX_TimeTicker_ExecutionTime");
 
-            builder.HasIndex("Status", "ExecutionTime", "Request")
-                .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime")
-                .IsUnique();
+            // Index for scheduler queries: many tickers can share the same status/time
+            builder.HasIndex("Status", "ExecutionTime")
+                .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
 
             builder.ToTable("TimeTickers", _schema);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.EntityFrameworkCore/Infrastructure/BasePersistenceProvider.cs b/src/TickerQ.EntityFrameworkCore/Infrastructure/BasePersistenceProvider.cs
index ce9e8780..7348b322 100644
--- a/src/TickerQ.EntityFrameworkCore/Infrastructure/BasePersistenceProvider.cs
+++ b/src/TickerQ.EntityFrameworkCore/Infrastructure/BasePersistenceProvider.cs
@@ -27,8 +27,8 @@ public BasePersistenceProvider(IDbContextFactory<TDbContext> dbContextFactory, I
     }
     
     protected readonly IDbContextFactory<TDbContext>  DbContextFactory;
-    private readonly string _lockHolder;
-    private readonly ITickerClock _clock;
+    protected readonly string _lockHolder;
+    protected readonly ITickerClock _clock;
     protected readonly ITickerQRedisContext RedisContext;
     
     #region Core_Time_Ticker_Methods
@@ -202,10 +202,42 @@ await dbContext.Set<TTimeTicker>()
                 .SetProperty(x => x.Status, TickerStatus.Skipped)
                 .SetProperty(x => x.SkippedReason, "Node is not alive!")
                 .SetProperty(x => x.ExecutedAt, now)
-                .SetProperty(x => x.UpdatedAt, now), cancellationToken)
+            .SetProperty(x => x.UpdatedAt, now), cancellationToken)
             .ConfigureAwait(false);
     }
     #endregion
+
+    public async Task<TimeTickerEntity[]> AcquireImmediateTimeTickersAsync(Guid[] ids, CancellationToken cancellationToken = default)
+    {
+        if (ids == null || ids.Length == 0)
+            return [];
+
+        await using var dbContext = await DbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        var now = _clock.UtcNow;
+
+        // Acquire and mark InProgress in a single update
+        var affected = await dbContext.Set<TTimeTicker>()
+            .Where(x => ids.Contains(x.Id))
+            .WhereCanAcquire(_lockHolder)
+            .ExecuteUpdateAsync(setter => setter
+                .SetProperty(x => x.LockHolder, _lockHolder)
+                .SetProperty(x => x.LockedAt, now)
+                .SetProperty(x => x.Status, TickerStatus.InProgress)
+                .SetProperty(x => x.UpdatedAt, now), cancellationToken)
+            .ConfigureAwait(false);
+
+        if (affected == 0)
+            return [];
+
+        // Return the acquired tickers for immediate execution, with children
+        return await dbContext.Set<TTimeTicker>()
+            .AsNoTracking()
+            .Where(x => ids.Contains(x.Id) && x.LockHolder == _lockHolder && x.Status == TickerStatus.InProgress)
+            .Include(x => x.Children.Where(y => y.ExecutionTime == null))
+            .Select(MappingExtensions.ForQueueTimeTickers<TTimeTicker>())
+            .ToArrayAsync(cancellationToken)
+            .ConfigureAwait(false);
+    }
         
     #region Core_Cron_Ticker_Methods
     public async Task MigrateDefinedCronTickers((string Function, string Expression)[] cronTickers, CancellationToken cancellationToken = default)
diff --git a/src/TickerQ.EntityFrameworkCore/Infrastructure/TickerEFCorePersistenceProvider.cs b/src/TickerQ.EntityFrameworkCore/Infrastructure/TickerEFCorePersistenceProvider.cs
index 04835ef6..c4b0cc11 100644
--- a/src/TickerQ.EntityFrameworkCore/Infrastructure/TickerEFCorePersistenceProvider.cs
+++ b/src/TickerQ.EntityFrameworkCore/Infrastructure/TickerEFCorePersistenceProvider.cs
@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using TickerQ.Utilities;
 using TickerQ.Utilities.Entities;
+using TickerQ.Utilities.Enums;
 using TickerQ.Utilities.Interfaces;
 using TickerQ.Utilities.Models;
 
@@ -250,6 +251,40 @@ public async Task<int> RemoveCronTickerOccurrences(Guid[] cronTickerOccurrences,
                 .ExecuteDeleteAsync(cancellationToken).ConfigureAwait(false);
         }
 
+        public async Task<CronTickerOccurrenceEntity<TCronTicker>[]> AcquireImmediateCronOccurrencesAsync(Guid[] occurrenceIds, CancellationToken cancellationToken = default)
+        {
+            if (occurrenceIds == null || occurrenceIds.Length == 0)
+                return Array.Empty<CronTickerOccurrenceEntity<TCronTicker>>();
+
+            await using var dbContext = await DbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+            var now = _clock.UtcNow;
+
+            // Only acquire occurrences that are acquirable (Idle/Queued and not locked by another node)
+            var query = dbContext.Set<CronTickerOccurrenceEntity<TCronTicker>>()
+                .Where(x => occurrenceIds.Contains(x.Id))
+                .WhereCanAcquire(_lockHolder);
+
+            // Lock and mark InProgress
+            var affected = await query
+                .ExecuteUpdateAsync(setter => setter
+                    .SetProperty(x => x.LockHolder, _lockHolder)
+                    .SetProperty(x => x.LockedAt, now)
+                    .SetProperty(x => x.Status, TickerStatus.InProgress)
+                    .SetProperty(x => x.UpdatedAt, now), cancellationToken)
+                .ConfigureAwait(false);
+
+            if (affected == 0)
+                return Array.Empty<CronTickerOccurrenceEntity<TCronTicker>>();
+
+            // Return acquired occurrences with CronTicker populated
+            return await dbContext.Set<CronTickerOccurrenceEntity<TCronTicker>>()
+                .AsNoTracking()
+                .Where(x => occurrenceIds.Contains(x.Id) && x.LockHolder == _lockHolder && x.Status == TickerStatus.InProgress)
+                .Include(x => x.CronTicker)
+                .ToArrayAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
+
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Base/TickerFunctionContext.cs b/src/TickerQ.Utilities/Base/TickerFunctionContext.cs
index 54b0853b..563844df 100644
--- a/src/TickerQ.Utilities/Base/TickerFunctionContext.cs
+++ b/src/TickerQ.Utilities/Base/TickerFunctionContext.cs
@@ -13,6 +13,7 @@ public TickerFunctionContext(TickerFunctionContext tickerFunctionContext, TReque
         Type = tickerFunctionContext.Type;
         RetryCount = tickerFunctionContext.RetryCount;
         IsDue = tickerFunctionContext.IsDue;
+        ScheduledFor = tickerFunctionContext.ScheduledFor;
         RequestCancelOperationAction = tickerFunctionContext.RequestCancelOperationAction;
         CronOccurrenceOperations = tickerFunctionContext.CronOccurrenceOperations;
         FunctionName = tickerFunctionContext.FunctionName;
@@ -29,6 +30,11 @@ public class TickerFunctionContext
     public TickerType Type { get; internal set; }
     public int RetryCount { get; internal set; }
     public bool IsDue { get; internal set; }
+    /// <summary>
+    /// The time this ticker was scheduled to run (UTC).
+    /// For time tickers, this is the ExecutionTime; for cron, the occurrence ExecutionTime.
+    /// </summary>
+    public DateTime ScheduledFor { get; internal set; }
     public string FunctionName { get; internal set; }
     public CronOccurrenceOperations CronOccurrenceOperations { get; internal set; }
     public void RequestCancellation() 
@@ -42,4 +48,4 @@ public class CronOccurrenceOperations
     internal Action SkipIfAlreadyRunningAction { get; set; }
     public void SkipIfAlreadyRunning()
         => SkipIfAlreadyRunningAction();
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Interfaces/ITickerPersistenceProvider.cs b/src/TickerQ.Utilities/Interfaces/ITickerPersistenceProvider.cs
index d3da77af..2ea75e16 100644
--- a/src/TickerQ.Utilities/Interfaces/ITickerPersistenceProvider.cs
+++ b/src/TickerQ.Utilities/Interfaces/ITickerPersistenceProvider.cs
@@ -20,6 +20,7 @@ public interface ITickerPersistenceProvider<TTimeTicker, TCronTicker>
         Task<int> UpdateTimeTicker(InternalFunctionContext functionContext, CancellationToken cancellationToken = default);
         Task<byte[]> GetTimeTickerRequest(Guid id, CancellationToken cancellationToken);
         Task UpdateTimeTickersWithUnifiedContext(Guid[] timeTickerIds, InternalFunctionContext functionContext, CancellationToken cancellationToken = default);
+        Task<TimeTickerEntity[]> AcquireImmediateTimeTickersAsync(Guid[] ids, CancellationToken cancellationToken = default);
         #endregion
         
         #region Cron_Ticker_Core_Methods
@@ -62,6 +63,7 @@ public interface ITickerPersistenceProvider<TTimeTicker, TCronTicker>
         Task<PaginationResult<CronTickerOccurrenceEntity<TCronTicker>>> GetAllCronTickerOccurrencesPaginated(Expression<Func<CronTickerOccurrenceEntity<TCronTicker>, bool>> predicate, int pageNumber, int pageSize, CancellationToken cancellationToken = default);
         Task<int> InsertCronTickerOccurrences(CronTickerOccurrenceEntity<TCronTicker>[] cronTickerOccurrences, CancellationToken cancellationToken);
         Task<int> RemoveCronTickerOccurrences(Guid[] cronTickerOccurrences, CancellationToken cancellationToken);
+        Task<CronTickerOccurrenceEntity<TCronTicker>[]> AcquireImmediateCronOccurrencesAsync(Guid[] occurrenceIds, CancellationToken cancellationToken = default);
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Interfaces/ITickerQDispatcher.cs b/src/TickerQ.Utilities/Interfaces/ITickerQDispatcher.cs
new file mode 100644
index 00000000..c31df0e3
--- /dev/null
+++ b/src/TickerQ.Utilities/Interfaces/ITickerQDispatcher.cs
@@ -0,0 +1,12 @@
+using System.Threading;
+using System.Threading.Tasks;
+using TickerQ.Utilities.Models;
+
+namespace TickerQ.Utilities.Interfaces
+{
+    public interface ITickerQDispatcher
+    {
+        Task DispatchAsync(InternalFunctionContext[] contexts, CancellationToken cancellationToken = default);
+    }
+}
+
diff --git a/src/TickerQ.Utilities/Interfaces/ITickerQNotificationHubSender.cs b/src/TickerQ.Utilities/Interfaces/ITickerQNotificationHubSender.cs
index 1c3fca01..3987c640 100644
--- a/src/TickerQ.Utilities/Interfaces/ITickerQNotificationHubSender.cs
+++ b/src/TickerQ.Utilities/Interfaces/ITickerQNotificationHubSender.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using TickerQ.Utilities.Entities;
 using TickerQ.Utilities.Models;
@@ -10,7 +11,8 @@ internal interface ITickerQNotificationHubSender
         Task AddCronTickerNotifyAsync(object cronTicker);
         Task UpdateCronTickerNotifyAsync(object cronTicker);
         Task RemoveCronTickerNotifyAsync(Guid id);
-        Task AddTimeTickerNotifyAsync(object timeTicker);
+        Task AddTimeTickerNotifyAsync(Guid id);
+        Task AddTimeTickersBatchNotifyAsync();
         Task UpdateTimeTickerNotifyAsync(object timeTicker);
         Task RemoveTimeTickerNotifyAsync(Guid id);
         void UpdateActiveThreads(object activeThreads);
@@ -24,4 +26,4 @@ internal interface ITickerQNotificationHubSender
         Task UpdateCronOccurrenceFromInternalFunctionContext<TCronTickerEntity>(InternalFunctionContext internalFunctionContext) where TCronTickerEntity : CronTickerEntity, new();
         Task CanceledTickerNotifyAsync(Guid id);
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Interfaces/Managers/IInternalTickerManager.cs b/src/TickerQ.Utilities/Interfaces/Managers/IInternalTickerManager.cs
index 753de78d..83ab6c42 100644
--- a/src/TickerQ.Utilities/Interfaces/Managers/IInternalTickerManager.cs
+++ b/src/TickerQ.Utilities/Interfaces/Managers/IInternalTickerManager.cs
@@ -19,4 +19,4 @@ internal interface IInternalTickerManager
         Task ReleaseDeadNodeResources(string instanceIdentifier, CancellationToken cancellationToken = default);
         Task UpdateSkipTimeTickersWithUnifiedContextAsync(InternalFunctionContext[] context, CancellationToken cancellationToken = default);
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Managers/InternalTickerManager.cs b/src/TickerQ.Utilities/Managers/InternalTickerManager.cs
index a5c6f840..73d64678 100644
--- a/src/TickerQ.Utilities/Managers/InternalTickerManager.cs
+++ b/src/TickerQ.Utilities/Managers/InternalTickerManager.cs
@@ -137,6 +137,7 @@ private async Task<InternalFunctionContext[]> QueueNextTimeTickersAsync(TimeTick
                     Retries = updatedTimeTicker.Retries,
                     RetryIntervals = updatedTimeTicker.RetryIntervals,
                     ParentId = updatedTimeTicker.ParentId,
+                    ExecutionTime = updatedTimeTicker.ExecutionTime ?? _clock.UtcNow,
                     TimeTickerChildren = updatedTimeTicker.Children.Select(ch => new InternalFunctionContext
                     {
                         FunctionName = ch.Function,
@@ -178,7 +179,8 @@ private async Task<InternalFunctionContext[]> QueueNextCronTickersAsync((DateTim
                     TickerId = occurrence.Id,
                     Type = TickerType.CronTickerOccurrence,
                     Retries = occurrence.CronTicker.Retries,
-                    RetryIntervals = occurrence.CronTicker.RetryIntervals
+                    RetryIntervals = occurrence.CronTicker.RetryIntervals,
+                    ExecutionTime = occurrence.ExecutionTime
                 });
                 
                 if (occurrence.CreatedAt == occurrence.UpdatedAt && _notificationHubSender != null)
@@ -406,6 +408,7 @@ public async Task<InternalFunctionContext[]> RunTimedOutTickers(CancellationToke
                     Retries = timedOutTimeTicker.Retries,
                     RetryIntervals = timedOutTimeTicker.RetryIntervals,
                     ParentId = timedOutTimeTicker.ParentId,
+                    ExecutionTime = timedOutTimeTicker.ExecutionTime ?? _clock.UtcNow,
                     TimeTickerChildren = timedOutTimeTicker.Children.Select(ch => new InternalFunctionContext
                     {
                         FunctionName = ch.Function,
@@ -440,7 +443,8 @@ public async Task<InternalFunctionContext[]> RunTimedOutTickers(CancellationToke
                     Type = TickerType.CronTickerOccurrence,
                     Retries = timedOutCronTicker.CronTicker.Retries,
                     RetryIntervals = timedOutCronTicker.CronTicker.RetryIntervals,
-                    ParentId = timedOutCronTicker.CronTickerId
+                    ParentId = timedOutCronTicker.CronTickerId,
+                    ExecutionTime = timedOutCronTicker.ExecutionTime
                 };
                 
                 results.Add(functionContext);
diff --git a/src/TickerQ.Utilities/Managers/TickerManager.cs b/src/TickerQ.Utilities/Managers/TickerManager.cs
index eb096868..99ccdfd0 100644
--- a/src/TickerQ.Utilities/Managers/TickerManager.cs
+++ b/src/TickerQ.Utilities/Managers/TickerManager.cs
@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using TickerQ.Utilities.Entities;
@@ -23,13 +24,15 @@ internal class
         private readonly ITickerQHostScheduler _tickerQHostScheduler;
         private readonly ITickerClock _clock;
         private readonly ITickerQNotificationHubSender _notificationHubSender;
+        private readonly ITickerQDispatcher _dispatcher;
         private readonly TickerExecutionContext _executionContext;
         public TickerManager(
             ITickerPersistenceProvider<TTimeTicker, TCronTicker> persistenceProvider,
             ITickerQHostScheduler tickerQHostScheduler,
             ITickerClock clock,
             ITickerQNotificationHubSender notificationHubSender,
-            TickerExecutionContext executionContext
+            TickerExecutionContext executionContext,
+            ITickerQDispatcher dispatcher
             )
         {
             _persistenceProvider = persistenceProvider;
@@ -37,6 +40,7 @@ TickerExecutionContext executionContext
             _clock = clock;
             _notificationHubSender = notificationHubSender;
             _executionContext = executionContext ?? throw new ArgumentNullException(nameof(executionContext));
+            _dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
         }
 
         Task<TickerResult<TCronTicker>> ICronTickerManager<TCronTicker>.AddAsync(TCronTicker entity, CancellationToken cancellationToken)
@@ -85,7 +89,7 @@ private async Task<TickerResult<TTimeTicker>> AddTimeTickerAsync(TTimeTicker ent
                     new TickerValidatorException($"Cannot find TickerFunction with name {entity?.Function}"));
             
             entity.ExecutionTime = entity.ExecutionTime == null 
-                ? _clock.UtcNow.AddSeconds(1) 
+                ? _clock.UtcNow
                 : ConvertToUtcIfNeeded(entity.ExecutionTime.Value);
             
             entity.CreatedAt = _clock.UtcNow;
@@ -93,11 +97,33 @@ private async Task<TickerResult<TTimeTicker>> AddTimeTickerAsync(TTimeTicker ent
             
             try
             {
+                var now = _clock.UtcNow;
+                var executionTime = entity.ExecutionTime!.Value;
+
+                // Persist first
                 await _persistenceProvider.AddTimeTickers([entity], cancellationToken: cancellationToken);
 
-                _tickerQHostScheduler.RestartIfNeeded(entity.ExecutionTime.Value);
+                if (executionTime <= now.AddSeconds(1))
+                {
+                    // Acquire and mark InProgress in one provider call
+                    var acquired = await _persistenceProvider
+                        .AcquireImmediateTimeTickersAsync([entity.Id], cancellationToken)
+                        .ConfigureAwait(false);
+
+                    if (acquired.Length > 0)
+                    {
+                        var contexts = BuildImmediateContextsFromNonGeneric(acquired);
+                        CacheFunctionReferences(contexts.AsSpan());
+                        await _dispatcher.DispatchAsync(contexts, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    _tickerQHostScheduler.RestartIfNeeded(executionTime);
+                }
+
+                await _notificationHubSender.AddTimeTickerNotifyAsync(entity.Id).ConfigureAwait(false);
 
-                await _notificationHubSender.AddTimeTickerNotifyAsync(entity).ConfigureAwait(false);
 
                 return new TickerResult<TTimeTicker>(entity);
             }
@@ -244,56 +270,103 @@ private static DateTime ConvertToUtcIfNeeded(DateTime dateTime)
         }
 
         // Batch operations implementation
+        private static void CacheFunctionReferences(Span<InternalFunctionContext> functions)
+        {
+            for (var i = 0; i < functions.Length; i++)
+            {
+                ref var context = ref functions[i];
+                if (TickerFunctionProvider.TickerFunctions.TryGetValue(context.FunctionName, out var tickerItem))
+                {
+                    context.CachedDelegate = tickerItem.Delegate;
+                    context.CachedPriority = tickerItem.Priority;
+                }
+
+                if (context.TimeTickerChildren is { Count: > 0 })
+                {
+                    var childrenSpan = CollectionsMarshal.AsSpan(context.TimeTickerChildren);
+                    CacheFunctionReferences(childrenSpan);
+                }
+            }
+        }
+
+        private static InternalFunctionContext[] BuildImmediateContextsFromNonGeneric(IEnumerable<TimeTickerEntity> tickers)
+        {
+            return tickers.Select(BuildContextFromNonGeneric).ToArray();
+        }
+
+        private static InternalFunctionContext BuildContextFromNonGeneric(TimeTickerEntity ticker)
+        {
+            return new InternalFunctionContext
+            {
+                FunctionName = ticker.Function,
+                TickerId = ticker.Id,
+                Type = Enums.TickerType.TimeTicker,
+                Retries = ticker.Retries,
+                RetryIntervals = ticker.RetryIntervals,
+                ParentId = ticker.ParentId,
+                ExecutionTime = ticker.ExecutionTime ?? DateTime.UtcNow,
+                RunCondition = ticker.RunCondition ?? Enums.RunCondition.OnAnyCompletedStatus,
+                TimeTickerChildren = ticker.Children.Select(BuildContextFromNonGeneric).ToList()
+            };
+        }
+
         private async Task<TickerResult<List<TTimeTicker>>> AddTimeTickersBatchAsync(List<TTimeTicker> entities, CancellationToken cancellationToken = default)
         {
-            var validEntities = new List<TTimeTicker>();
-            var errors = new List<Exception>();
-            
+            if (entities == null || entities.Count == 0)
+                return new TickerResult<List<TTimeTicker>>(entities ?? new List<TTimeTicker>());
+
+            var tickerFunctionsHashSet = new HashSet<string>(TickerFunctionProvider.TickerFunctions.Keys);
+            var immediateTickers = new List<Guid>();
+            var now = _clock.UtcNow;
+            DateTime earliestForNonImmediate = default;
             foreach (var entity in entities)
             {
-                // Same validation logic as your single add
                 if (entity.Id == Guid.Empty)
                     entity.Id = Guid.NewGuid();
 
-                if (TickerFunctionProvider.TickerFunctions.All(x => x.Key != entity?.Function))
-                {
-                    errors.Add(new TickerValidatorException($"Cannot find TickerFunction with name {entity?.Function}"));
-                    continue;
-                }
-                
-                if (entity.ExecutionTime == null)
-                {
-                    errors.Add(new TickerValidatorException("Invalid ExecutionTime!"));
-                    continue;
-                }
-                
-                entity.ExecutionTime ??= _clock.UtcNow;
+                if (!tickerFunctionsHashSet.Contains(entity.Function))
+                    return new TickerResult<List<TTimeTicker>>(
+                        new TickerValidatorException($"Cannot find TickerFunction with name {entity?.Function}"));
+
+                entity.ExecutionTime ??= now;
                 entity.ExecutionTime = ConvertToUtcIfNeeded(entity.ExecutionTime.Value);
-                
-                validEntities.Add(entity);
+
+                // Align with single AddTimeTickerAsync: initialize timestamps
+                entity.CreatedAt = now;
+                entity.UpdatedAt = now;
+
+                if (entity.ExecutionTime.Value <= now.AddSeconds(1))
+                    immediateTickers.Add(entity.Id);
+                else if (earliestForNonImmediate == default || entity.ExecutionTime <= earliestForNonImmediate)
+                    earliestForNonImmediate = entity.ExecutionTime.Value;
             }
             
-            if (errors.Any())
-                return new TickerResult<List<TTimeTicker>>(errors.First());
-            
             try
             {
-                await _persistenceProvider.AddTimeTickers(validEntities.ToArray(), cancellationToken: cancellationToken);
+                await _persistenceProvider.AddTimeTickers(entities.ToArray(), cancellationToken: cancellationToken);
 
-                // Restart scheduler for earliest execution time
-                if (validEntities.Any())
+                await _notificationHubSender.AddTimeTickersBatchNotifyAsync().ConfigureAwait(false);
+
+                if (immediateTickers.Count > 0)
                 {
-                    var earliestExecution = validEntities.Min(e => e.ExecutionTime.Value);
-                    _tickerQHostScheduler.RestartIfNeeded(earliestExecution);
+                    var acquired = await _persistenceProvider
+                        .AcquireImmediateTimeTickersAsync(immediateTickers.ToArray(), cancellationToken)
+                        .ConfigureAwait(false);
 
-                    // Send notifications for all
-                    foreach (var entity in validEntities)
+                    if (acquired.Length > 0)
                     {
-                        await _notificationHubSender.AddTimeTickerNotifyAsync(entity).ConfigureAwait(false);
+                        var contexts = BuildImmediateContextsFromNonGeneric(acquired);
+                        CacheFunctionReferences(contexts.AsSpan());
+                        await _dispatcher.DispatchAsync(contexts, cancellationToken).ConfigureAwait(false);
                     }
                 }
 
-                return new TickerResult<List<TTimeTicker>>(validEntities);
+                if (earliestForNonImmediate != default)
+                {
+                    _tickerQHostScheduler.RestartIfNeeded(earliestForNonImmediate);
+                }
+
+                return new TickerResult<List<TTimeTicker>>(entities);
             }
             catch (Exception e)
             {
@@ -503,4 +576,4 @@ private async Task<TickerResult<TCronTicker>> DeleteCronTickersBatchAsync(List<G
             return new TickerResult<TCronTicker>(affectedRows);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/Temps/NoOpTickerQNotificationHubSender.cs b/src/TickerQ.Utilities/Temps/NoOpTickerQNotificationHubSender.cs
index 34ebf086..97528960 100644
--- a/src/TickerQ.Utilities/Temps/NoOpTickerQNotificationHubSender.cs
+++ b/src/TickerQ.Utilities/Temps/NoOpTickerQNotificationHubSender.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using TickerQ.Utilities.Entities;
 using TickerQ.Utilities.Interfaces;
@@ -23,7 +24,12 @@ public Task RemoveCronTickerNotifyAsync(Guid id)
             return Task.CompletedTask;
         }
 
-        public Task AddTimeTickerNotifyAsync(object timeTicker)
+        public Task AddTimeTickerNotifyAsync(Guid id)
+        {
+            return Task.CompletedTask;
+        }
+        
+        public Task AddTimeTickersBatchNotifyAsync()
         {
             return Task.CompletedTask;
         }
@@ -85,4 +91,4 @@ public Task CanceledTickerNotifyAsync(Guid id)
             return Task.CompletedTask;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ.Utilities/TickerExecutionContext.cs b/src/TickerQ.Utilities/TickerExecutionContext.cs
index 9b87d60b..18be64ae 100644
--- a/src/TickerQ.Utilities/TickerExecutionContext.cs
+++ b/src/TickerQ.Utilities/TickerExecutionContext.cs
@@ -2,7 +2,6 @@
 using System.Runtime.InteropServices;
 using System.Threading;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
 using TickerQ.Utilities.Enums;
 using TickerQ.Utilities.Models;
 
diff --git a/src/TickerQ/DependencyInjection/TickerQServiceExtensions.cs b/src/TickerQ/DependencyInjection/TickerQServiceExtensions.cs
index ed4afb80..cd57b22b 100644
--- a/src/TickerQ/DependencyInjection/TickerQServiceExtensions.cs
+++ b/src/TickerQ/DependencyInjection/TickerQServiceExtensions.cs
@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using TickerQ.BackgroundServices;
+using TickerQ.Dispatcher;
 using TickerQ.Provider;
 using TickerQ.TickerQThreadPool;
 using TickerQ.Utilities;
@@ -57,6 +58,7 @@ public static IServiceCollection AddTickerQ<TTimeTicker, TCronTicker>(this IServ
             services.AddSingleton<ITickerQInstrumentation, LoggerInstrumentation>();
             services.AddSingleton<TickerQFallbackBackgroundService>();
             services.AddSingleton<TickerExecutionTaskHandler>();
+            services.AddSingleton<ITickerQDispatcher, TickerQDispatcher>();
             services.AddSingleton(sp =>
             {
                 var notification = sp.GetRequiredService<ITickerQNotificationHubSender>();
diff --git a/src/TickerQ/Src/BackgroundServices/TickerQFallbackBackgroundService.cs b/src/TickerQ/Src/BackgroundServices/TickerQFallbackBackgroundService.cs
index 840c0d33..e43090dc 100644
--- a/src/TickerQ/Src/BackgroundServices/TickerQFallbackBackgroundService.cs
+++ b/src/TickerQ/Src/BackgroundServices/TickerQFallbackBackgroundService.cs
@@ -34,62 +34,76 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         while (!stoppingToken.IsCancellationRequested)
         {
-            // If the scheduler is frozen or disposed (e.g., manual start mode or shutdown),
-            // skip queuing fallback work to avoid throwing and stopping the host.
-            if (_tickerQTaskScheduler.IsFrozen || _tickerQTaskScheduler.IsDisposed)
+            try
             {
-                await Task.Delay(_fallbackJobPeriod, stoppingToken);
-                continue;
-            }
+                // If the scheduler is frozen or disposed (e.g., manual start mode or shutdown),
+                // skip queuing fallback work to avoid throwing and stopping the host.
+                if (_tickerQTaskScheduler.IsFrozen || _tickerQTaskScheduler.IsDisposed)
+                {
+                    await Task.Delay(_fallbackJobPeriod, stoppingToken);
+                    continue;
+                }
 
-            var functions = await _internalTickerManager.RunTimedOutTickers(stoppingToken);
+                var functions = await _internalTickerManager.RunTimedOutTickers(stoppingToken);
 
-            if (functions.Length != 0)
-            {
-                foreach (var function in functions)
+                if (functions.Length != 0)
                 {
-                    if (TickerFunctionProvider.TickerFunctions.TryGetValue(function.FunctionName, out var tickerItem))
+                    foreach (var function in functions)
                     {
-                        function.CachedDelegate = tickerItem.Delegate;
-                        function.CachedPriority = tickerItem.Priority;
-                    }
-
-                    foreach (var child in function.TimeTickerChildren)
-                    {
-                        if (TickerFunctionProvider.TickerFunctions.TryGetValue(child.FunctionName, out var childItem))
+                        if (TickerFunctionProvider.TickerFunctions.TryGetValue(function.FunctionName, out var tickerItem))
                         {
-                            child.CachedDelegate = childItem.Delegate;
-                            child.CachedPriority = childItem.Priority;
+                            function.CachedDelegate = tickerItem.Delegate;
+                            function.CachedPriority = tickerItem.Priority;
                         }
 
-                        foreach (var grandChild in child.TimeTickerChildren)
+                        foreach (var child in function.TimeTickerChildren)
                         {
-                            if (TickerFunctionProvider.TickerFunctions.TryGetValue(grandChild.FunctionName, out var grandChildItem))
+                            if (TickerFunctionProvider.TickerFunctions.TryGetValue(child.FunctionName, out var childItem))
+                            {
+                                child.CachedDelegate = childItem.Delegate;
+                                child.CachedPriority = childItem.Priority;
+                            }
+
+                            foreach (var grandChild in child.TimeTickerChildren)
                             {
-                                grandChild.CachedDelegate = grandChildItem.Delegate;
-                                grandChild.CachedPriority = grandChildItem.Priority;
+                                if (TickerFunctionProvider.TickerFunctions.TryGetValue(grandChild.FunctionName, out var grandChildItem))
+                                {
+                                    grandChild.CachedDelegate = grandChildItem.Delegate;
+                                    grandChild.CachedPriority = grandChildItem.Priority;
+                                }
                             }
                         }
-                    }
 
-                    try
-                    {
-                        await _tickerQTaskScheduler.QueueAsync(
-                            ct => _tickerExecutionTaskHandler.ExecuteTaskAsync(function, true, ct),
-                            function.CachedPriority,
-                            stoppingToken);
-                    }
-                    catch (InvalidOperationException) when (_tickerQTaskScheduler.IsFrozen || _tickerQTaskScheduler.IsDisposed)
-                    {
-                        // Scheduler is frozen/disposed – ignore and let loop delay
-                        break;
+                        try
+                        {
+                            await _tickerQTaskScheduler.QueueAsync(
+                                ct => _tickerExecutionTaskHandler.ExecuteTaskAsync(function, true, ct),
+                                function.CachedPriority,
+                                stoppingToken);
+                        }
+                        catch (InvalidOperationException) when (_tickerQTaskScheduler.IsFrozen || _tickerQTaskScheduler.IsDisposed)
+                        {
+                            // Scheduler is frozen/disposed – ignore and let loop delay
+                            break;
+                        }
                     }
-                }
 
-                await Task.Delay(TimeSpan.FromMilliseconds(10), stoppingToken);
+                    await Task.Delay(TimeSpan.FromMilliseconds(10), stoppingToken);
+                }
+                else
+                {
+                    await Task.Delay(_fallbackJobPeriod, stoppingToken);
+                }
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                // Host is shutting down – exit gracefully.
+                break;
             }
-            else
+            catch (Exception)
             {
+                // Swallow unexpected exceptions so they don't bubble up
+                // and stop the host; wait a bit before retrying.
                 await Task.Delay(_fallbackJobPeriod, stoppingToken);
             }
         }
diff --git a/src/TickerQ/Src/BackgroundServices/TickerQSchedulerBackgroundService.cs b/src/TickerQ/Src/BackgroundServices/TickerQSchedulerBackgroundService.cs
index caddef1a..81fd3aec 100644
--- a/src/TickerQ/Src/BackgroundServices/TickerQSchedulerBackgroundService.cs
+++ b/src/TickerQ/Src/BackgroundServices/TickerQSchedulerBackgroundService.cs
@@ -114,6 +114,7 @@ private async Task RunTickerQSchedulerAsync(CancellationToken stoppingToken, Can
             {
                 sleepDuration = TimeSpan.FromDays(1);
                 _executionContext.SetNextPlannedOccurrence(null);
+                _executionContext.SetFunctions(null);
             }
             else
             {
@@ -122,8 +123,12 @@ private async Task RunTickerQSchedulerAsync(CancellationToken stoppingToken, Can
                     : timeRemaining;
                 _executionContext.SetNextPlannedOccurrence(DateTime.UtcNow.Add(sleepDuration));
             }
-            
-            _executionContext.NotifyCoreAction(_executionContext.GetNextPlannedOccurrence(), CoreNotifyActionType.NotifyNextOccurence);
+
+            var notify = _executionContext.NotifyCoreAction;
+            if (notify != null)
+            {
+                notify(_executionContext.GetNextPlannedOccurrence(), CoreNotifyActionType.NotifyNextOccurence);
+            }
 
             await Task.Delay(sleepDuration, cancellationToken);
         }
@@ -131,7 +136,7 @@ private async Task RunTickerQSchedulerAsync(CancellationToken stoppingToken, Can
 
     private async Task ReleaseAllResourcesAsync(Exception ex)
     {
-        if (ex != null)
+        if (ex != null && _executionContext.NotifyCoreAction != null)
             _executionContext.NotifyCoreAction(ex.ToString(), CoreNotifyActionType.NotifyHostExceptionMessage);
 
         await _internalTickerManager.ReleaseAcquiredResources([], CancellationToken.None);
diff --git a/src/TickerQ/Src/Dispatcher/TickerQDispatcher.cs b/src/TickerQ/Src/Dispatcher/TickerQDispatcher.cs
new file mode 100644
index 00000000..ff83f183
--- /dev/null
+++ b/src/TickerQ/Src/Dispatcher/TickerQDispatcher.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using TickerQ.TickerQThreadPool;
+using TickerQ.Utilities.Interfaces;
+using TickerQ.Utilities.Models;
+
+namespace TickerQ.Dispatcher
+{
+    internal class TickerQDispatcher : ITickerQDispatcher
+    {
+        private readonly TickerQTaskScheduler _taskScheduler;
+        private readonly TickerExecutionTaskHandler _taskHandler;
+
+        public TickerQDispatcher(TickerQTaskScheduler taskScheduler, TickerExecutionTaskHandler taskHandler)
+        {
+            _taskScheduler = taskScheduler ?? throw new ArgumentNullException(nameof(taskScheduler));
+            _taskHandler = taskHandler ?? throw new ArgumentNullException(nameof(taskHandler));
+        }
+
+        public async Task DispatchAsync(InternalFunctionContext[] contexts, CancellationToken cancellationToken = default)
+        {
+            if (contexts == null || contexts.Length == 0)
+                return;
+
+            foreach (var context in contexts)
+            {
+                await _taskScheduler.QueueAsync(
+                    async ct => await _taskHandler.ExecuteTaskAsync(context, false, ct).ConfigureAwait(false),
+                    context.CachedPriority,
+                    cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+}
+
diff --git a/src/TickerQ/Src/Provider/TickerInMemoryPersistenceProvider.cs b/src/TickerQ/Src/Provider/TickerInMemoryPersistenceProvider.cs
index 5684b57d..64792382 100644
--- a/src/TickerQ/Src/Provider/TickerInMemoryPersistenceProvider.cs
+++ b/src/TickerQ/Src/Provider/TickerInMemoryPersistenceProvider.cs
@@ -24,6 +24,10 @@ internal class
         private static readonly ConcurrentDictionary<Guid, TTimeTicker> TimeTickers =
             new(new Dictionary<Guid, TTimeTicker>());
 
+        // Index of parent -> child ids for fast hierarchy lookup in memory
+        private static readonly ConcurrentDictionary<Guid, ConcurrentDictionary<Guid, byte>> ChildrenIndex =
+            new(new Dictionary<Guid, ConcurrentDictionary<Guid, byte>>());
+
         private static readonly ConcurrentDictionary<Guid, TCronTicker> CronTickers =
             new(new Dictionary<Guid, TCronTicker>());
 
@@ -61,7 +65,7 @@ public async IAsyncEnumerable<TimeTickerEntity> QueueTimeTickers(TimeTickerEntit
                         updatedTicker.LockedAt = now;
                         updatedTicker.UpdatedAt = now;
                         updatedTicker.Status = TickerStatus.Queued;
-
+                        
                         if (TimeTickers.TryUpdate(timeTicker.Id, updatedTicker, existingTicker))
                         {
                             timeTicker.UpdatedAt = now;
@@ -84,22 +88,23 @@ public async IAsyncEnumerable<TimeTickerEntity> QueueTimedOutTimeTickers([Enumer
             var fallbackThreshold = now.AddSeconds(-1);  // Fallback picks up tasks older than main 1-second window
 
             // First, get the time tickers that need to be updated (matching EF query)
+            // NOTE: we project to the raw ticker here and only build the full
+            //       TimeTickerEntity graph after we successfully acquire the lock.
             var timeTickersToUpdate = TimeTickers.Values
                 .Where(x => x.ExecutionTime != null)
                 .Where(x => x.Status == TickerStatus.Idle || x.Status == TickerStatus.Queued)
                 .Where(x => x.ExecutionTime <= fallbackThreshold)  // Only tasks older than 1 second
-                .Select(x => ForQueueTimeTickers(x))  // Map to TimeTickerEntity with children, matching EF's Select
                 .ToArray();
 
-            foreach (var timeTicker in timeTickersToUpdate)
+            foreach (var ticker in timeTickersToUpdate)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
                 // Now update the actual ticker in storage
-                if (TimeTickers.TryGetValue(timeTicker.Id, out var existingTicker))
+                if (TimeTickers.TryGetValue(ticker.Id, out var existingTicker))
                 {
                     // Check if we can update (matching EF's Where condition)
-                    if (existingTicker.UpdatedAt <= timeTicker.UpdatedAt)
+                    if (existingTicker.UpdatedAt <= ticker.UpdatedAt)
                     {
                         var updatedTicker = CloneTicker(existingTicker);
                         updatedTicker.LockHolder = _lockHolder;
@@ -107,9 +112,10 @@ public async IAsyncEnumerable<TimeTickerEntity> QueueTimedOutTimeTickers([Enumer
                         updatedTicker.UpdatedAt = now;
                         updatedTicker.Status = TickerStatus.InProgress;
 
-                        if (TimeTickers.TryUpdate(timeTicker.Id, updatedTicker, existingTicker))
+                        if (TimeTickers.TryUpdate(ticker.Id, updatedTicker, existingTicker))
                         {
-                            yield return timeTicker;  // Yield the already-mapped TimeTickerEntity
+                            // Only build the full hierarchy for successfully acquired tickers
+                            yield return ForQueueTimeTickers(ticker);
                         }
                     }
                 }
@@ -149,22 +155,21 @@ public Task ReleaseAcquiredTimeTickers(Guid[] timeTickerIds, CancellationToken c
         public Task<TimeTickerEntity[]> GetEarliestTimeTickers(CancellationToken cancellationToken = default)
         {
             var now = _clock.UtcNow;
-            
-            // Define the window: ignore anything older than 1 second ago
             var oneSecondAgo = now.AddSeconds(-1);
 
-            // Build base query matching EF Core's approach
+            // Base query: same filter as EF provider, but over the snapshot
             var baseQuery = TimeTickers.Values
                 .Where(x => x.ExecutionTime != null)
                 .Where(CanAcquire)
-                .Where(x => x.ExecutionTime >= oneSecondAgo);  // Ignore old tickers (fallback handles them)
+                .Where(x => x.ExecutionTime >= oneSecondAgo)
+                .ToArray();
 
-            // Get minimum execution time (matching EF's approach)
+            // Get minimum execution time
             var minExecutionTime = baseQuery
                 .OrderBy(x => x.ExecutionTime)
                 .Select(x => x.ExecutionTime)
                 .FirstOrDefault();
-            
+
             if (minExecutionTime == null)
                 return Task.FromResult(Array.Empty<TimeTickerEntity>());
 
@@ -178,13 +183,13 @@ public Task<TimeTickerEntity[]> GetEarliestTimeTickers(CancellationToken cancell
                 minExecutionTime.Value.Second,
                 DateTimeKind.Utc);
 
-            // Fetch all tickers within that complete second (this ensures we get all tickers in the same second)
             var maxExecutionTime = minSecond.AddSeconds(1);
 
+            // Fetch all tickers within that complete second and map using the children lookup
             var result = baseQuery
                 .Where(x => x.ExecutionTime >= minSecond && x.ExecutionTime < maxExecutionTime)
                 .OrderBy(x => x.ExecutionTime)
-                .Select(ForQueueTimeTickers)  // Use same mapping as EF Core
+                .Select(ForQueueTimeTickers)
                 .ToArray();
 
             return Task.FromResult(result);
@@ -230,17 +235,44 @@ public Task UpdateTimeTickersWithUnifiedContext(Guid[] timeTickerIds, InternalFu
             return Task.CompletedTask;
         }
 
+        public Task<TimeTickerEntity[]> AcquireImmediateTimeTickersAsync(Guid[] ids, CancellationToken cancellationToken = default)
+        {
+            if (ids == null || ids.Length == 0)
+                return Task.FromResult(Array.Empty<TimeTickerEntity>());
+
+            var now = _clock.UtcNow;
+            var acquired = new List<TimeTickerEntity>();
+
+            foreach (var id in ids)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (!TimeTickers.TryGetValue(id, out var ticker))
+                    continue;
+
+                if (!CanAcquire(ticker))
+                    continue;
+
+                var updatedTicker = CloneTicker(ticker);
+                updatedTicker.LockHolder = _lockHolder;
+                updatedTicker.LockedAt = now;
+                updatedTicker.Status = TickerStatus.InProgress;
+                updatedTicker.UpdatedAt = now;
+
+                if (TimeTickers.TryUpdate(id, updatedTicker, ticker))
+                {
+                    acquired.Add(ForQueueTimeTickers(updatedTicker));
+                }
+            }
+
+            return Task.FromResult(acquired.ToArray());
+        }
+
         public Task<TTimeTicker> GetTimeTickerById(Guid id, CancellationToken cancellationToken = default)
         {
             if (TimeTickers.TryGetValue(id, out var ticker))
             {
-                var result = CloneTicker(ticker);
-                // Include children
-                result.Children = TimeTickers.Values
-                    .Where(x => x.ParentId == id)
-                    .Select(x => CloneTicker(x))
-                    .ToList();
-                    
+                var result = BuildTickerHierarchy(ticker);
                 return Task.FromResult(result);
             }
             
@@ -259,25 +291,7 @@ public Task<TTimeTicker[]> GetTimeTickers(Expression<Func<TTimeTicker, bool>> pr
             var results = query
                 .Where(x => x.ParentId == null)  // Only root items, matching EF Core
                 .OrderByDescending(x => x.ExecutionTime)  // Match EF Core's OrderByDescending(x => x.ExecutionTime)
-                .Select(x =>
-                {
-                    var ticker = CloneTicker(x);
-                    // Include children with their children (matching EF's Include + ThenInclude)
-                    ticker.Children = TimeTickers.Values
-                        .Where(c => c.ParentId == x.Id)
-                        .Select(child =>
-                        {
-                            var clonedChild = CloneTicker(child);
-                            // Include grandchildren
-                            clonedChild.Children = TimeTickers.Values
-                                .Where(gc => gc.ParentId == child.Id)
-                                .Select(CloneTicker)
-                                .ToList();
-                            return clonedChild;
-                        })
-                        .ToList();
-                    return ticker;
-                })
+                .Select(BuildTickerHierarchy)
                 .ToArray();
                 
             return Task.FromResult(results);
@@ -301,25 +315,7 @@ public Task<PaginationResult<TTimeTicker>> GetTimeTickersPaginated(Expression<Fu
                 .OrderByDescending(x => x.ExecutionTime)  // Match EF Core's OrderByDescending(x => x.ExecutionTime)
                 .Skip((pageNumber - 1) * pageSize)
                 .Take(pageSize)
-                .Select(x =>
-                {
-                    var ticker = CloneTicker(x);
-                    // Include children with their children (matching EF's Include + ThenInclude)
-                    ticker.Children = TimeTickers.Values
-                        .Where(c => c.ParentId == x.Id)
-                        .Select(child =>
-                        {
-                            var clonedChild = CloneTicker(child);
-                            // Include grandchildren
-                            clonedChild.Children = TimeTickers.Values
-                                .Where(gc => gc.ParentId == child.Id)
-                                .Select(CloneTicker)
-                                .ToList();
-                            return clonedChild;
-                        })
-                        .ToList();
-                    return ticker;
-                })
+                .Select(BuildTickerHierarchy)
                 .ToArray();
                 
             return Task.FromResult(new PaginationResult<TTimeTicker>
@@ -355,6 +351,10 @@ private int AddTickerWithChildren(TTimeTicker ticker, Guid? parentId = null)
             // Add the ticker itself
             if (TimeTickers.TryAdd(ticker.Id, ticker))
             {
+                // Maintain children index
+                if (ticker.ParentId.HasValue)
+                    AddChildIndex(ticker.ParentId.Value, ticker.Id);
+
                 count++;
                 
                 // Recursively add all children
@@ -400,6 +400,15 @@ private int UpdateTickerWithChildren(TTimeTicker ticker, Guid? parentId = null)
             {
                 if (TimeTickers.TryUpdate(ticker.Id, ticker, existing))
                 {
+                    // Maintain children index for parent changes
+                    if (existing.ParentId != ticker.ParentId)
+                    {
+                        if (existing.ParentId.HasValue)
+                            RemoveChildIndex(existing.ParentId.Value, ticker.Id);
+                        if (ticker.ParentId.HasValue)
+                            AddChildIndex(ticker.ParentId.Value, ticker.Id);
+                    }
+
                     count++;
                     
                     // Recursively update all children
@@ -431,20 +440,25 @@ public Task<int> RemoveTimeTickers(Guid[] tickerIds, CancellationToken cancellat
             foreach (var id in tickerIds)
             {
                 // Remove ticker and all its children (cascade delete)
-                if (TimeTickers.TryRemove(id, out _))
+                if (TimeTickers.TryRemove(id, out var removed))
                 {
                     count++;
                     
+                    // Clean children index
+                    if (removed.ParentId.HasValue)
+                        RemoveChildIndex(removed.ParentId.Value, removed.Id);
+                    
                     // Remove children
-                    var childrenIds = TimeTickers.Values
-                        .Where(x => x.ParentId == id)
-                        .Select(x => x.Id)
-                        .ToArray();
+                    var childrenIds = GetChildrenIds(id);
                         
                     foreach (var childId in childrenIds)
                     {
-                        if (TimeTickers.TryRemove(childId, out _))
+                        if (TimeTickers.TryRemove(childId, out var child))
+                        {
                             count++;
+                            if (child.ParentId.HasValue)
+                                RemoveChildIndex(child.ParentId.Value, child.Id);
+                        }
                     }
                 }
             }
@@ -455,23 +469,47 @@ public Task<int> RemoveTimeTickers(Guid[] tickerIds, CancellationToken cancellat
         public Task ReleaseDeadNodeTimeTickerResources(string instanceIdentifier, CancellationToken cancellationToken = default)
         {
             var now = _clock.UtcNow;
-            
-            // Take snapshot to avoid enumeration issues during concurrent modifications
-            var tickersToRelease = TimeTickers.Values.Where(x => x.LockHolder == instanceIdentifier).ToArray();
-            foreach (var ticker in tickersToRelease)
+
+            // Phase 1: release acquirable tickers for the dead node (match EF WhereCanAcquire(instanceIdentifier))
+            var releasable = TimeTickers.Values
+                .Where(x =>
+                    (x.Status == TickerStatus.Idle || x.Status == TickerStatus.Queued) &&
+                    (x.LockHolder == instanceIdentifier || x.LockedAt == null))
+                .ToArray();
+
+            foreach (var ticker in releasable)
             {
-                if (TimeTickers.TryGetValue(ticker.Id, out var currentTicker))
-                {
-                    var updatedTicker = CloneTicker(currentTicker);
-                    updatedTicker.LockHolder = null;
-                    updatedTicker.LockedAt = null;
-                    updatedTicker.Status = TickerStatus.Idle;
-                    updatedTicker.UpdatedAt = now;
-                    
-                    TimeTickers.TryUpdate(ticker.Id, updatedTicker, currentTicker);
-                }
+                if (!TimeTickers.TryGetValue(ticker.Id, out var currentTicker))
+                    continue;
+
+                var updatedTicker = CloneTicker(currentTicker);
+                updatedTicker.LockHolder = null;
+                updatedTicker.LockedAt = null;
+                updatedTicker.Status = TickerStatus.Idle;
+                updatedTicker.UpdatedAt = now;
+
+                TimeTickers.TryUpdate(ticker.Id, updatedTicker, currentTicker);
             }
-            
+
+            // Phase 2: mark in-progress tickers for that node as skipped
+            var inProgress = TimeTickers.Values
+                .Where(x => x.LockHolder == instanceIdentifier && x.Status == TickerStatus.InProgress)
+                .ToArray();
+
+            foreach (var ticker in inProgress)
+            {
+                if (!TimeTickers.TryGetValue(ticker.Id, out var currentTicker))
+                    continue;
+
+                var updatedTicker = CloneTicker(currentTicker);
+                updatedTicker.Status = TickerStatus.Skipped;
+                updatedTicker.SkippedReason = "Node is not alive!";
+                updatedTicker.ExecutedAt = now;
+                updatedTicker.UpdatedAt = now;
+
+                TimeTickers.TryUpdate(ticker.Id, updatedTicker, currentTicker);
+            }
+
             return Task.CompletedTask;
         }
 
@@ -615,7 +653,7 @@ public Task<CronTickerOccurrenceEntity<TCronTicker>> GetEarliestAvailableCronOcc
             var query = CronOccurrences.Values.AsEnumerable();
             
             if (ids != null && ids.Length > 0)
-                query = query.Where(x => ids.Contains(x.CronTicker.Id));
+                query = query.Where(x => ids.Contains(x.CronTickerId));
                 
             var occurrence = query
                 .Where(x => CanAcquireCronOccurrence(x))
@@ -788,23 +826,47 @@ public Task UpdateCronTickerOccurrencesWithUnifiedContext(Guid[] timeTickerIds,
         public Task ReleaseDeadNodeOccurrenceResources(string instanceIdentifier, CancellationToken cancellationToken = default)
         {
             var now = _clock.UtcNow;
-            
-            // Take snapshot to avoid enumeration issues during concurrent modifications
-            var occurrencesToRelease = CronOccurrences.Values.Where(x => x.LockHolder == instanceIdentifier).ToArray();
-            foreach (var occurrence in occurrencesToRelease)
+
+            // Phase 1: release acquirable occurrences for the dead node (match EF WhereCanAcquire(instanceIdentifier))
+            var releasable = CronOccurrences.Values
+                .Where(x =>
+                    (x.Status == TickerStatus.Idle || x.Status == TickerStatus.Queued) &&
+                    (x.LockHolder == instanceIdentifier || x.LockedAt == null))
+                .ToArray();
+
+            foreach (var occurrence in releasable)
             {
-                if (CronOccurrences.TryGetValue(occurrence.Id, out var currentOccurrence))
-                {
-                    var updatedOccurrence = CloneCronOccurrence(currentOccurrence);
-                    updatedOccurrence.LockHolder = null;
-                    updatedOccurrence.LockedAt = null;
-                    updatedOccurrence.Status = TickerStatus.Idle;
-                    updatedOccurrence.UpdatedAt = now;
-                    
-                    CronOccurrences.TryUpdate(occurrence.Id, updatedOccurrence, currentOccurrence);
-                }
+                if (!CronOccurrences.TryGetValue(occurrence.Id, out var currentOccurrence))
+                    continue;
+
+                var updatedOccurrence = CloneCronOccurrence(currentOccurrence);
+                updatedOccurrence.LockHolder = null;
+                updatedOccurrence.LockedAt = null;
+                updatedOccurrence.Status = TickerStatus.Idle;
+                updatedOccurrence.UpdatedAt = now;
+
+                CronOccurrences.TryUpdate(occurrence.Id, updatedOccurrence, currentOccurrence);
             }
-            
+
+            // Phase 2: mark in-progress occurrences for that node as skipped
+            var inProgress = CronOccurrences.Values
+                .Where(x => x.LockHolder == instanceIdentifier && x.Status == TickerStatus.InProgress)
+                .ToArray();
+
+            foreach (var occurrence in inProgress)
+            {
+                if (!CronOccurrences.TryGetValue(occurrence.Id, out var currentOccurrence))
+                    continue;
+
+                var updatedOccurrence = CloneCronOccurrence(currentOccurrence);
+                updatedOccurrence.Status = TickerStatus.Skipped;
+                updatedOccurrence.SkippedReason = "Node is not alive!";
+                updatedOccurrence.ExecutedAt = now;
+                updatedOccurrence.UpdatedAt = now;
+
+                CronOccurrences.TryUpdate(occurrence.Id, updatedOccurrence, currentOccurrence);
+            }
+
             return Task.CompletedTask;
         }
 
@@ -854,6 +916,12 @@ public Task<int> InsertCronTickerOccurrences(CronTickerOccurrenceEntity<TCronTic
             var count = 0;
             foreach (var occurrence in cronTickerOccurrences)
             {
+                // Ensure navigation is populated for in-memory usage
+                if (occurrence.CronTicker == null && CronTickers.TryGetValue(occurrence.CronTickerId, out var cronTicker))
+                {
+                    occurrence.CronTicker = cronTicker;
+                }
+
                 if (CronOccurrences.TryAdd(occurrence.Id, occurrence))
                     count++;
             }
@@ -873,14 +941,74 @@ public Task<int> RemoveCronTickerOccurrences(Guid[] cronTickerOccurrences, Cance
             return Task.FromResult(count);
         }
 
+        public Task<CronTickerOccurrenceEntity<TCronTicker>[]> AcquireImmediateCronOccurrencesAsync(Guid[] occurrenceIds, CancellationToken cancellationToken = default)
+        {
+            if (occurrenceIds == null || occurrenceIds.Length == 0)
+                return Task.FromResult(Array.Empty<CronTickerOccurrenceEntity<TCronTicker>>());
+
+            var now = _clock.UtcNow;
+            var acquired = new List<CronTickerOccurrenceEntity<TCronTicker>>();
+
+            foreach (var id in occurrenceIds)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (!CronOccurrences.TryGetValue(id, out var occurrence))
+                    continue;
+
+                if (!CanAcquireCronOccurrence(occurrence))
+                    continue;
+
+                var updated = CloneCronOccurrence(occurrence);
+                updated.LockHolder = _lockHolder;
+                updated.LockedAt = now;
+                updated.Status = TickerStatus.InProgress;
+                updated.UpdatedAt = now;
+
+                if (CronOccurrences.TryUpdate(id, updated, occurrence))
+                {
+                    acquired.Add(updated);
+                }
+            }
+
+            return Task.FromResult(acquired.ToArray());
+        }
+
         #endregion
 
         #region Helper Methods
 
-        // Matches EF Core's MappingExtensions.ForQueueTimeTickers
-        private TimeTickerEntity ForQueueTimeTickers(TTimeTicker ticker)
+        private TTimeTicker BuildTickerHierarchy(TTimeTicker ticker)
         {
-            return new TimeTickerEntity
+            var root = CloneTicker(ticker);
+            root.Children = BuildChildrenHierarchy(ticker.Id);
+            return root;
+        }
+
+        private List<TTimeTicker> BuildChildrenHierarchy(Guid parentId)
+        {
+            if (!ChildrenIndex.TryGetValue(parentId, out var children) || children.IsEmpty)
+                return new List<TTimeTicker>();
+
+            var results = new List<TTimeTicker>(children.Count);
+
+            foreach (var childId in children.Keys)
+            {
+                if (!TimeTickers.TryGetValue(childId, out var child))
+                    continue;
+
+                var clonedChild = CloneTicker(child);
+                clonedChild.Children = BuildChildrenHierarchy(child.Id);
+                results.Add(clonedChild);
+            }
+
+            return results;
+        }
+
+        // Matches EF Core's MappingExtensions.ForQueueTimeTickers but uses an in-memory children index
+        private static TimeTickerEntity ForQueueTimeTickers(TTimeTicker ticker)
+        {
+            var root = new TimeTickerEntity
             {
                 Id = ticker.Id,
                 Function = ticker.Function,
@@ -889,29 +1017,91 @@ private TimeTickerEntity ForQueueTimeTickers(TTimeTicker ticker)
                 UpdatedAt = ticker.UpdatedAt,
                 ParentId = ticker.ParentId,
                 ExecutionTime = ticker.ExecutionTime,
-                Children = TimeTickers.Values
-                    .Where(x => x.ParentId == ticker.Id && x.ExecutionTime == null)
-                    .Select(ch => new TimeTickerEntity
+                Children = new List<TimeTickerEntity>()
+            };
+
+            if (ChildrenIndex.TryGetValue(ticker.Id, out var directChildren) && !directChildren.IsEmpty)
+            {
+                // Pre-size children collection to avoid repeated growth
+                var children = new List<TimeTickerEntity>(directChildren.Count);
+
+                foreach (var childId in directChildren.Keys)
+                {
+                    if (!TimeTickers.TryGetValue(childId, out var ch))
+                        continue;
+
+                    // Only children with null ExecutionTime, matching EF mapping
+                    if (ch.ExecutionTime != null)
+                        continue;
+
+                    var childEntity = new TimeTickerEntity
                     {
                         Id = ch.Id,
                         Function = ch.Function,
                         Retries = ch.Retries,
                         RetryIntervals = ch.RetryIntervals,
                         RunCondition = ch.RunCondition,
-                        Children = TimeTickers.Values
-                            .Where(gch => gch.ParentId == ch.Id)
-                            .Select(gch => new TimeTickerEntity
+                        Children = new List<TimeTickerEntity>()
+                    };
+
+                    if (ChildrenIndex.TryGetValue(ch.Id, out var grandChildren) && !grandChildren.IsEmpty)
+                    {
+                        // Pre-size grandchildren collection
+                        var grandChildList = new List<TimeTickerEntity>(grandChildren.Count);
+
+                        foreach (var grandChildId in grandChildren.Keys)
+                        {
+                            if (!TimeTickers.TryGetValue(grandChildId, out var gch))
+                                continue;
+
+                            grandChildList.Add(new TimeTickerEntity
                             {
+                                Id = gch.Id,
                                 Function = gch.Function,
                                 Retries = gch.Retries,
                                 RetryIntervals = gch.RetryIntervals,
-                                Id = gch.Id,
                                 RunCondition = gch.RunCondition
-                            })
-                            .ToList()
-                    })
-                    .ToList()
-            };
+                            });
+                        }
+
+                        childEntity.Children = grandChildList;
+                    }
+
+                    children.Add(childEntity);
+                }
+
+                root.Children = children;
+            }
+
+            return root;
+        }
+
+        private static void AddChildIndex(Guid parentId, Guid childId)
+        {
+            var children = ChildrenIndex.GetOrAdd(parentId, _ => new ConcurrentDictionary<Guid, byte>());
+            children.TryAdd(childId, 0);
+        }
+
+        private static void RemoveChildIndex(Guid parentId, Guid childId)
+        {
+            if (!ChildrenIndex.TryGetValue(parentId, out var children))
+                return;
+
+            children.TryRemove(childId, out _);
+
+            // Optional: cleanup empty buckets
+            if (children.IsEmpty)
+            {
+                ChildrenIndex.TryRemove(parentId, out _);
+            }
+        }
+
+        private static Guid[] GetChildrenIds(Guid parentId)
+        {
+            if (!ChildrenIndex.TryGetValue(parentId, out var children))
+                return Array.Empty<Guid>();
+
+            return children.Keys.ToArray();
         }
 
         private bool CanAcquire(TTimeTicker ticker)
@@ -984,34 +1174,106 @@ private CronTickerOccurrenceEntity<TCronTicker> CloneCronOccurrence(CronTickerOc
 
         private void ApplyFunctionContextToTicker(TTimeTicker ticker, InternalFunctionContext context)
         {
-            ticker.UpdatedAt = _clock.UtcNow;
-            ticker.Status = context.Status;
-            ticker.RetryCount = context.RetryCount;
-            ticker.ElapsedTime = context.ElapsedTime;
-            ticker.ExceptionMessage = context.ExceptionDetails;
-            ticker.ExecutedAt = context.ExecutedAt;
-            
-            if (context.Status == TickerStatus.Done || context.Status == TickerStatus.DueDone)
+            var propsToUpdate = context.GetPropsToUpdate();
+
+            // STATUS / SKIPPED
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.Status)) &&
+                context.Status != TickerStatus.Skipped)
+            {
+                ticker.Status = context.Status;
+            }
+            else if (propsToUpdate.Contains(nameof(InternalFunctionContext.Status)))
+            {
+                ticker.Status = context.Status;
+                ticker.SkippedReason = context.ExceptionDetails;
+            }
+
+            // EXECUTED_AT
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ExecutedAt)))
+            {
+                ticker.ExecutedAt = context.ExecutedAt;
+            }
+
+            // EXCEPTION DETAILS
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ExceptionDetails)) &&
+                context.Status != TickerStatus.Skipped)
+            {
+                ticker.ExceptionMessage = context.ExceptionDetails;
+            }
+
+            // ELAPSED_TIME
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ElapsedTime)))
+            {
+                ticker.ElapsedTime = context.ElapsedTime;
+            }
+
+            // RETRY COUNT
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.RetryCount)))
+            {
+                ticker.RetryCount = context.RetryCount;
+            }
+
+            // RELEASE LOCK
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ReleaseLock)))
             {
                 ticker.LockHolder = null;
                 ticker.LockedAt = null;
             }
+
+            // UPDATED_AT ALWAYS
+            ticker.UpdatedAt = _clock.UtcNow;
         }
         
         private void ApplyFunctionContextToCronOccurrence(CronTickerOccurrenceEntity<TCronTicker> occurrence, InternalFunctionContext context)
         {
-            occurrence.UpdatedAt = _clock.UtcNow;
-            occurrence.Status = context.Status;
-            occurrence.RetryCount = context.RetryCount;
-            occurrence.ElapsedTime = context.ElapsedTime;
-            occurrence.ExceptionMessage = context.ExceptionDetails;
-            occurrence.ExecutedAt = context.ExecutedAt;
-            
-            if (context.Status == TickerStatus.Done || context.Status == TickerStatus.DueDone)
+            var propsToUpdate = context.GetPropsToUpdate();
+
+            // STATUS / SKIPPED
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.Status)) &&
+                context.Status != TickerStatus.Skipped)
+            {
+                occurrence.Status = context.Status;
+            }
+            else if (propsToUpdate.Contains(nameof(InternalFunctionContext.Status)))
+            {
+                occurrence.Status = context.Status;
+                occurrence.SkippedReason = context.ExceptionDetails;
+            }
+
+            // EXECUTED_AT
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ExecutedAt)))
+            {
+                occurrence.ExecutedAt = context.ExecutedAt;
+            }
+
+            // EXCEPTION DETAILS
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ExceptionDetails)) &&
+                context.Status != TickerStatus.Skipped)
+            {
+                occurrence.ExceptionMessage = context.ExceptionDetails;
+            }
+
+            // ELAPSED_TIME
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ElapsedTime)))
+            {
+                occurrence.ElapsedTime = context.ElapsedTime;
+            }
+
+            // RETRY COUNT
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.RetryCount)))
+            {
+                occurrence.RetryCount = context.RetryCount;
+            }
+
+            // RELEASE LOCK
+            if (propsToUpdate.Contains(nameof(InternalFunctionContext.ReleaseLock)))
             {
                 occurrence.LockHolder = null;
                 occurrence.LockedAt = null;
             }
+
+            // UPDATED_AT ALWAYS
+            occurrence.UpdatedAt = _clock.UtcNow;
         }
 
         #endregion
diff --git a/src/TickerQ/Src/TickerExecutionTaskHandler.cs b/src/TickerQ/Src/TickerExecutionTaskHandler.cs
index 7145d88d..b1573765 100644
--- a/src/TickerQ/Src/TickerExecutionTaskHandler.cs
+++ b/src/TickerQ/Src/TickerExecutionTaskHandler.cs
@@ -147,6 +147,7 @@ private async Task RunContextFunctionAsync(InternalFunctionContext context, bool
             Id = context.TickerId,
             Type = context.Type,
             IsDue = isDue,
+            ScheduledFor = context.ExecutionTime,
             RequestCancelOperationAction = () => cancellationTokenSource.Cancel(),
             CronOccurrenceOperations = new CronOccurrenceOperations
             {
@@ -385,4 +386,4 @@ private Task SafeRecursiveExecution(InternalFunctionContext context, bool isDue,
 
         return Task.CompletedTask;
     }
-}
\ No newline at end of file
+}
diff --git a/src/TickerQ/Src/TickerQThreadPool/TickerQTaskScheduler.cs b/src/TickerQ/Src/TickerQThreadPool/TickerQTaskScheduler.cs
index 788a9728..9f5a6098 100644
--- a/src/TickerQ/Src/TickerQThreadPool/TickerQTaskScheduler.cs
+++ b/src/TickerQ/Src/TickerQThreadPool/TickerQTaskScheduler.cs
@@ -7,8 +7,7 @@
 namespace TickerQ.TickerQThreadPool;
 
 /// <summary>
-/// Simplified elastic work-stealing task scheduler.
-/// No priority support - focuses on throughput and efficient CPU utilization.
+/// Elastic work-stealing task scheduler.
 /// </summary>
 public sealed class TickerQTaskScheduler : IAsyncDisposable
 {
@@ -361,7 +360,7 @@ private async Task ExecuteWorkAsync(WorkItem workItem)
                     // Task already completed synchronously – observe any exception
                     try
                     {
-                        await task.ConfigureAwait(false);
+                        await task;
                     }
                     catch
                     {
diff --git a/tests/TickerQ.Tests/CronScheduleCacheTests.cs b/tests/TickerQ.Tests/CronScheduleCacheTests.cs
new file mode 100644
index 00000000..20ec124c
--- /dev/null
+++ b/tests/TickerQ.Tests/CronScheduleCacheTests.cs
@@ -0,0 +1,40 @@
+using System;
+using FluentAssertions;
+using TickerQ.Utilities;
+using Xunit;
+
+namespace TickerQ.Tests;
+
+public class CronScheduleCacheTests
+{
+    [Fact]
+    public void GetNextOccurrenceOrDefault_Returns_Null_For_Invalid_Expression()
+    {
+        CronScheduleCache.TimeZoneInfo = TimeZoneInfo.Utc;
+
+        var next = CronScheduleCache.GetNextOccurrenceOrDefault("invalid cron", DateTime.UtcNow);
+
+        next.Should().BeNull();
+    }
+
+    [Fact]
+    public void GetNextOccurrenceOrDefault_Normalizes_Whitespace_And_Caches()
+    {
+        CronScheduleCache.TimeZoneInfo = TimeZoneInfo.Utc;
+        var now = new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        var expr1 = "*/5 * * * * *";
+        var expr2 = "*/5    *   *   *   *   *";
+
+        var next1 = CronScheduleCache.GetNextOccurrenceOrDefault(expr1, now);
+        var next2 = CronScheduleCache.GetNextOccurrenceOrDefault(expr2, now);
+
+        next1.Should().NotBeNull();
+        next2.Should().NotBeNull();
+        next2.Should().Be(next1);
+
+        var invalidated = CronScheduleCache.Invalidate(expr1);
+        invalidated.Should().BeTrue();
+    }
+}
+
diff --git a/tests/TickerQ.Tests/InternalFunctionContextTests.cs b/tests/TickerQ.Tests/InternalFunctionContextTests.cs
new file mode 100644
index 00000000..74256bf7
--- /dev/null
+++ b/tests/TickerQ.Tests/InternalFunctionContextTests.cs
@@ -0,0 +1,167 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using FluentAssertions;
+using TickerQ.Utilities.Enums;
+using TickerQ.Utilities;
+using TickerQ.Utilities.Models;
+using Xunit;
+
+namespace TickerQ.Tests;
+
+public class InternalFunctionContextTests
+{
+    [Fact]
+    public void SetProperty_Tracks_Updated_Properties()
+    {
+        var context = new InternalFunctionContext();
+
+        context
+            .SetProperty(c => c.Status, TickerStatus.InProgress)
+            .SetProperty(c => c.ElapsedTime, 123L)
+            .SetProperty(c => c.ReleaseLock, true);
+
+        var updated = context.GetPropsToUpdate();
+
+        updated.Should().Contain(new[] { nameof(InternalFunctionContext.Status), nameof(InternalFunctionContext.ElapsedTime), nameof(InternalFunctionContext.ReleaseLock) });
+        updated.Count.Should().Be(3);
+
+        context.Status.Should().Be(TickerStatus.InProgress);
+        context.ElapsedTime.Should().Be(123L);
+        context.ReleaseLock.Should().BeTrue();
+    }
+
+    [Fact]
+    public void ResetUpdateProps_Clears_Tracked_Properties()
+    {
+        var context = new InternalFunctionContext();
+
+        context
+            .SetProperty(c => c.Status, TickerStatus.Done)
+            .SetProperty(c => c.ElapsedTime, 500L);
+
+        context.GetPropsToUpdate().Should().NotBeEmpty();
+
+        context.ResetUpdateProps();
+
+        context.GetPropsToUpdate().Should().BeEmpty();
+    }
+
+    [Fact]
+    public void ResetUpdateProps_Does_Not_Reset_Property_Values()
+    {
+        var context = new InternalFunctionContext();
+
+        context
+            .SetProperty(c => c.Status, TickerStatus.Done)
+            .SetProperty(c => c.ElapsedTime, 250L);
+
+        context.ResetUpdateProps();
+
+        context.Status.Should().Be(TickerStatus.Done);
+        context.ElapsedTime.Should().Be(250L);
+        context.GetPropsToUpdate().Should().BeEmpty();
+    }
+
+    [Fact]
+    public void SetProperty_Reinitializes_Tracking_Set_When_Null()
+    {
+        var context = new InternalFunctionContext();
+
+        // Simulate a null ParametersToUpdate set to verify the null-coalescing assignment.
+        var parametersProperty = typeof(InternalFunctionContext)
+            .GetProperty("ParametersToUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
+
+        parametersProperty.Should().NotBeNull();
+        parametersProperty!.SetValue(context, null);
+
+        context.SetProperty(c => c.Status, TickerStatus.InProgress);
+
+        var updated = context.GetPropsToUpdate();
+        updated.Should().NotBeNull();
+        updated.Should().Contain(nameof(InternalFunctionContext.Status));
+    }
+
+    [Fact]
+    public void SetProperty_Allows_Multiple_Updates_To_Same_Property()
+    {
+        var context = new InternalFunctionContext();
+
+        context
+            .SetProperty(c => c.Status, TickerStatus.InProgress)
+            .SetProperty(c => c.Status, TickerStatus.Failed);
+
+        context.Status.Should().Be(TickerStatus.Failed);
+
+        var updated = context.GetPropsToUpdate();
+        updated.Should().Contain(nameof(InternalFunctionContext.Status));
+        updated.Count.Should().Be(1);
+    }
+
+    [Fact]
+    public void SetProperty_Throws_For_NonProperty_Expression()
+    {
+        var context = new InternalFunctionContext();
+
+        Action act = () => context.SetProperty(c => c.ElapsedTime + 1, 10L);
+
+        act.Should().Throw<ArgumentException>()
+            .WithMessage("*Expression must point to a property*");
+    }
+
+    [Fact]
+    public void TimeTickerChildren_Defaults_To_Empty_List_And_Can_Add()
+    {
+        var context = new InternalFunctionContext();
+
+        context.TimeTickerChildren.Should().NotBeNull();
+        context.TimeTickerChildren.Should().BeEmpty();
+
+        var child = new InternalFunctionContext
+        {
+            TickerId = Guid.NewGuid(),
+            ParentId = Guid.NewGuid(),
+            FunctionName = "ChildFunction"
+        };
+
+        context.TimeTickerChildren.Add(child);
+
+        context.TimeTickerChildren.Should().ContainSingle();
+        context.TimeTickerChildren.Single().FunctionName.Should().Be("ChildFunction");
+    }
+
+    [Fact]
+    public void CachedDelegate_And_Priority_Can_Be_Assigned()
+    {
+        var context = new InternalFunctionContext();
+        TickerFunctionDelegate handler = (_, _, _) => default!;
+
+        context.CachedDelegate = handler;
+        context.CachedPriority = TickerTaskPriority.High;
+
+        context.CachedDelegate.Should().BeSameAs(handler);
+        context.CachedPriority.Should().Be(TickerTaskPriority.High);
+    }
+
+    [Fact]
+    public void SetProperty_Supports_Array_And_String_Properties()
+    {
+        var context = new InternalFunctionContext();
+        var intervals = new[] { 1, 5, 10 };
+        const string exceptionDetails = "Something went wrong";
+
+        context
+            .SetProperty(c => c.RetryIntervals, intervals)
+            .SetProperty(c => c.ExceptionDetails, exceptionDetails);
+
+        context.RetryIntervals.Should().BeSameAs(intervals);
+        context.ExceptionDetails.Should().Be(exceptionDetails);
+
+        var updated = context.GetPropsToUpdate();
+        updated.Should().Contain(new[]
+        {
+            nameof(InternalFunctionContext.RetryIntervals),
+            nameof(InternalFunctionContext.ExceptionDetails)
+        });
+    }
+}
diff --git a/tests/TickerQ.Tests/TickerFunctionContextTests.cs b/tests/TickerQ.Tests/TickerFunctionContextTests.cs
new file mode 100644
index 00000000..7f862e9b
--- /dev/null
+++ b/tests/TickerQ.Tests/TickerFunctionContextTests.cs
@@ -0,0 +1,55 @@
+using System;
+using TickerQ.Utilities.Base;
+using TickerQ.Utilities.Enums;
+using Xunit;
+
+namespace TickerQ.Tests;
+
+public class TickerFunctionContextTests
+{
+    [Fact]
+    public void GenericContext_Preserves_ScheduledFor_From_Base_Context()
+    {
+        // Arrange
+        var scheduledFor = new DateTime(2025, 1, 1, 12, 0, 0, DateTimeKind.Utc);
+
+        var baseContext = new TickerFunctionContext
+        {
+            Id = Guid.NewGuid(),
+            Type = TickerType.TimeTicker,
+            RetryCount = 1,
+            IsDue = true,
+            ScheduledFor = scheduledFor,
+            FunctionName = "TestFunction"
+        };
+
+        var request = new TestRequest { Value = 42 };
+
+        // Act
+        var genericContext = new TickerFunctionContext<TestRequest>(baseContext, request);
+
+        // Assert
+        Assert.Equal(baseContext.Id, genericContext.Id);
+        Assert.Equal(baseContext.Type, genericContext.Type);
+        Assert.Equal(baseContext.RetryCount, genericContext.RetryCount);
+        Assert.Equal(baseContext.IsDue, genericContext.IsDue);
+        Assert.Equal(baseContext.ScheduledFor, genericContext.ScheduledFor);
+        Assert.Equal(baseContext.FunctionName, genericContext.FunctionName);
+        Assert.Equal(request, genericContext.Request);
+    }
+
+    [Fact]
+    public void RequestCancellation_Invokes_Underlying_Action()
+    {
+        // This test is intentionally left empty because RequestCancelOperationAction
+        // is an internal delegate that is only set by the runtime scheduler pipeline.
+        // Verifying its behavior would require testing internal wiring rather than
+        // the public surface area of TickerFunctionContext.
+        Assert.True(true);
+    }
+    
+    private sealed class TestRequest
+    {
+        public int Value { get; set; }
+    }
+}
diff --git a/tests/TickerQ.Tests/TickerOptionsBuilderTests.cs b/tests/TickerQ.Tests/TickerOptionsBuilderTests.cs
new file mode 100644
index 00000000..195086c3
--- /dev/null
+++ b/tests/TickerQ.Tests/TickerOptionsBuilderTests.cs
@@ -0,0 +1,154 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using TickerQ.Utilities;
+using TickerQ.Utilities.Entities;
+using TickerQ.Utilities.Interfaces;
+using TickerQ.Utilities.Interfaces.Managers;
+using TickerQ.Utilities.Enums;
+using Xunit;
+
+namespace TickerQ.Tests;
+
+public class TickerOptionsBuilderTests
+{
+    private sealed class FakeTimeTicker : TimeTickerEntity<FakeTimeTicker> { }
+    private sealed class FakeCronTicker : CronTickerEntity { }
+
+    private sealed class FakeExceptionHandler : ITickerExceptionHandler
+    {
+        public System.Threading.Tasks.Task HandleExceptionAsync(Exception exception, Guid tickerId, TickerType tickerType) 
+            => System.Threading.Tasks.Task.CompletedTask;
+
+        public System.Threading.Tasks.Task HandleCanceledExceptionAsync(Exception exception, Guid tickerId, TickerType tickerType) 
+            => System.Threading.Tasks.Task.CompletedTask;
+    }
+
+    [Fact]
+    public void ConfigureRequestJsonOptions_Initializes_And_Invokes_Config()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.ConfigureRequestJsonOptions(options =>
+        {
+            options.PropertyNameCaseInsensitive = true;
+            options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
+        });
+
+        var jsonOptions = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("RequestJsonSerializerOptions", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder) as JsonSerializerOptions;
+
+        jsonOptions.Should().NotBeNull();
+        jsonOptions!.PropertyNameCaseInsensitive.Should().BeTrue();
+        jsonOptions.DefaultIgnoreCondition.Should().Be(JsonIgnoreCondition.WhenWritingNull);
+    }
+
+    [Fact]
+    public void UseGZipCompression_Sets_Flag()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.UseGZipCompression();
+
+        var flag = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("RequestGZipCompressionEnabled", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder);
+
+        flag.Should().BeOfType<bool>().Which.Should().BeTrue();
+    }
+
+    [Fact]
+    public void IgnoreSeedDefinedCronTickers_Disables_Seeding_Flag()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.IgnoreSeedDefinedCronTickers();
+
+        var flag = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("SeedDefinedCronTickers", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder);
+
+        flag.Should().BeOfType<bool>().Which.Should().BeFalse();
+    }
+
+    [Fact]
+    public void SetExceptionHandler_Sets_Handler_Type()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.SetExceptionHandler<FakeExceptionHandler>();
+
+        var handlerType = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("TickerExceptionHandlerType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder) as Type;
+
+        handlerType.Should().Be(typeof(FakeExceptionHandler));
+    }
+
+    [Fact]
+    public void UseTickerSeeder_Time_Sets_TimeSeederAction()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.UseTickerSeeder(async (ITimeTickerManager<FakeTimeTicker> _) => { await System.Threading.Tasks.Task.CompletedTask; });
+
+        var seeder = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("TimeSeederAction", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder);
+
+        seeder.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void UseTickerSeeder_Cron_Sets_CronSeederAction()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.UseTickerSeeder(async (ICronTickerManager<FakeCronTicker> _) => { await System.Threading.Tasks.Task.CompletedTask; });
+
+        var seeder = typeof(TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>)
+            .GetProperty("CronSeederAction", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(builder);
+
+        seeder.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void ConfigureScheduler_Invokes_Delegate()
+    {
+        var executionContext = new TickerExecutionContext();
+        var schedulerOptions = new SchedulerOptionsBuilder();
+
+        var builder = new TickerOptionsBuilder<FakeTimeTicker, FakeCronTicker>(executionContext, schedulerOptions);
+
+        builder.ConfigureScheduler(options =>
+        {
+            options.MaxConcurrency = 42;
+            options.NodeIdentifier = "test-node";
+        });
+
+        schedulerOptions.MaxConcurrency.Should().Be(42);
+        schedulerOptions.NodeIdentifier.Should().Be("test-node");
+    }
+}