Top 45 Ruby Interview Questions 2026

Last Updated: June 2026 | Level: Freshers to 3 Years Experience | Read Time: ~18 min

Ruby is elegant, expressive, and the foundation of Ruby on Rails, which powered the rapid growth of startups like GitHub, Shopify, and Basecamp. Candidates report that blocks/procs/lambdas, the Ruby object model, and ActiveRecord are the highest-frequency topics in Ruby developer interviews. This guide covers 45 questions from Ruby fundamentals to Rails conventions. Confirm current interview requirements on the official careers portal for the company you are targeting.

Pair with Python Interview Questions 2026 and Node.js Interview Questions 2026 for full-stack preparation.

---

Table of Contents

1. Ruby Basics (Q1-Q12)
2. Blocks, Procs, and Lambdas (Q13-Q22)
3. Modules, Mixins, and OOP (Q23-Q32)
4. Metaprogramming (Q33-Q38)
5. Rails and Ecosystem (Q39-Q45)
6. Mock Interview: 5 Questions
7. FAQ

---

Ruby Basics

Q1. What are the key characteristics of Ruby? Easy

• Everything is an object - even integers and nil
• Dynamic typing - type checked at runtime
• Flexible syntax - multiple ways to express the same thing
• Metaprogramming-friendly - code can inspect and modify itself
• Principle of Least Surprise - behavior matches programmer expectations
• Duck typing - if it responds to a method, use it

---

Q2. What is the difference between nil, false, and a blank string? Easy

nil.nil?    # true
false.nil?  # false
"".nil?     # false

# Truthiness: ONLY nil and false are falsy in Ruby
puts "truthy" if 0     # prints (0 is truthy!)
puts "truthy" if ""    # prints (empty string is truthy!)
puts "truthy" if []    # prints (empty array is truthy!)
puts "truthy" if nil   # does NOT print
puts "truthy" if false # does NOT print

This is different from JavaScript/Python where 0, "", and [] are falsy.

---

Q3. What is the difference between puts, print, and p? Easy

puts "hello"  # prints with newline, converts to string
puts [1, 2]   # prints each element on its own line
print "hello" # prints without newline
p "hello"     # prints inspect form: "hello" (with quotes)
p 42          # prints 42 (returns value, great for debugging)
p nil         # prints nil
pp object     # pretty prints complex objects

p is the preferred debugging tool - it shows the Ruby representation, not the human string.

---

Q4. What are symbols in Ruby? How do they differ from strings? Medium

# Symbol: immutable, unique, interned
:hello
:user_id
:"with spaces"

# Same symbol always same object
:hello.object_id == :hello.object_id  # true
"hello".object_id == "hello".object_id # false (different objects)

# Use cases
hash = { name: "Aditya", age: 25 }  # symbol keys (fast)
hash[:name]  # Aditya

# Convert
"hello".to_sym  # :hello
:hello.to_s     # "hello"

Symbols are faster hash keys (O(1) equality via object_id). Use symbols for identifiers, strings for user-facing data.

---

Q5. What are ranges in Ruby? Easy

(1..10)   # inclusive: 1 to 10
(1...10)  # exclusive: 1 to 9

(1..5).to_a   # [1, 2, 3, 4, 5]
(1..10).include?(7)  # true
('a'..'e').to_a      # ["a", "b", "c", "d", "e"]

# Ranges in case statements
age = 25
case age
when 0..12  then "child"
when 13..17 then "teen"
when 18..64 then "adult"
else "senior"
end

---

Q6. What are Ruby arrays? Key operations? Easy

arr = [1, 2, 3, 4, 5]

arr.first         # 1
arr.last          # 5
arr.first(2)      # [1, 2]
arr.last(2)       # [4, 5]
arr.length        # 5
arr.reverse       # [5, 4, 3, 2, 1]
arr.flatten       # flattens nested arrays
arr.compact       # removes nil values
arr.uniq          # removes duplicates
arr.sort          # ascending
arr.sort_by { |x| -x }  # descending
arr.each { |x| puts x }
arr.map { |x| x * 2 }   # [2, 4, 6, 8, 10]
arr.select { |x| x > 2 } # [3, 4, 5]
arr.reject { |x| x > 2 } # [1, 2]
arr.reduce(0) { |sum, x| sum + x }  # 15
arr.inject(:+)   # 15 (shorthand)
arr.any? { |x| x > 4 }  # true
arr.all? { |x| x > 0 }  # true
arr.none? { |x| x > 10 } # true
arr.count { |x| x.even? } # 2
arr.flat_map { |x| [x, x*2] }
arr.each_with_index { |val, idx| puts "#{idx}: #{val}" }
arr.zip([10, 20, 30])  # [[1,10],[2,20],[3,30]]

---

Q7. What are Ruby hashes? Easy

# Creation
hash = { name: "Aditya", age: 25 }
old_style = { :name => "Aditya" }  # old rocket syntax

# Access
hash[:name]         # "Aditya"
hash.fetch(:name)   # "Aditya" (raises KeyError if missing)
hash.fetch(:email, "[email protected]")  # default value

# Iteration
hash.each { |k, v| puts "#{k}: #{v}" }
hash.map { |k, v| [k, v.to_s] }.to_h
hash.select { |k, v| v.is_a?(String) }
hash.reject { |k, v| v.nil? }
hash.transform_values { |v| v.to_s }
hash.transform_keys { |k| k.to_s }
hash.merge({ city: "Delhi" })

# Useful methods
hash.key?(:name)     # true
hash.value?("Aditya") # true
hash.keys            # [:name, :age]
hash.values          # ["Aditya", 25]

---

Q8. What are conditional expressions in Ruby? Easy

# Standard if/elsif/else
if age >= 18
  "adult"
elsif age >= 13
  "teen"
else
  "child"
end

# Inline (postfix)
puts "adult" if age >= 18
puts "minor" unless age >= 18

# Ternary
label = age >= 18 ? "adult" : "minor"

# Case/when (no fall-through unlike C)
case status
when :active   then "Active"
when :inactive then "Inactive"
when nil       then "Not set"
end

---

Q9. What is ||= and &&=? Medium

# ||= : assign if nil or false
user ||= "Anonymous"
# equivalent to: user = user || "Anonymous"

# Common use: memoization
@config ||= load_config

# &&= : assign only if truthy
user &&= user.downcase
# equivalent to: user = user && user.downcase
# only downcases if user is not nil/false

---

Q10. What are frozen strings in Ruby? Medium

# String literals are mutable by default
str = "hello"
str << " world"  # modifies in place

# Freeze: make immutable
frozen = "hello".freeze
# frozen << " world"  # RuntimeError: can't modify frozen String

# Magic comment (freeze all string literals)
# frozen_string_literal: true

Frozen string literals improve performance (Ruby can intern them) and prevent accidental mutation. Enable in production code.

---

Q11. What is the safe navigation operator &.? Medium

user = nil
user&.name       # nil (no NoMethodError)
user&.address&.city  # nil

# Equivalent to
user && user.name

# Real use
current_user&.admin?  # nil if not logged in

---

Q12. Predict the output: Easy

a = [1, 2, 3]
b = a
b << 4
puts a.inspect

Output: [1, 2, 3, 4]

Explanation: Arrays are objects in Ruby. b = a copies the reference, not the array. b << 4 mutates the same object. Use b = a.dup for a shallow copy.

---

Blocks, Procs, and Lambdas

Q13. What is a block in Ruby? Easy

# Block: anonymous code attached to a method call
[1, 2, 3].each { |x| puts x }

# Multi-line block
[1, 2, 3].each do |x|
  puts x * 2
end

# yield: call the block from a method
def greet
  puts "before"
  yield if block_given?
  puts "after"
end

greet { puts "inside block" }
# before
# inside block
# after

---

Q14. What is a Proc? Medium

# Proc: a saved block (callable object)
square = Proc.new { |n| n * n }
double = proc { |n| n * 2 }  # shorthand

square.call(5)  # 25
square.(5)      # 25 (alternative)
square[5]       # 25 (alternative)

# Proc is lenient with arguments
no_arg = Proc.new { |x| x.to_s }
no_arg.call       # nil.to_s = "" (no error)
no_arg.call(1, 2) # 1.to_s, extra arg ignored

---

Q15. What is a Lambda? Medium

# Lambda: strict Proc (argument count enforced)
double = lambda { |n| n * 2 }
triple = ->(n) { n * 3 }  # arrow syntax (Ruby 1.9+)

double.call(5)   # 10
double.(5)       # 10
double[5]        # 10

# Lambda is strict about arguments
double.call(1, 2)  # ArgumentError (unlike Proc)

---

Q16. What is the difference between Proc and Lambda? Medium

Feature	Proc	Lambda
Argument handling	Lenient (extra ignored, missing = nil)	Strict (ArgumentError)
return behavior	Returns from enclosing method	Returns from lambda only
Type	Proc (lambda? false)	Proc (lambda? true)

def proc_return
  p = Proc.new { return "from proc" }
  p.call
  "from method"  # never reached!
end

def lambda_return
  l = -> { return "from lambda" }
  l.call
  "from method"  # reached
end

puts proc_return   # "from proc"
puts lambda_return # "from method"

---

Q17. What is method object? Medium

def double(n) = n * 2

m = method(:double)
m.call(5)  # 10

# Pass as block
[1, 2, 3].map(&method(:double))  # [2, 4, 6]

# Unbound method
unbound = String.instance_method(:upcase)
bound = unbound.bind("hello")
bound.call  # "HELLO"

---

Q18. What is the & operator with symbols? Medium

# &:symbol converts symbol to a Proc calling that method
["hello", "world"].map(&:upcase)   # ["HELLO", "WORLD"]
[1, nil, 2, nil, 3].compact        # [1, 2, 3]
[1, 2, 3, 4].select(&:even?)       # [2, 4]

# Equivalent to:
["hello", "world"].map { |s| s.upcase }

# Works because Symbol#to_proc creates a proc:
to_proc = :upcase.to_proc  # proc { |obj| obj.send(:upcase) }

---

Q19. What is closure behavior in Ruby? Medium

def make_counter
  count = 0
  increment = -> { count += 1; count }
  reset = -> { count = 0 }
  [increment, reset]
end

inc, reset = make_counter
puts inc.call  # 1
puts inc.call  # 2
puts inc.call  # 3
reset.call
puts inc.call  # 1 (reset worked)

Both lambdas close over the same count variable.

---

Q20. What is yield_self (also then)? Advanced

# Passes self into a block and returns the block's result
"hello"
  .then { |s| s.upcase }
  .then { |s| "#{s}!" }
  # => "HELLO!"

# Useful for conditional chains
user
  .then { |u| u.admin? ? u : nil }
  &.then { |u| send_admin_email(u) }

---

Q21. What is tap? Medium

# tap: passes self to block, returns self (for debugging chains)
[1, 2, 3]
  .tap { |a| puts "before: #{a}" }
  .map { |x| x * 2 }
  .tap { |a| puts "after: #{a}" }
  .select { |x| x > 4 }
# Output:
# before: [1, 2, 3]
# after: [2, 4, 6]
# => [6]

---

Q22. Predict the output: Medium

multiplier = 3
doubler = ->(n) { n * multiplier }
multiplier = 10
puts doubler.call(5)

Output: 50

Explanation: Lambda closes over the variable multiplier, not its value at creation time. When called, multiplier is 10, so 5 * 10 = 50.

---

Modules, Mixins, and OOP

Q23. What are modules in Ruby? Medium

# Namespace
module Animals
  class Dog
    def speak = "Woof"
  end
  class Cat
    def speak = "Meow"
  end
end

dog = Animals::Dog.new
dog.speak  # "Woof"

# Mixin
module Greetable
  def greet = "Hello, I am #{name}"
end

class Person
  include Greetable
  attr_reader :name
  def initialize(name) = @name = name
end

Person.new("Aditya").greet  # "Hello, I am Aditya"

---

Q24. What is the difference between include, extend, and prepend? Advanced

module M
  def hello = "Hello from M"
end

# include: adds as instance methods (at end of method lookup chain)
class A
  include M
end
A.new.hello  # works

# extend: adds as class methods
class B
  extend M
end
B.hello      # works (class method)

# prepend: inserts at FRONT of method lookup chain
class C
  prepend M
  def hello = "Hello from C"
end
C.new.hello  # "Hello from M" (M is checked first)

---

Q25. What is the Ruby method lookup chain (MRO)? Advanced

module A; def hello = "A"; end
module B; def hello = "B"; end

class Parent
  include A
  def hello = "Parent"
end

class Child < Parent
  include B
end

# Lookup order for Child.new.hello:
# Child -> B -> Parent -> A -> Object -> Kernel -> BasicObject
puts Child.ancestors.inspect
# [Child, B, Parent, A, Object, Kernel, BasicObject]
puts Child.new.hello  # "B" (first in lookup chain after Child)

---

Q26. What are attr_accessor, attr_reader, attr_writer? Easy

class User
  attr_reader :name      # getter only
  attr_writer :email     # setter only
  attr_accessor :age     # both getter and setter
  
  def initialize(name, email, age)
    @name = name
    @email = email
    @age = age
  end
end

u = User.new("Aditya", "[email protected]", 25)
u.name      # "Aditya"
u.age = 26  # setter
u.email = "[email protected]"  # setter
# u.email   # NoMethodError (no reader)

---

Q27. What is method visibility: public, protected, private? Medium

class Person
  def greet
    "Hello, #{secret_name}"  # can call private internally
  end
  
  protected
  def compare_age(other)
    age <=> other.age  # protected: accessible to instances of same class
  end
  
  private
  def secret_name
    "#{first_name} #{last_name}"
  end
end

Ruby's private differs from Java: you can call private methods on self implicitly, but not self.private_method explicitly (except in Ruby 2.7+ where self. on private is allowed).

---

Q28. What is the Comparable module? Medium

class Weight
  include Comparable
  attr_reader :value
  
  def initialize(value) = @value = value
  
  def <=>(other)
    value <=> other.value
  end
end

weights = [Weight.new(5), Weight.new(2), Weight.new(8)]
weights.sort         # [2, 5, 8] (uses <=>)
weights.min          # Weight(2)
weights.max          # Weight(8)
Weight.new(5) > Weight.new(3)  # true (from Comparable)
Weight.new(5).between?(Weight.new(1), Weight.new(10))  # true

---

Q29. What is Enumerable? Advanced

class NumberList
  include Enumerable
  
  def initialize(nums) = @nums = nums
  
  # Only required method: each
  def each(&block) = @nums.each(&block)
end

list = NumberList.new([3, 1, 4, 1, 5, 9])
list.sort          # [1, 1, 3, 4, 5, 9]
list.select(&:odd?) # [3, 1, 1, 5, 9]
list.map { |n| n * 2 }
list.min
list.max
list.sum
list.group_by { |n| n % 2 == 0 ? :even : :odd }

Implementing each gets you 50+ methods from Enumerable for free.

---

Q30. What is duck typing? Medium

# Duck typing: if it quacks like a duck, it's a duck
def process(io)
  io.write("processing...\n")  # works for File, StringIO, STDOUT
end

process(STDOUT)
process(File.open("log.txt", "w"))
process(StringIO.new)  # in-memory, great for testing

# No type checking needed - just check for the method
def serialize(obj)
  if obj.respond_to?(:to_json)
    obj.to_json
  else
    obj.to_s
  end
end

---

Q31. Predict the output: module include order. Advanced

module A
  def name = "A"
end
module B
  def name = "B"
end
class C
  include A
  include B
end

puts C.new.name
puts C.ancestors.inspect

Output:

B
[C, B, A, Object, Kernel, BasicObject]

Explanation: The last include is inserted just after the class itself in the lookup chain. B is included second so it appears before A in the ancestors list.

---

Q32. What is open class (monkey patching) in Ruby? Advanced

# You can reopen any class and add/modify methods
class String
  def palindrome?
    self == self.reverse
  end
  
  def word_count
    split.length
  end
end

"racecar".palindrome?    # true
"hello world".word_count # 2

Powerful but dangerous - changing core classes can break gems. Prefer refinements for scoped changes.

---

Metaprogramming

Q33. What is method_missing? Advanced

class DynamicProxy
  def initialize(target) = @target = target
  
  def method_missing(name, *args, &block)
    if @target.respond_to?(name)
      puts "Calling #{name} on target"
      @target.send(name, *args, &block)
    else
      super
    end
  end
  
  def respond_to_missing?(name, include_private = false)
    @target.respond_to?(name) || super
  end
end

Always override respond_to_missing? alongside method_missing for correct behavior.

---

Q34. What is define_method? Advanced

class Report
  ['pdf', 'csv', 'xlsx'].each do |format|
    define_method("export_#{format}") do
      "Exporting in #{format} format"
    end
  end
end

r = Report.new
r.export_pdf   # "Exporting in pdf format"
r.export_csv   # "Exporting in csv format"

---

Q35. What is send and public_send? Advanced

"hello".send(:upcase)  # "HELLO"
"hello".send(:upcase)  # can call private methods too

class Secret
  private
  def whisper = "shhh"
end

s = Secret.new
s.send(:whisper)        # "shhh" (bypasses private)
s.public_send(:whisper) # NoMethodError (respects private)

---

Q36. What are class_eval and instance_eval? Advanced

# class_eval: evaluate code in class context
String.class_eval do
  def shout
    upcase + "!!!"
  end
end
"hello".shout  # "HELLO!!!"

# instance_eval: evaluate in object's context
obj = Object.new
obj.instance_eval do
  @secret = 42
  def answer = @secret
end
obj.answer  # 42

---

Q37. What is attr_accessor really doing (implement it)? Advanced

# attr_accessor :name is equivalent to:
class Person
  def name
    @name
  end
  
  def name=(value)
    @name = value
  end
end

# Simplified implementation using define_method
def self.my_attr_accessor(*attrs)
  attrs.each do |attr|
    define_method(attr) { instance_variable_get("@#{attr}") }
    define_method("#{attr}=") { |val| instance_variable_set("@#{attr}", val) }
  end
end

---

Q38. What is Struct in Ruby? Medium

# Struct: auto-generates getter/setter/equality/to_s
Point = Struct.new(:x, :y)
p = Point.new(3, 4)
p.x       # 3
p.to_a    # [3, 4]
Point.new(3, 4) == Point.new(3, 4)  # true

# With custom methods
Point = Struct.new(:x, :y) do
  def distance_from_origin
    Math.sqrt(x**2 + y**2)
  end
end

Point.new(3, 4).distance_from_origin  # 5.0

---

Rails and Ecosystem

Q39. What is ActiveRecord? Medium

# Model
class User < ApplicationRecord
  has_many :posts
  belongs_to :team
  
  validates :email, presence: true, uniqueness: true
  validates :age, numericality: { greater_than: 0 }
  
  scope :active, -> { where(status: 'active') }
end

# Queries
User.all
User.find(1)
User.find_by(email: "[email protected]")
User.where(status: 'active').order(created_at: :desc).limit(10)
User.active.joins(:posts).group(:id).having('COUNT(posts.id) > 5')

---

Q40. What are Rails associations? Medium

class User < ApplicationRecord
  has_many :posts
  has_many :comments, through: :posts
  has_one :profile
  belongs_to :team
end

class Post < ApplicationRecord
  belongs_to :user
  has_many :comments
  has_and_belongs_to_many :tags
end

# Usage
user.posts              # all posts
user.posts.create(title: "Hello")
post.user               # the author
user.comments           # through association

---

Q41. What are Rails migrations? Medium

class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      t.string :name, null: false
      t.string :email, null: false, index: { unique: true }
      t.integer :age
      t.timestamps  # adds created_at and updated_at
    end
  end
end

rails db:migrate          # run pending migrations
rails db:rollback         # undo last migration
rails db:migrate:status   # show migration state

---

Q42. What is REST in Rails? Medium

# config/routes.rb
Rails.application.routes.draw do
  resources :users  # generates 7 RESTful routes
end

# Generated routes:
# GET    /users          -> users#index
# POST   /users          -> users#create
# GET    /users/:id      -> users#show
# PATCH  /users/:id      -> users#update
# DELETE /users/:id      -> users#destroy
# GET    /users/new      -> users#new
# GET    /users/:id/edit -> users#edit

---

Q43. What is Rails middleware? Advanced

# config/application.rb
config.middleware.use MyMiddleware
config.middleware.insert_before ActionDispatch::Static, LoggingMiddleware

# Custom middleware
class TimingMiddleware
  def initialize(app) = @app = app
  
  def call(env)
    start = Time.now
    status, headers, response = @app.call(env)
    duration = Time.now - start
    headers['X-Response-Time'] = "#{duration.round(3)}ms"
    [status, headers, response]
  end
end

---

Q44. What is the Asset Pipeline in Rails? Medium

# app/assets/stylesheets/application.css
# *= require_self
# *= require_tree .

# In views
<%= stylesheet_link_tag "application" %>
<%= javascript_include_tag "application" %>

# assets:precompile generates fingerprinted files
# /assets/application-a1b2c3d4e5.css

Rails 7 switched to import maps and propshaft as the default.

---

Q45. Predict the output: ActiveRecord lazy evaluation. Advanced

# What is the difference between these two?
users = User.where(active: true)
puts users.class

users2 = User.where(active: true).to_a
puts users2.class

Output:

ActiveRecord::Relation
Array

Explanation: ActiveRecord queries return a Relation object (lazy) - the SQL is not executed until you call .to_a, .each, .first, etc. This enables query chaining without multiple DB hits.

---

Mock Interview: 5 Questions

1. Implement memoize as a module that any class can include to cache method results.
2. Write a method using method_missing that enables dynamic finders like find_by_name_and_email.
3. What is the output of [1, [2, [3, [4]]]].flatten(1).inspect?
4. Explain the difference between map and each. When would you use inject?
5. Implement a simple event emitter class with on, off, and emit methods.

---

FAQ

Q: How does Ruby performance compare to Python or Go? A: Pure Ruby is slower than Go and roughly comparable to Python for CPU-bound tasks. Ruby 3.x with YJIT JIT compilation significantly improved performance. For I/O-bound web apps, Rails performance is adequate; for CPU-intensive work, use Go or a compiled extension.

Q: Should I learn Rails or Sinatra? A: Learn Rails for full-stack web development - it has the best job market, most gems, and the most production deployments. Learn Sinatra for lightweight APIs or when you need a minimal framework.

Q: What is Bundler and why does it matter? A: Bundler manages gem dependencies via a Gemfile. It ensures every developer and deployment environment uses identical gem versions, preventing "works on my machine" issues.

---

Related reading: Python Interview Questions 2026 | Node.js Interview Questions 2026 | SQL Interview Questions 2026 | Laravel Interview Questions 2026