Ruby On Rails
10 min

TL;DR: If your Rails app processes a few hundred jobs per minute with predictable workloads, Solid Queue is an excellent default. No Redis, no extra infrastructure, ships with Rails 8. But if you run sustained high-concurrency workloads with strict latency requirements, Sidekiq with Redis remains the faster, more observable, and more battle-tested choice. You can also run both in a hybrid setup.
Rails 8 made Solid Queue the default background job backend, and the community conversation shifted fast. Suddenly, every team running Sidekiq started asking: should we drop Redis entirely?
Short answer: it depends on your workload, and for a lot of production apps, removing Redis is the wrong move.
We use Sidekiq across most of our Rails projects at Essence Solusoft. It's battle-tested, the observability is excellent, and when Redis is already part of the stack for caching or Action Cable, adding Sidekiq costs almost nothing operationally. For new projects where the workload is moderate and simplicity matters more than raw speed, Solid Queue is a strong default.
This post compares both options across architecture, throughput, latency, error handling, and migration strategies so you can make the right call for your application.
How do Solid Queue and Sidekiq differ architecturally?
The core difference is where job data lives and how workers pick it up.
Solid Queue stores everything in your SQL database. Job records sit across several tables: ready executions, scheduled executions, claimed executions, and failed executions. A supervisor process manages workers and dispatchers. Workers poll the database at intervals to pick up jobs, using FOR UPDATE SKIP LOCKED to avoid contention when multiple workers compete for the same queue. It's straightforward, it requires no external services, and it works well within moderate load.
Sidekiq takes a fundamentally different approach. Jobs are serialized as JSON and pushed into Redis lists. Worker threads perform blocking pops on those lists, which means there's no polling delay. The moment a job hits the list, a waiting thread grabs it. Sidekiq's multi-threaded architecture lets each process run 10-25 threads, enabling massive parallelism.
The practical difference shows up in how a job moves from enqueue to completion. With Solid Queue, perform_later inserts a record into the database. A dispatcher checks the scheduled table and moves jobs to the ready state when they're due. A worker polls, claims the job, runs it, and deletes the execution record. Failures land in a dedicated table.
With Sidekiq, perform_later pushes directly to a Redis list. A thread does a blocking pop and executes immediately. Retries go back into a sorted set with backoff timestamps. Dead jobs move to a dead set after retries are exhausted.
Neither architecture is wrong. But they serve different workload profiles, and pretending they're interchangeable is where teams get into trouble.
How much faster is Sidekiq, and when does it matter?
Sidekiq processes jobs roughly 5x faster than Solid Queue in comparable scenarios. In raw numbers, Solid Queue handles up to about 1,000 jobs per minute while Sidekiq pushes past 2,000 under similar conditions. That gap widens under sustained load because Sidekiq's in-memory architecture doesn't compete with application queries for database resources.
Latency tells a sharper story. Solid Queue's workers poll the database at configured intervals, typically 100ms to 1 second. In practice, job pickup latency ranges from 100ms to 5 seconds depending on load and database responsiveness. Sidekiq's blocking pop on Redis delivers pickup in about 8 milliseconds. That's a different order of magnitude.
Does it matter? For nightly reports or weekly data cleanup, a few seconds of delay is irrelevant. Solid Queue handles these perfectly. But for payment webhooks, OTP emails, checkout flow PDF generation, and real-time notifications, users notice the difference. When a customer is staring at a checkout confirmation screen, the gap between 8ms and 3 seconds of job pickup latency is the gap between "that was fast" and "is it broken?"
Worth noting: GoodJob offers a middle ground. It uses PostgreSQL's LISTEN/NOTIFY for 50-200ms pickup latency, which is 10-25x faster than Solid Queue while still avoiding Redis. If you're committed to a database-backed approach but need better latency, it's worth evaluating.

What happens to your database when it runs both app queries and job processing?
This is the trade-off most teams underestimate. When you use Solid Queue, your application database handles every insert, poll, claim, and state transition for background jobs on top of its normal workload. Every worker poll is a SELECT with locking. Every claimed job is an UPDATE. Every completion is a DELETE.
Under moderate volume, this is fine. Under heavy load, it creates real contention. If your database is already handling complex queries, reporting, or high-traffic API requests, adding queue operations to the same machine slows everything down. Your application queries get slower because job processing competes for the same connection pool and I/O bandwidth.
Sidekiq sidesteps this entirely. Queue operations hit Redis, not your SQL database. Your primary database stays focused on application data. This natural isolation is one of Sidekiq's most underappreciated advantages, and it's the main reason we keep it in place on apps that are already close to database capacity.
You can mitigate the database pressure by running Solid Queue on a separate database using Active Record's multiple database support. That gives you isolation without Redis. But it adds another database to manage, which brings its own operational overhead. For apps that don't have Redis today and run moderate job volumes, the single-database setup works well. For apps already under database pressure, switching from Sidekiq to Solid Queue without capacity planning is usually the wrong call.
How do failed jobs and monitoring compare?
Solid Queue relies on Active Job's built-in retry mechanism: retry_on and discard_on declarations in your job classes. Failed jobs land in a database table with error details. Inspecting and re-enqueueing them means querying the database directly or installing Mission Control Jobs for a UI. There's no built-in exponential backoff or dead set beyond what Active Job provides.
Sidekiq ships with 25 retries and exponential backoff by default. A dead set catches jobs that exhaust all attempts. Each failure records the error type, backtrace, and retry count. The web dashboard mounts in your routes and gives you live queue depth, retry counts, processed vs failed counters, and filtering by queue or job class. You see problems at a glance.
That observability gap is real. Without a mature dashboard, teams don't realize when jobs are blocked, latency has crept up, or a specific queue is backing up. Mission Control is improving, but it doesn't match Sidekiq's long-standing web UI in depth or polish.
Regardless of which backend you use, every job class should declare explicit retry policies rather than relying on defaults. We build a consistent ApplicationJob hierarchy with structured error classes, integrate with error tracking services like Sentry, and map Active Record errors to specific retry or discard decisions. That discipline matters more than which queue system runs underneath.
What about recurring tasks and transactional safety?
Solid Queue has a clear advantage for recurring tasks. It supports cron-like scheduling natively through a config/recurring.yml file. A scheduler process reads this config and enqueues jobs at scheduled times. No external cron, no additional gems. If your app needs a handful of nightly imports or hourly syncs, this is genuinely simpler than managing scheduling outside Sidekiq.
Sidekiq handles recurring work through external mechanisms: system-level cron triggering rake tasks, or scheduler libraries that push jobs at the right times. It works, but the scheduling logic lives outside the application.
Transactional integrity is another area where Solid Queue has a real edge. The classic problem: you save a record and enqueue a job to process it. If the job enqueues but the transaction rolls back, you have a ghost job processing data that doesn't exist. If the transaction commits but the enqueue fails, you have data with no job.
When Solid Queue uses the same database as your app, you can enqueue jobs inside the same transaction as business data. Both commit or both roll back. That eliminates an entire class of bugs.
With Sidekiq, the enqueue is a separate network call to Redis, outside the database transaction. Rails 8 introduced enqueue_after_transaction_commit to mitigate this, which defers the enqueue until the wrapping transaction commits. It works with both backends and is worth enabling regardless of which system you use.
When should you pick one over the other?
Pick Solid Queue when your app processes fewer than 1,000 jobs per minute, you don't have strict sub-second latency requirements, Redis isn't already in your stack, your database has headroom for additional load, and you prefer Rails-native defaults. Early-stage SaaS products, internal tools, and admin applications fit this profile well.
Keep Sidekiq when you're sustaining over 1,000 jobs per minute, you need near-real-time processing for user-facing features, Redis is already running for caching or Action Cable, you need deep observability and real-time dashboards, or you're running data-heavy pipelines where speed compounds over hours.
Run both when your workload has two distinct profiles. Rails lets you set different Active Job adapters per job class. You can default to Solid Queue for housekeeping, emails, and low-priority delayed work while routing payment webhooks, billing reconciliation, and high-volume data exports through Sidekiq.
The operational overhead of running both is real. You manage Redis and queue database tables, monitor two backends, and maintain separate configs. But when the flexibility justifies the complexity, it prevents having to choose a single system that compromises on either simplicity or performance.
One principle we follow across all our Rails development work: keep your job classes on Active Job's abstraction layer unless you need a Sidekiq-specific feature that justifies the coupling. perform_later instead of perform_async. ApplicationJob instead of include Sidekiq::Job. That discipline keeps the backend decision reversible, which matters more than most teams realize until the day they need to switch.

Need help with your background job architecture?
If you're evaluating whether to stick with Sidekiq, migrate to Solid Queue, or run a hybrid setup, the decision should be based on data, not hype. Our team audits current workloads by measuring job volume per queue, analyzing failure patterns, reviewing database utilization, and profiling execution times.
Whether you need performance optimization on an existing Sidekiq deployment, a clean Solid Queue setup for a new Rails 8 app, or a phased migration between backends, we can help.
Start with your workload reality. The right queue system follows from there.
Frequently Asked Questions
Should I replace Sidekiq with Solid Queue in my existing Rails app?
Only if your job volume is moderate (under 1,000 per minute), you don't need sub-second pickup latency, and removing Redis genuinely simplifies your infrastructure. If Redis already runs for caching or Action Cable, removing it for background jobs saves nothing operationally.
Can I use Solid Queue and Sidekiq together?
Yes. Rails lets you set different Active Job adapters per job class. You can default to Solid Queue for most work and route latency-sensitive or high-volume jobs through Sidekiq. The overhead of managing both systems is real, but the flexibility can be worth it.
Does Solid Queue work with Rails 7?
Solid Queue requires Rails 7.1 and Ruby 3.2 at minimum. It became the default backend in Rails 8, but you can add it to a 7.1+ app by installing the gem and running the setup generator.
Will Solid Queue slow down my database?
It depends on volume. Under moderate load, the additional queries are negligible. Under heavy job processing, the polling, claiming, and state transitions compete with application queries for database resources. Running Solid Queue on a separate database mitigates this, but adds operational complexity.
How do I migrate from Sidekiq to Solid Queue safely?
Move one queue at a time. Switch the adapter for low-risk job classes first, monitor behavior in production, then gradually migrate the rest. Keep both systems running in parallel during the transition. Export Sidekiq's dead set before decommissioning it.

Written by
Ashok Damaniya
Chief Technical Officer (CTO)
Ashok Damaniya is the Chief Technology Officer at Essence Solusoft. He leads the technical team, guides architecture and development decisions, and helps deliver reliable, scalable software solutions.
Reader guide
Use the links below to jump into next reading without leaving the article flow.
Blog categories
Recent posts
Solid Queue vs Sidekiq: When Removing Redis From Rails Is the Wrong Decision
10 min
What We've Built: Essence Solusoft's Journey as a Ruby on Rails Development Company
10 min
AI Integration in Rails: Adding AI Features Without Rebuilding Your Application
7 min
Rails Performance Optimization: Why Your Application Gets Slower Under Load
8 min
Similar Blogs






