Open Source Alternatives
  • Alternatives
  • Categories
    Categories by size1,283 projects
    • Developer Tools660
    • AI & Machine Learning543
    • Business & Productivity307
    • Web Development219
    • Security & Monitoring198
    • Communication & Collaboration168
    • IT Management164
    • Design & Creative142
    • LLMOps & AI Tooling140
    • DevOps & CI/CD137
    Browse all 21 categoriesCloud & Hosting, Product & Project Management and 9 more
  • Blog
  • Advertise
SearchNotion, Slack, password manager.../
Submit
Open Source Alternatives
  • Alternatives
    • Developer Tools660
    • AI & Machine Learning543
    • Business & Productivity307
    • Web Development219
    • Security & Monitoring198
    • Communication & Collaboration168
    • Browse all 21 categories
  • Blog
  • Advertise
Submit your project

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Open Source Alternatives LogoOpen Source Alternatives

Handpicked Open Source Alternatives to Paid Softwares

Add Open Source Alternatives as a preferred source on Google

Product

  • Categories
  • Tag
  • Advertise

Resources

  • Blog
  • Collection
  • Submit

Company

  • Privacy Policy
  • Terms of Service
  • Refund Policy
  • Sitemap

Alternatives

  • Claude Code
  • Jira
  • Notion
  • Slack
  • Linear
  • Wispr Flow
  • All alternatives
© 2026 Open Source Alternatives. All rights reserved.
Open SourceAlternatives
Home/Categories/Backend Development/Solid Queue
icon of Solid Queue

Solid Queue

Open source alternative to Sidekiq

  • 2.5K stars
  • MIT
  • Active this month
  • Last commit 13 days ago

Last verified Nov 17, 2026

Run background jobs in Rails using your existing SQL database, with no Redis required. MIT licensed and default in new Rails 8 applications.

Visit websiteGitHub2.5K starsDeploy on Hostinger
image of Solid Queue
TL;DR

Solid Queue is a database-backed Active Job backend for Ruby on Rails that queues and processes background jobs in your existing SQL database, without Redis. It replaces Sidekiq as the job backend for Rails teams who want fewer infrastructure dependencies, and ships as the default in Rails 8. MIT licensed, it includes concurrency controls, batch jobs, recurring tasks, and bulk enqueuing at no cost. Best for Rails developers running MySQL, PostgreSQL, or SQLite who want to consolidate job processing into their existing database stack.

Read the full breakdownHide the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ
who it's for

Who Solid Queue is for#

Rails teams starting with or upgrading to Rails 8

Solid Queue is the default Active Job backend for new Rails 8 applications, pre-configured out of the box. Teams upgrading from earlier Rails versions can add it in two commands and have background processing running in the same database they already manage.

Skip if:

Skip if your team has established Sidekiq operational experience and relies on Sidekiq-specific features like unique jobs that have no equivalent in Solid Queue.

Sidekiq users reducing Redis infrastructure costs

Teams paying for managed Redis hosting just for Sidekiq can eliminate that dependency by switching to Solid Queue. The migration path is incremental: set `self.queue_adapter = :solid_queue` on individual job classes and move one job at a time, leaving others on Sidekiq until the cutover is complete.

Skip if:

Skip if you depend on Sidekiq Pro or Enterprise features such as unique jobs, rate limiting, or Sidekiq's built-in web dashboard and do not want to add mission_control-jobs as a replacement.

SQLite-based single-server Rails deployments

Applications deployed to a single server using SQLite (common with Kamal-based setups) can use Solid Queue on the same SQLite database or a dedicated SQLite queue database. No Redis process is needed, keeping the production environment to a single Rails server run via the Puma plugin.

Skip if:

Skip if your workload will grow to require multiple job workers on separate machines; SQLite is not designed for high-concurrency writes from multiple processes.

the problem

The problem it solves#

Running background jobs in Rails has historically required Redis as a separate data store. Teams add Redis alongside their application database, then manage two persistence layers: keeping Redis available, monitoring its memory, and tuning its persistence settings adds operational work that grows with the application.

For SQLite-based deployments, single-server setups, or early-stage projects, a Redis dependency can complicate a production stack that otherwise needs only one database. Advanced features in Sidekiq, the established paid tool for Rails background jobs, also require a commercial Pro or Enterprise license, adding per-process cost that grows with application scale.

how Solid Queue solves it

How it solves it#

SQL-native queue storage, no Redis

Jobs are stored in SQL tables alongside application data, using MySQL, PostgreSQL, or SQLite. The `FOR UPDATE SKIP LOCKED` clause, available on MySQL 8+, MariaDB 10.6+, and PostgreSQL 9.5+, prevents lock contention when multiple workers poll the same queue. SQLite works for smaller deployments without that clause.

Concurrency controls per job class

Limit how many instances of a job run at the same time, or block certain jobs from running concurrently with each other. The dispatcher handles unblocking held jobs on a configurable maintenance interval, defaulting to 600 seconds. This replaces application-level mutex patterns for jobs that must not overlap.

Recurring tasks via config file

Define cron-like recurring tasks in `config/recurring.yml`. The scheduler process reads this file and enqueues jobs when they come due, handling the full Active Job lifecycle including retries. Dynamic scheduling, allowing recurring tasks to be created and modified at runtime, requires the optional scheduler configuration with `dynamic_tasks_enabled: true`.

Batch jobs with progress tracking

Group multiple related jobs into a batch and monitor collective progress or completion. Solid Queue includes batch support, batch progress counters, and maintenance for stalled batches. This functionality is included in the MIT license, while Sidekiq requires a Pro tier subscription for comparable batch features.

Horizontal scaling with multiple workers

Run `bin/jobs` on multiple machines to scale horizontally without coordination overhead. Each process runs its own supervisor, which forks workers and dispatchers according to the configuration. Workers can be assigned to specific queues or queue prefixes, and multiple worker processes can share a queue configuration using the `processes` count setting.

Bulk enqueuing via enqueue_all

Supports Active Job's `perform_all_later` via `enqueue_all`, which inserts multiple jobs in a single database operation. This is faster than enqueuing jobs one at a time in a loop when preparing large batches of work. Compatible with any Active Job subclass.

strengths · trade-offs

Strengths and trade-offs#

Strengths

  • MIT license covers all featuresEvery feature, including concurrency controls, batch jobs, recurring tasks, and bulk enqueuing, is available under the MIT license with no commercial tier. Sidekiq requires a Pro license for batches and unique jobs, or an Enterprise license for rate limiting. Solid Queue ships all of this at no cost.
  • Default in Rails 8, zero extra configNew Rails 8 applications include Solid Queue pre-configured as the Active Job backend. No gems to add, no generator to run; it is set up out of the box. Teams on Rails 7.1 or 7.2 can add it manually with two commands and a database.yml entry.
  • FOR UPDATE SKIP LOCKED prevents polling contentionOn MySQL 8+, MariaDB 10.6+, and PostgreSQL 9.5+, Solid Queue uses `FOR UPDATE SKIP LOCKED` to let workers move past rows already claimed by another process, rather than waiting on a lock. This allows multiple workers to poll the same queue concurrently without blocking each other at peak throughput.
  • Single or dedicated queue database optionsBy default, Solid Queue stores queues in a dedicated database, keeping queue I/O separate from application data. For small projects or SQLite deployments, the single-database configuration skips the second database entirely by migrating the queue schema into the main application database.

Trade-offs

  • -Dedicated queue database requires extra setupThe recommended configuration uses a separate database for queue tables, which requires adding entries to `config/database.yml` and running `db:prepare` to initialize the queue schema. This is a one-time setup step, but it adds complexity for teams new to Rails multiple-database configurations.
  • -No built-in web dashboardSolid Queue ships no dashboard for inspecting queues, retrying failed jobs, or discarding stale ones. The README recommends `mission_control-jobs`, a separate gem from the Rails organization, for a web UI. Teams migrating from Sidekiq Pro lose the built-in dashboard unless they add this extra dependency.
  • -SQL polling increases database query volumeWorkers poll the queue database on a configurable interval, defaulting to 0.1 seconds. High worker counts or short polling intervals on a shared database can generate meaningful query load. The recommended mitigation is a dedicated queue database, which also keeps queue I/O off the application's primary database.
versus alternatives

Solid Queue vs alternatives#

Solid Queue vs Sidekiq

Both tools handle Active Job background processing in Rails. Sidekiq requires Redis as a backing store; Solid Queue uses your existing SQL database. The decision largely comes down to whether adding Redis to your stack is acceptable.

FeatureSolid QueueSidekiq
LicenseMITProprietary (commercial tiers)
Backing storeMySQL, PostgreSQL, or SQLiteRedis
Concurrency controlsYes (included)Pro tier required
Recurring tasksYes (included)Enterprise tier required
Batch jobsYes (included)Pro tier required
Unique jobsNoPro tier
Rate limitingNoEnterprise tier
Web dashboardVia mission_control-jobsBuilt-in
Rails 8 defaultYesNo

Solid Queue is the better choice when you want to avoid Redis entirely, run a single-server deployment, or use SQLite. Teams on Rails 8 get it out of the box. The MIT license makes concurrency controls, batch jobs, and recurring tasks available without paying for a Sidekiq commercial tier.

Sidekiq is worth considering when you need unique jobs across all workers or rate limiting, features Solid Queue does not cover, or when Sidekiq's built-in web dashboard matters more than adding mission_control-jobs separately. For teams with established Redis infrastructure and deep Sidekiq operational experience, switching may add complexity rather than reduce it.

install · quick start

Quick start#

bash
Install Solid Queue as a Ruby gem for background job processing in Rails.
```bash
gem install solid_queue
```
tech stack · detected from GitHub

What it's built on#

Languages
Ruby
frequently asked

FAQ#

Does Solid Queue require Redis?

No. Solid Queue stores all job data in a SQL database, using MySQL, PostgreSQL, or SQLite. Redis is not required or used at any stage. This is the primary reason teams switch from Sidekiq: they can run job processing without maintaining a separate Redis instance.

Is Solid Queue included in Rails 8 by default?

Yes. Rails 8 includes Solid Queue as the default Active Job backend, pre-configured in new applications. For Rails 7.1 and 7.2, you can add it manually: run bundle add solid_queue and bin/rails solid_queue:install to generate the configuration files and queue database schema.

Can I migrate from Sidekiq to Solid Queue without downtime?

Yes, the migration can be done incrementally. Set self.queue_adapter = :solid_queue on individual job classes to move them one at a time, leaving other jobs on Sidekiq. Run both backends in parallel until all jobs are on Solid Queue, then remove Sidekiq and Redis. The README documents this incremental adoption path.

What SQL databases does Solid Queue support?

Solid Queue supports MySQL, PostgreSQL, and SQLite. The FOR UPDATE SKIP LOCKED clause, which prevents lock contention across multiple workers, is available on MySQL 8+, MariaDB 10.6+, and PostgreSQL 9.5+. SQLite works without that clause and is suitable for smaller deployments with a single worker process.

How does Solid Queue handle failed jobs?

Solid Queue relies on Active Job for retries, discarding, and error handling. Configure retry behavior using Active Job's standard retry_on and discard_on class-level macros in each job class. Failed jobs can be inspected and retried via the mission_control-jobs dashboard if installed, or programmatically via the job record.

also worth a look

Similar open-source tools#

Convex

Alternative toFirebase

Reactive backend with TypeScript functions and real-time sync

  • 12,794 GitHub stars
  • FSL-1.1-Apache-2.0Licence FSL-1.1-Apache-2.0

code-graph-rag

Alternative toAugment AI

AI-powered codebase analysis with knowledge graphs

  • 5,354 GitHub stars
  • MITLicence MIT

FerretDB

Alternative toMongoDB Atlas

Run MongoDB apps on PostgreSQL with no code changes needed

  • 11,112 GitHub stars
  • Apache-2.0Licence Apache-2.0

Frankfurter

Alternative toOpen Exchange Rates

Open source exchange rate API, 219 currencies, no key required

  • 2,104 GitHub stars
  • MITLicence MIT

Aspire

InDeveloper Tools

Code-first distributed app orchestration with built-in observability.

  • 6,426 GitHub stars
  • MITLicence MIT

Milvaion

Alternative toHangfire Pro

Distributed .NET job scheduler, decoupled workers, one dashboard.

  • 81 GitHub stars
  • Apache-2.0Licence Apache-2.0
by category

Open source tools in these categories#

89

Backend Development

dify, graphify, Rust
660

Developer Tools

REA (Reverse Engineer Anything), Skills for Real Engineers, superpowers
78

Databases & Storage

Immich, Supabase, Redis
Hostinger

Self-host Solid Queue on a Hostinger VPS

Keep it running 24/7, even when your laptop is off. A Hostinger VPS gives it a server of its own.

  1. 01

    Choose a plan

    Starts from $6.49/mo

  2. 02

    Apply

    Extra 10% off yearly plans

  3. 03

    Install Solid Queue

    On a server that stays on

  4. 04

    Start building

    Focus on the app, not the server

Deploy on Hostinger

Sponsors

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

  • 13,025 GitHub stars
  • AGPL-3.0Licence AGPL-3.0
  • #Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

  • 8,291 GitHub stars
  • Apache-2.0Licence Apache-2.0
  • #AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

/
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime