TickerQ: The Next-Generation Background Job Scheduler for .NET

Background task processing is one of the fundamental building blocks of modern software architecture.

Whether you're sending emails, generating reports, synchronizing data with third-party systems, clearing caches, processing payments, or executing scheduled maintenance tasks, background jobs allow your application to perform these operations efficiently without blocking user requests.

For years, libraries such as Hangfire and Quartz.NET have been the go-to solutions for .NET developers.

However, modern .NET development has evolved significantly. Technologies like Native AOT, Source Generators, Minimal APIs, Dependency Injection, OpenTelemetry, and cloud-native architectures have changed how applications are designed.

This is where TickerQ stands out.

TickerQ is a modern, high-performance background job scheduler built specifically for today's .NET ecosystem. Instead of relying heavily on reflection and runtime discovery, it embraces compile-time code generation and modern development practices to deliver a faster, safer, and more scalable scheduling platform.

What is TickerQ?

TickerQ is an open-source Background Job Scheduler designed for .NET applications.

It enables developers to schedule and execute background operations with minimal configuration while providing enterprise-grade capabilities.

With TickerQ you can:

• Execute one-time scheduled jobs
• Schedule recurring Cron jobs
• Process delayed tasks
• Manage distributed background workers
• Monitor execution history
• Retry failed jobs
• Build scalable cloud-native applications

One of its most unique features is its extensive use of Roslyn Source Generators.

Instead of discovering jobs through reflection at runtime, TickerQ generates the required infrastructure during compilation. This approach reduces startup overhead, improves runtime performance, and provides compile-time validation.

Why Another Job Scheduler?

The .NET ecosystem already contains mature scheduling libraries.

So why should developers consider TickerQ?

Because modern applications have different requirements than applications built ten years ago.

Today's software commonly relies on:

• Native AOT
• Minimal APIs
• Dependency Injection
• Source Generators
• Cloud-native deployments
• Distributed systems
• Kubernetes
• OpenTelemetry

Traditional schedulers were designed before many of these technologies became mainstream.

TickerQ was designed from the ground up with modern .NET development practices in mind.

Its architecture focuses on performance, maintainability, observability, and scalability rather than simply executing scheduled tasks.

Source Generator Architecture

Perhaps the most innovative aspect of TickerQ is its use of Source Generators.

Traditional job schedulers typically discover jobs using reflection.

While reflection is flexible, it also introduces:

• Runtime overhead
• Additional memory allocations
• Longer startup times
• Less compile-time safety

TickerQ avoids these limitations.

During compilation, it automatically generates the code necessary to register and execute jobs.

This provides several benefits:

• Faster application startup
• Reduced memory consumption
• Compile-time validation
• Better IDE support
• Native AOT compatibility
• Improved overall performance

This modern architecture aligns perfectly with Microsoft's current direction for high-performance .NET applications.

Flexible Scheduling Options

TickerQ supports multiple scheduling models depending on your application's needs.

One-Time Jobs

Sometimes a task should only execute once.

Examples include:

• Send an email after user registration
• Generate a PDF report tomorrow morning
• Schedule database cleanup
• Delay processing for a few minutes

These jobs execute exactly once at their scheduled time.

Delayed Jobs

Delayed execution is particularly useful when immediate processing isn't necessary.

Examples include:

• Execute after 5 minutes
• Execute after 30 minutes
• Execute after 24 hours

Delayed jobs improve responsiveness while keeping user-facing requests fast.

Cron Scheduling

Recurring jobs are another core feature.

Examples include:

• Every day at 02:00
• Every Monday morning
• Every hour
• Every 15 minutes
• Every month on the first day

Cron expressions provide precise scheduling for recurring business processes.

Typical use cases include:

• Backup operations
• Report generation
• Data synchronization
• Cache invalidation
• Notification services
• Billing systems

Dependency Injection Integration

TickerQ fully embraces Microsoft's Dependency Injection infrastructure.

Your scheduled jobs behave like any other registered service.

public class EmailJobs
{
    private readonly IEmailService _emailService;

    public EmailJobs(IEmailService emailService)
    {
        _emailService = emailService;
    }

    [TickerFunction("SendEmails")]
    public async Task Execute(
        TickerFunctionContext context,
        CancellationToken cancellationToken)
    {
        await _emailService.SendPendingEmails();
    }
}

There is no need to manually instantiate services or use service locators.

Constructor injection works exactly as expected.

This keeps your code clean, testable, and consistent with the rest of your application architecture.

Getting Started

Installing TickerQ is straightforward.

dotnet add package TickerQ

Register the required services.

builder.Services.AddTickerQ();

var app = builder.Build();

app.UseTickerQ();

Within just a few minutes, your application is ready to process scheduled background jobs.

Creating Your First Background Job

Creating a background job requires only a simple class.

public class MyJobs
{
    [TickerFunction("HelloWorld")]
    public async Task Execute(
        TickerFunctionContext context,
        CancellationToken cancellationToken)
    {
        Console.WriteLine("Hello TickerQ");
    }
}

Scheduling that job is equally simple.

await manager.AddAsync(new TimeTickerEntity
{
    Function = "HelloWorld",
    ExecutionTime = DateTime.UtcNow.AddMinutes(1)
});

This design makes the learning curve very gentle while still supporting advanced enterprise scenarios.

Entity Framework Core Integration

Most enterprise applications already use Entity Framework Core.

TickerQ integrates naturally into that ecosystem.

Job metadata such as:

• Execution history
• Retry attempts
• Current status
• Scheduled execution times
• Error information

can all be persisted inside your database.

Using EF Core also means your background infrastructure can share the same database and transactional behavior as the rest of your application.

This simplifies maintenance while improving reliability.

Real-Time Dashboard

Monitoring background jobs is just as important as executing them.

TickerQ includes a modern real-time dashboard that allows developers and administrators to observe everything happening inside the scheduler.

Typical dashboard features include:

• Running jobs
• Queued jobs
• Completed jobs
• Failed jobs
• Retry attempts
• Execution duration
• Job history
• Manual execution
• Live updates

The dashboard uses SignalR to provide real-time updates without requiring page refreshes.

This greatly improves operational visibility, especially in production environments.

Distributed Scheduling

Modern applications often run on multiple servers.

Without coordination, the same scheduled task could accidentally execute multiple times.

TickerQ addresses this challenge with distributed scheduling capabilities.

Its architecture includes support for:

• Distributed locks
• Redis integration
• Node coordination
• Dead-node cleanup
• Cluster-aware scheduling

These features help ensure scheduled jobs execute exactly where and when they should, even across multiple application instances.

This makes TickerQ an excellent choice for cloud-native and microservice-based systems.

OpenTelemetry Support

Observability has become a critical part of software development.

TickerQ integrates with OpenTelemetry, allowing background jobs to participate in your application's monitoring infrastructure.

This makes it possible to collect:

• Metrics
• Traces
• Performance information
• Execution timings
• Failure statistics

The collected telemetry can then be visualized using platforms such as:

• Grafana
• Prometheus
• Jaeger
• Azure Monitor
• OpenTelemetry Collector

This level of visibility makes diagnosing production issues significantly easier.

Performance-Oriented Design

Performance has clearly been a priority during TickerQ's design.

Several architectural decisions contribute to its efficiency:

• Source-generated registrations
• Reduced reflection
• Lower startup overhead
• Dependency Injection integration
• Optimized scheduling pipeline
• Native AOT compatibility

While every application's workload is different, these design choices help reduce runtime overhead compared to traditional reflection-heavy solutions.

Typical Use Cases

TickerQ is suitable for projects of all sizes.

Common scenarios include:

• SaaS platforms
• Enterprise ERP systems
• CRM applications
• E-commerce platforms
• Financial software
• Healthcare systems
• Inventory management
• Email automation
• Push notification services
• Data synchronization
• Scheduled reporting
• File processing
• Background cleanup jobs
• API integrations

Any application that performs work outside the request-response lifecycle can benefit from a dedicated background scheduler.

TickerQ vs Hangfire vs Quartz.NET

Hangfire and Quartz.NET remain excellent and battle-tested libraries.

However, TickerQ introduces several modern capabilities that make it particularly attractive for new .NET projects.

Some notable differences include:

• Source Generator architecture
• Reflection-free job registration
• Native AOT readiness
• Modern Dependency Injection support
• Real-time dashboard
• Distributed scheduling capabilities
• OpenTelemetry integration
• Cloud-native design philosophy

Rather than replacing existing schedulers in every situation, TickerQ offers an alternative built specifically for the latest generation of .NET applications.

Who Should Use TickerQ?

TickerQ is an excellent choice for developers who:

• Build modern .NET applications
• Prefer compile-time safety
• Need recurring scheduled tasks
• Require distributed execution
• Use Dependency Injection extensively
• Deploy applications to Kubernetes
• Need production monitoring
• Value high-performance infrastructure
• Want a scheduler designed for cloud-native environments

Whether you're building a startup SaaS platform or a large enterprise application, TickerQ provides a clean and scalable scheduling solution.

Final Thoughts

TickerQ is far more than just another Cron library.

It is a modern background processing platform that combines compile-time code generation, flexible scheduling, dependency injection, Entity Framework Core integration, distributed execution, observability, and real-time monitoring into a single cohesive solution.

Its focus on Source Generators, Native AOT compatibility, and cloud-native architecture makes it particularly well-suited for the future of .NET development.

If you're starting a new .NET project—or looking to modernize an existing one—TickerQ is definitely worth exploring.

As an open-source project, it also welcomes community contributions, making it an excellent opportunity for developers who want to participate in shaping the next generation of background processing for .NET.