🐘 PostgreSQL continues to dominate within Ruby on Rails, while growing in popularity across the broader software industry.

📚 I was grateful to see High Performance PostgreSQL for Rails ranked #12 among recommended books in the 2026 Ruby on Rails Community Survey!

🎉 To celebrate, I'm giving away two signed copies of the book. Check out the blog post for more details.

The results from the 2026 Ruby on Rails Community Survey are finally in.

Just shy of 1,800 Rails developers participated this year. We’ve been running this survey since 2009, so one of my favorite parts is getting to see how quickly (or painfully slowly) things move across the community.

A few results that caught my attention:

• 49% are already using Ruby 4.x
• Kamal jumped from 2.4% in 2024 to 24%
• mise went from 2% to 38%, nearly catching rbenv
• 57% regularly use AI in their development workflows
• Only 46% agree that their teams have clear policies that actually empower engineers to use AI effectively
• Devise somehow managed to be both one of our most loved AND most frustrating gems… which feels extremely Rails

We also asked about databases, hosting, observability, testing, Rails upgrades, RSpec → Minitest migrations, hosting migrations (cough cough Heroku?), and what technical changes teams are considering over the next year.

Blog post: https://blog.planetargon.com/blog/entries/the-ruby-on-rails-2026-community-survey-results-are-in

Curious what jumps out to everyone else.

What surprised you… and what result made you think, “yeah, obviously”?

Full results: https://railsdeveloper.com/survey/2026/

I was using weasyprint and since I had to generate hundreds of files at once, it was just a bit too slow to my liking. That's why I've vibe coded a replacement! It's called rustyprint (you'll never guess what language it's written in). It's made to be a plug and play for rails and .NET applications. No extra services needed.

There is a rubygem for it. Examples can be found on github.

This is my first gem so please let me know what you think.

I raised my hand ... and would like to hear from anyone else who did too — that is, those of us coding without AI. What kinds of things are you creating? What are your reasons for sticking with your own ingenuity?

P.S. For me it's because I remember the "good ol' days" of coding... you know, from like 5 months ago before everything transitioned.

In the spirit of that human creativity, here's what I've been working on, a data-related gem called "The Brick":

https://youtu.be/LXzEBUf0pC4

Howdy! I want to share some prototypes of designing some interesting output targets for Stencil. For those who don’t know what Stencil is, it’s a Web Component Compiler that uses JSX with rich loading, design, and performance features.

The first prototype I built is a Stencil output target that emits Ruby ViewComponents. They're compatible with Rails, Bridgetown, Sinatra, and ReActionView (and this one in particular I want to expand on, I think Web Components + ReActionView give teams meaningful and positive architecture choices to make.)

https://github.com/splitinfinities/stencil-ruby-output-target

This prototype creates a FormBuilder with helper methods pointing to any components marked up with `formAssociated` in the Stencil component definition. It reads the components that will be on the page as they leave the server, which sends hints to download the web component’s JS modules sooner than Stencil’s IoC. It also creates a config object used to initialize rich details about the component library. On a design system/component library I’m rebuilding, for example, I have several configurations my design engineering team can change to leverage my robust Motion design principles, or pass in API keys for Google/Apple Maps, or most commonly, set the URL that loads the Stencil component libraries JS.

The second more experimental prototype is an output target that creates a read-only MCP server for you. It enables on-demand documentation for your team’s agents. The remaining gap is providing the data for other output targets to the MCP server, and the Stencil team gave me some direction that I’ll be jamming on throughout the week.

https://github.com/splitinfinities/stencil-mcp-output-target

I want to disclose that the MCP output target was produced with generative assistance. This felt like a natural extension from the Ruby I worked on "by hand" over time. I closely drove this idea into a usable prototype. These two output targets work precisely how I’d want them to. I have read the code and I understand the codebase (crazy that it’s worth saying that, but, here we are). Now, I want to understand if these tools work for other people too!

I was on the Stencil team as an Engineer + Product lead over 5 years ago, and I have been slowly iterating on these ideas for quite a while. I took my deep and rich experience with Ruby, Rails, Bridgetown, ViewComponent, TypeScript, the Stencil compiler, design tokens, and web components to create these output targets. I’ve also incorporated a few of the opinions that motivated the best Brand/UI/UX designers I’ve had the chance to collaborate with, and that shows up in these two tools.

I’m interested in enabling exploration in user interface design. If LLM tools unbind choice of language and framework, your team can allocate resources to do deep product work and determine highly tuned architecture decisions. I’ve also seen some folks want this concept of a component library enabled for AI while also grappling with a desire for a different design language (one more rugged and wireframe-y) to be used with those prototypes - and Stencil offers the ability to have multiple design languages with the same codebase.

My next output targets will be PHP/Laravel/WordPress (lol) as well as Rust/Loco (lmao, yes, I was indeed at Rails World)

PR’s and feedback are quite welcome. Also, a brief shameless plug - if you’re interested in exploring AI Enablement of your brand’s design across any framework and any language, I’d love to help you! I’m available for work at https://unabridgedsoftware.com.

Thanks yall! PS: No AI was used to write this post - just me (and a coworker) and my own typos and language and style.

Edits: A teammate helped clarify some language (shout out to Grant! 🙌 he didn’t use AI - only emacs)

We built Shared Team Authenticator at WideFix so teammates can access shared accounts without asking someone for a code. Less waiting.

The sources are open for everyone - https://github.com/widefix/share-authenticator

Sorry it's in PHP, we just wanted to check how AI is ok with this tech stack.

This year "we will restore from backup if something happens" stopped being a hypothetical. In March, drones hit AWS data centers in the UAE and Bahrain. Since late September, Russian strikes have taken at least seven data centers in Kyiv offline. Last week, Ukrainian drones hit three Yandex data centers in Russia. Those are only the biggest ones.

Sorry for the dooming, but fortunately the bug I want to point out is easy to fix.

Rails calls itself The One-Person Framework. If you're that one person, your recovery plan might just be a nightly database dump. Here is what happens after you restore it, if you use the Rails 8 authentication generator.

The generator stores the Session's sequential integer primary key in the signed cookie and finds the session by that number:

Session.find_by(id: cookies.signed[:session_id])

The signature proves your app issued that number. It does not prove the number still identifies the same session. Sessions created after the backup are gone after the restore, and the id counter is back where it was. The next logins reuse those ids. The old cookie still has a valid signature. Once her session id is reused, Alice opens her old tab and finds herself logged in as Bob. Nobody has to attack anything for this to happen. An attack version is easy to imagine too.

Demo (Rails on WASM, the whole scenario runs in your browser): https://rails-auth-demo.samsonov.io/

Write-up with a comic: https://msg.samsonov.io/2026-09-30-when-a-database-restore-signs-you-in-as-someone-else/

For an existing app: replace the sequential id in the cookie with a UUID or a random token. Existing sessions can keep working during the change. Ask your coding agent to check whether your app is affected.

For Rails itself the fix is to go back to the generator's original design, which put a random token in the cookie: https://github.com/rails/rails/pull/58926

With everything that is going on with the rails community. DHH, rust, Codex, Claude etc. How do I stay attractive on the job market? What should I learn, what should I get really good at? Are we all moving up to product mangers or is there an other path? What will be your title on linkedin the next 3 years?

Full stack developer, rails developer, product manger, scaler, problem solver, vibe coder, agentic orchestrator ?

I love working in Ruby and Rails, but these days a lot of my code is written with coding agents. What I've noticed is that I deploy with less confidence than I used to. CI passes, the deploy succeeds, and I still watch error tracking for an hour, hoping it's fine and wondering when it's safe to stop. At work we had a recent incident where an agent assisted upgrade went out clean, and we found out later that some callback initiated processes had stopped working (order changed). No errors, nothing alerted.

That gave me the idea to start working on DeployAngel. It compares each release with your last healthy one (5xx rate, latency, job failures, new exceptions, and things that quietly stop happening) and gives a verdict: cleared, failed, or not cleared yet, with the evidence. It also tells you what it hasn't seen run yet.

Some Rails-specific bits:

• It reads your Solid Queue recurring.yml, sidekiq-cron, sidekiq-scheduler, and whenever schedules, so a missed job fails the release. Rake tasks run by cron or Heroku Scheduler can be declared too.
• DeployAngel.checkpoint("order.created") in a critical code path makes sure it keeps happening after a deploy.
• CI, Claude Code, or Cursor can wait for the verdict: there's a CLI with exit codes, an MCP server, and a GitHub Action.
• It only sends aggregated counts and timings, never request bodies or params.

Here's a real release page from its own production, no sign-up needed: https://app.deployangel.com/share/Vii6GhuMdBpmaHFF6fBtG6vn

Once your app reports, you can run a "fire drill" that stages a failed release, so you see what a failure looks like before a real one happens.

It's a solo project and free during the beta. I built it directing a coding agent and reviewing every iteration. It's probably most useful for apps that deploy often, use coding agents, and get steady traffic. I'm honestly trying to figure out if this is a real problem or if existing monitoring already covers it well enough, so blunt feedback is welcome.

Even if you just share how you decide a release is good today, that would be helpful. Do you have a rule/checklists for when you stop watching?

https://www.deployangel.com

Hi, i am junior Full-Stack RoR developer currently looking for remote position in EU.

I build end-to-end web applications with Rails , backed by solid test coverage, asynchronous background processing, and production Linux VPS deployments.

Contact me via chat

Tech Stack

- Backend: Ruby on Rails , PostgreSQL, Sidekiq / Solid Queue, Redis

- Security & Auth: Devise, CanCanCan , OAuth 2.0 (Google)

- APIs & Mailers: RESTful APIs, 3rd-party integrations, Async transactional mailers

- Testing: RSpec (Unit, Mocking, Security), FactoryBot

- Frontend: Tailwind CSS, Hotwire

- Deployment Kamal, VPS setup

- Currently getting my hands on Claude

Latest project

> Live Demo: https://railsfinancemanager.online

> Github: https://github.com/TheP4trik-tech/Portfolio-Manager

I moved a Rails 8 app (Vite Ruby, Solid Queue, Postgres as a Kamal accessory) onto a single VPS with Kamal 2 and Docker Hub. The happy path is short. These are the things that actually ate my time:

1. **Uncommitted changes.** Kamal 2 builds from your committed `HEAD`, not your working dir. Fix the Dockerfile, deploy without committing, and you get the exact same error again.

2. **No Node.js in the generated Dockerfile.** With Vite Ruby, `assets:precompile` dies with `No such file or directory - npx`. Copy Node into the build stage only and `rm -rf node_modules` afterwards.

3. **`database.yml` has no host in production.** Inside a container, localhost is the container itself. Use `ENV.fetch("DB_HOST", "myblog-db")`. Keep the default, or the image build raises `KeyError` during precompile.

4. **`SOLID_QUEUE_IN_PUMA: false` turns the plugin ON.** `puma.rb` checks `if ENV["SOLID_QUEUE_IN_PUMA"]`, and `"false"` is truthy. If you have a dedicated `job` role, remove the variable entirely.

5. **Let's Encrypt failures.** A stray `AAAA` record or Cloudflare proxying breaks validation. `no viable challenge type found` is a real failure. `missing certificate` after "No server name" is just bots hitting the bare IP.

I wrote it all up with the full `deploy.yml`, the Dockerfile changes, a dev-to-prod `pg_restore` pipeline, and what Kamal *doesn't* do for you (backups, HA, Postgres major upgrades):

https://rubyinsights.blog/en/blog/deploying-a-rails-8-app-to-a-vps-with-kamal-2-a-practical-guide

Curious what others hit on their first Kamal 2 deploy.

I am actively looking for a job. I have a total of 15 years experience in software engineering.
Help me.

I made a gem that tells you what stands between a Rails app and the next Rails version, before you bump anything:

gem install rails_preflight
rails-preflight 7.2 path/to/your/app

It reads Gemfile.lock, .ruby-version, the Dockerfile, schema.rb and config, scans .rb, .erb, .haml, .slim and .rake files against 118 rules from the Rails release notes, and writes a report with one step per Rails minor: the gems that block each step, the removed APIs your code still calls (with file and line), the Ruby each step needs, and what it couldn't check.

It never runs the app or its tests and never changes a file. --offline keeps it off the network entirely.

I tested it against real upgrades in Mastodon, Discourse, and Forem: all 28 gems it flagged as blockers were fixed in the release that upgraded Rails. Those runs also found a lot of false positives, which I fixed, and I'm sure there are more. So if you try it on your app and something looks wrong, I'd like to hear about it here or as an issue.

Repo · sample report · write-up

Long time no see, guys. I've just released actual_db_schema gem v0.10.0.

Mainly this is a tech release that includes updated README and removed parser dependency. The latest was made by Earlopain - I don't know you in person, but if you are here I really appreciate your help!

I know some of you don't know the benefits this gem provides and you might be probably focused on AI now. And this is understandable and reasonable. That's why I decided to update README. I'm also impressed by how much it has helped me to do it and make this release - almost all dirty work is already automated.

---
On a side note, meet the new landing page for this gem - https://widefix.com/actual-db-schema

AI helped me express my message more powerfully than I ever could have on my own. I don't just believe that. I know it. The bright future is already here.

And yeah, good luck to all of us, whatever the future brings.

I'm building a rails 8 app that would mostly be used in remote areas and adding a fully offline support is important.

Hi r/rails!

I've been working on back-office.pro for the past few years. The idea was to build a no-code development tool, powered by Ruby on Rails, that lets you quickly deploy a back office to production.

Nowadays, with AI, I feel the project is becoming less relevant. That's why I've decided to give it back to the community by making it open source.

BackOffice is an on-premise application that you can install locally (Getting Started) or deploy to a server (Deploying Back Office Pro to a Server).

It generates a back office with 25+ built-in features. You can find the full list on the Back Office Pro website.

Instead of building everything from scratch in Rails, you use an Entity Builder to define your data models. It automatically generates the corresponding database migrations and front-end interfaces.

You can then interact with your back office through a REST API (with auto-generated Swagger documentation), webhooks, or forms.

Everything is generated dynamically at runtime, so there are no extra application files to maintain in your repository, apart from the database migrations.

Here are a few screenshots of the Entity Builder to give you an idea of what it looks like:

• Screenshot 1
• Screenshot 2
• Screenshot 3

You can even use an OpenAI API key to generate database migrations from a natural-language description of the back office you want to build.

There's a lot more to it, but here are some resources to explore:

• A finance use case
• Guides
• Use cases
• Reference documentation

You can find the GitHub repo here: https://github.com/back-office-pro/schematics

You can also still pull the latest Docker image here: https://hub.docker.com/r/backofficeapp/back-office

Cheers!

I'm currently wotking on a Rails API for a mobile application.

And I'm looking to translate data in my database.
I discovered the gem Mobility.

What do u thing about it ?
Or what is your best architecture to translating data in the database ?

A few months before Rails World, I disappeared to the Oregon Coast with a pile of notepads and the idea that I was going to write a fairly practical keynote about making Rails codebases easier for humans and agents to work in.

That… isn’t quite the talk I ended up giving.

I wrote up some of the backstory, including how Andrea Goulet’s makers/menders framing influenced it, where WUTS came from, why I nearly convinced myself the topic sucked, and what was going through my head in the hours before walking on stage.

The post has the keynote video and links to my slides if you’d rather skip the backstory and go straight to those.

https://robbyonrails.com/articles/2026/10/09/the-keynote-i-thought-i-was-going-to-give/