ruby 28 lines · 2 tabs

Optimistic locking for concurrent updates

Alex Kumar Jan 2026

2 tabs

class AddLockVersionToPosts < ActiveRecord::Migration[6.1]
  def change
    add_column :posts, :lock_version, :integer, default: 0, null: false
  end
end

module Api
  module V1
    class PostsController < BaseController
      def update
        post = Post.find(params[:id])

        post.update!(post_params)
        render json: post, status: :ok
      rescue ActiveRecord::StaleObjectError
        render json: {
          error: 'CONFLICT',
          message: 'This post was modified by another user. Please refresh and try again.'
        }, status: :conflict
      end

      private

      def post_params
        params.require(:post).permit(:title, :body, :lock_version)
      end
    end
  end
end

2 files · ruby Explain with highlit

When multiple users can update the same record simultaneously, optimistic locking prevents lost updates by detecting conflicts. Rails provides built-in support via a lock_version integer column that increments on every update. If two users load the same record and both submit updates, the second update raises ActiveRecord::StaleObjectError because the lock_version has changed. This gives the application a chance to handle the conflict gracefully, perhaps by asking the user to review changes or merging updates. Optimistic locking works well for scenarios where conflicts are rare but the consequences of lost updates are serious. For high-contention scenarios, I switch to pessimistic locking with lock! to prevent concurrent access entirely.

Related snips

ruby

class CommentsController < ApplicationController
  before_action :set_post

  def create
    @comment = @post.comments.build(comment_params)

System test: asserting Turbo Stream responses

rails hotwire turbo

by codesnips 4 tabs

ruby

class Post < ApplicationRecord
  belongs_to :author, class_name: 'User'
  has_many :comments, dependent: :destroy

  scope :published, -> { where.not(published_at: nil).where('published_at <= ?', Time.current) }
  scope :draft, -> { where(published_at: nil) }

ActiveRecord scopes for reusable query logic

rails activerecord patterns

by Alex Kumar 1 tab

ruby

module Api
  module V1
    class UsersController < BaseController
      def show
        user = User.includes(:profile).find(params[:id])

ETags for conditional requests and caching

rails caching http-caching

by Alex Kumar 1 tab

ruby

class PostsController < ApplicationController
  def index
    @posts = Post.includes(:author)
                 .order(created_at: :desc)
                 .page(params[:page])
                 .per(10)

Turbo Frames: infinite scroll with lazy-loading frame

rails turbo hotwire

by codesnips 4 tabs

ruby

require "csv"

class PeopleCsvStream
  include Enumerable

  HEADERS = %w[id full_name email signed_up_at plan].freeze

Resilient CSV Export as a Streamed Response

rails performance streaming

by codesnips 3 tabs

erb

<form data-controller="query-sync" data-action="change->query-sync#apply">
  <select name="status" class="rounded border p-2">
    <option value="">Any</option>
    <option value="open">Open</option>
    <option value="closed">Closed</option>
  </select>

Filter UI that syncs query params via Stimulus (no front-end router)

rails hotwire stimulus

by Henry Kim 2 tabs

Share this code

Here's the card — post it anywhere.

Optimistic locking for concurrent updates — share card

Link copied