shell
1$ fly launch
2
3Creating app in \fly\guides\hellodotnet
4
5? Choose an app name (leave blank to generate one): hellodotnet
6? Select Organization: demo (demo)
7? Select region: ord (Chicago, Illinois (US))
8
9Admin URL: https://fly.io/apps/hellodotnet
10Hostname: hellodotnet.fly.dev
11? Would you like to set up a Postgresql database now? No
12? Would you like to set up an Upstash Redis database now? No
13Wrote config file fly.toml
14? Would you like to deploy now? Yes
15
16Deploying hellodotnet
17...
18
19$ flyctl apps open
20Opening https://hellodotnet.fly.dev/

Scheduling background jobs is a fundamental part of many .NET applications — whether it's sending emails, processing reports, or syncing data.

For years, developers have relied on tools like Quartz.NET and Hangfire.

While they are great tools, they have several drawbacks.

Quartz.NET drawbacks:

• Reflection-based job registration
• Complex API
• Heavy configuration
• Clumsy parameter passing into the jobs
• No built-in EF Core integration (only via 3rd party packages)
• No built-in dashboard for job monitoring (only via 3rd party packages)
• No built-in retries

Hangfire drawbacks:

• Reflection-based job registration
• Limited DI-support
• Limited async support
• Some built-in storage providers require a commercial license

TickerQ is a fresh take on job scheduling in .NET — offering a modern, clean API, built-in persistence, EF Core integration, and a beautiful dashboard for job monitoring.

It removes much of the boilerplate and ceremony we're used to, and instead provides a developer-friendly, code-first experience.

In this post, we will explore:

• How to set up TickerQ in a .NET project
• Integrating TickerQ with EF Core
• Creating and scheduling jobs (recurring and one-time)
• Dynamically registering jobs
• Using the TickerQ Dashboard to monitor job execution

Let's dive in!

TickerQ is available as a NuGet package that targets .NET Standard 2.1 and is compatible with any .NET Core 3.1+ application. It works out of the box with ASP.NET Core and doesn't require any additional configuration files — everything is code-first and dependency-injection friendly.

Follow these steps to get started with TickerQ:

Step 1: Install the NuGet Package

bash
1dotnet add package TickerQ

This adds the core TickerQ library. You can optionally install other packages like TickerQ.EntityFrameworkCore and TickerQ.Dashboard (we'll cover that in the next sections).

Step 2: Register TickerQ in the Program.cs

TickerQ plugs directly into your application startup pipeline. Add the following lines in your Program.cs:

csharp
1builder.Services.AddTickerQ();
2
3var app = builder.Build();
4app.UseTickerQ();
5
6app.Run();

AddTickerQ method registers all the required services for TickerQ. UseTickerQ method adds the middleware that handles the incoming requests.

That's it. No background services to manage. No additional hosted services. TickerQ takes care of that for you under the hood.

Step 3: Define a Job

TickerQ jobs are just regular class methods, and classes don't need to inherit any interfaces or base classes. Simply add the TickerFunction attribute to any method in any class.

Here is an example of a job that creates reports:

csharp
1public class CreateReportJob
2{
3    private readonly ReportDbContext _dbContext;
4
5    public CreateReportJob(ReportDbContext dbContext)
6    {
7        _dbContext = dbContext;
8    }
9
10    [TickerFunction(functionName: "Send Notifications", cronExpression: "0 * * * *")]
11    public async Task CreateReport(TickerFunctionContext tickerContext,
12        CancellationToken cancellationToken)
13    {
14        var report = new Report
15        {
16            Title = $"Scheduled Report - {DateTime.UtcNow:yyyy-MM-dd HH:mm}",
17            Content = $"This is an automatically generated report created at {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss}",
18            CreatedAt = DateTime.UtcNow
19        };
20
21        _dbContext.Reports.Add(report);
22        await _dbContext.SaveChangesAsync(cancellationToken);
23    }
24}

In this example, TickerQ will call the CreateReport method every hour.

The cronExpression parameter is optional and can be used to schedule recurring jobs based on a cron expression. If you omit it, you can either configure the schedule when registering TickerQ in the DI or specify it dynamically.

Dependency injection is supported out of the box, and you can specify as many job methods in a single class as you want.

Here, the TickerFunctionContext is used to access additional information about the job execution.

You can also use the context to cancel or delete the job:

csharp
1tickerContext.CancelTicker();
2
3await tickerContext.DeleteAsync();

You can also reference cron expressions from appsettings.json using %Section:Key% syntax:

csharp
1[TickerFunction(FunctionName: "ExampleMethod", CronExpression: "%CronTicker:EveryMinute%")]
2public void ExampleMethod() { }

json
1{
2  "CronTicker": {
3    "EveryMinute": "* * * * *"
4  }
5}

Step 4: Handling Exceptions (optional)

To handle exceptions, you can implement the ITickerExceptionHandler interface and register it in the DI:

csharp
1public class TickerExceptionHandler : ITickerExceptionHandler
2{
3    public async Task HandleExceptionAsync(Exception exception,
4        Guid tickerId, TickerType tickerType)
5    {
6        // your logic...
7    }
8
9    public async Task HandleCanceledExceptionAsync(Exception exception,
10        Guid tickerId, TickerType tickerType)
11    {
12        // your logic...
13    }
14}

csharp
1services.AddTicker(opt =>
2{
3  opt.SetExceptionHandler<TickerExceptionHandler>(); 
4});

Now let's explore how to integrate TickerQ with EF Core.

To make TickerQ production‑ready, especially in cases where your app may be restarted or scaled across instances, you'll want persistence.

EF Core provides TickerQ with a relational store for job state, history, locking, and recovery.

First, install the EF Core extension for TickerQ:

bash
1dotnet add package TickerQ.EntityFrameworkCore

In your service registration, enable EF Core features when calling AddTickerQ(...). For example:

csharp
1services.AddTickerQ(options =>
2{
3    // Set a fallback timeout to check for missed jobs and execute.
4    options.UpdateMissedJobCheckDelay(TimeSpan.FromSeconds(10));
5
6    options.SetInstanceIdentifier("TickerQ");
7
8    // Configure the EF Core–backed operational store for TickerQ metadata, locks, and state.
9    options.AddOperationalStore<ReportDbContext>(efCoreOptions =>
10    {
11        // Apply custom model configuration only during EF Core migrations
12        // (design-time). The runtime model remains unaffected.
13        // efCoreOptions.UseModelCustomizerForMigrations();
14
15        // On app start, cancel tickers left in Expired or InProgress (terminated) states
16        // to prevent duplicate re-execution after crashes or abrupt shutdowns.
17        efCoreOptions.CancelMissedTickersOnAppStart();
18
19        // Defined cron-based functions are auto-seeded in the database by default.
20        // Example: [TickerFunction(..., "*/5 * * * *")]
21        // Use this to ignore them and keep seeds runtime-only.
22        efCoreOptions.IgnoreSeedMemoryCronTickers();
23    });
24});

TickerQ uses EF Core to define its own internal tables/entities.

You have two options:

1. Use built‑in model customization for migrations

If you call UseModelCustomizerForMigrations(), the TickerQ entity configurations are applied automatically during migrations. This keeps things clean.

2. Manual configuration in the DbContext

If you don't use the model customizer, you need to apply the entity configurations in OnModelCreating explicitly, e.g.:

csharp
1public class ReportDbContext : DbContext
2{
3    public ReportDbContext(DbContextOptions<ReportDbContext> options)
4        : base(options) { }
5
6    public DbSet<Report> Reports { get; set; } = null!;
7
8    protected override void OnModelCreating(ModelBuilder modelBuilder)
9    {
10        base.OnModelCreating(modelBuilder);
11
12        modelBuilder.HasDefaultSchema(DbConsts.SchemaName);
13
14        // Adds TickerQ schema to EntityFrameworkCore
15        modelBuilder.ApplyConfiguration(new TimeTickerConfigurations(schema: DbConsts.SchemaName));
16        modelBuilder.ApplyConfiguration(new CronTickerConfigurations(schema: DbConsts.SchemaName));
17        modelBuilder.ApplyConfiguration(new CronTickerOccurrenceConfigurations(schema: DbConsts.SchemaName));
18
19        // ...
20    }
21}

After setup, create your EF migration as usual with the EF Core CLI command:

bash
1dotnet ef migrations add InitialMigration -c ReportDbContext

Here is what the database schema looks like with TickerQ tables:

Here is how you can seed initial tickers (time-based and cron-based):

csharp
1efCoreOptions.UseTickerSeeder(
2    async timeTicker =>
3    {
4        await timeTicker.AddAsync(new TimeTicker
5        {
6            Id = Guid.NewGuid(),
7            Function = "Create Report",
8            ExecutionTime = DateTime.UtcNow.AddSeconds(5)
9        });
10    },
11    async cronTicker =>
12    {
13        await cronTicker.AddAsync(new CronTicker
14        {
15            Id = Guid.NewGuid(),
16            Expression = "0 0 * * *", // every day at 00:00 UTC
17            Function = "Create Report"
18        });
19    }
20);

You can use the TimeTicker to schedule a job to be executed at a specific time.

TickerQ supports both one‑time / delayed jobs (called TimeTickers) and recurring or cron‑based jobs (called CronTickers).

You can schedule jobs dynamically via API endpoints or within the app startup, with retry policies, custom intervals, and more.

Suppose you have an API endpoint where a user requests sending a notification at a future date/time.

You can use the ITimeTickerManager<TimeTicker> to schedule such a job:

csharp
1public record NotificationJobContext(string Title, string Content);
2
3app.MapPost("/api/schedule‑notification", async (NotificationRequest request, 
4    ITimeTickerManager<TimeTicker> timeTickerManager) =>
5{
6    if (request.ScheduledTime <= DateTime.Now)
7    {
8        return Results.BadRequest("Scheduled time must be in the future");
9    }
10
11    // Create the typed job data.
12    var jobData = new NotificationJobContext(request.Title, request.Content);
13
14    // Schedule the job.
15    var result = await timeTickerManager.AddAsync(new TimeTicker
16    {
17        Function = "Send Notifications",
18        ExecutionTime = request.ScheduledTime.ToUniversalTime(),
19        Request = TickerHelper.CreateTickerRequest(jobData),
20        Retries = 3,
21        RetryIntervals = new[] { 30, 60, 120 } // Retry after 30s, 60s, then 2 min
22    });
23
24    return Results.Ok(new
25    {
26        JobId = result.Result.Id,
27        Message = $"Notification '{request.Title}' scheduled for {request.ScheduledTime}"
28    });
29});

Here I pass the NotificationJobContext to the job and I can extract it in the job method:

csharp
1public class NotificationJob
2{
3    private readonly ILogger<NotificationJob> _logger;
4    public const string TitleKey = "Title";
5    public const string ContentKey = "Content";
6
7    public NotificationJob(ILogger<NotificationJob> logger)
8    {
9        _logger = logger;
10    }
11
12    [TickerFunction(functionName: "Send Notifications", cronExpression: "0 0 * * *" )]
13    public Task Execute(TickerFunctionContext<NotificationJobContext> tickerContext,
14        CancellationToken cancellationToken)
15    {
16        var title = tickerContext.Request.Title;
17        var content = tickerContext.Request.Content;
18
19        // ...
20
21        return Task.CompletedTask;
22    }
23}

Alternatively, you can use the ICronTickerManager<CronTicker> to schedule a recurring job:

csharp
1var result = await cronTickerManager.AddAsync(new CronTicker
2{
3    Function = "Send Notifications",
4    Request = TickerHelper.CreateTickerRequest(jobData),
5    Expression = "* * * * *",
6    Retries = 3,
7    RetryIntervals = new[] { 30, 60, 120 } // Retry after 30s, 60s, then 2 min
8});

Here is how you can update and delete a CronTicker:

csharp
1// Update a CronTicker by ID
2// You get the ID when scheduling the job (result.Result.Id)
3await cronTickerManager.UpdateAsync(tickerId, ticker =>
4{
5    ticker.Description = "Updated cron description";
6    ticker.Expression = "*/10 * * * *"; // every 10 minutes
7});
8
9// Delete a CronTicker by ID
10await cronTickerManager.DeleteAsync(tickerId);

TickerQ has a built‑in, first‑party dashboard UI that gives you real‑time visibility and control over all your scheduled jobs (both time‑based and cron‑based).

It's useful for debugging, maintaining, and managing production workloads.

Add the TickerQ.Dashboard NuGet package to your project.

bash
1dotnet add package TickerQ.Dashboard

Register dashboard support when configuring TickerQ in DI:

csharp
1builder.Services.AddTickerQ(options =>
2{
3    // ...
4    
5    options.AddOperationalStore<ReportDbContext>(efCoreOptions =>
6    {
7        // ...
8    });
9    
10    options.AddDashboard(x =>
11    {
12        x.BasePath = "/tickerq-dashboard";
13        x.EnableBasicAuth = true;
14    });
15});

You can also configure authentication for the dashboard UI; see the documentation for more details.

TickerQ supports Basic Authentication out of the box for the dashboard UI. You can configure credentials in your appsettings.json:

csharp
1"TickerQBasicAuth": {
2  "Username": "admin",
3  "Password": "admin"
4}

To access the dashboard, navigate to https://localhost:5001/tickerq-dashboard in your browser (whatever your port is).

Enter admin/admin to log in:

TickerQ is a modern, lightweight, and production-ready scheduling library for .NET applications — offering a refreshing alternative to Hangfire and Quartz.NET.

You can see how much more code Quartz requires when compared to TickerQ in this blog post.

Here is the full comparison table of TickerQ vs. Quartz vs. Hangfire:

You can find the image source - here.

Hope you find this newsletter useful. See you next time.