Ruby on Rails Interview Questions and Answers for 2026

Callbacks are commonly used within an object’s life cycle at certain moments, such as after a state change. While using callbacks, you can write codes while creating, saving, updating, deleting, loading, or validating the active record object from the database.

It will give you greater control of data and the applications using it. It changes the usual flow of the code, resulting in complicated debugging and test-making. 

There are three types of callbacks.  

• before_create – these run before the stated object. 
• after_create – these run after the stated object. 
• around_create – allows you to have code before and after the original action, where you decide when the original action gets done.

For using a callback, we need to “register” it at the top of your Model using method  specifying the type, such as before_create. We can either pass that method a symbol that corresponds to the method name or write the callback as a block at once. 

For example 

class User < ActiveRecord::Base 
  before_create do |user| 
    puts "Creating #{user.name}" 
  end 
    after_create :Created 
    private 
  def just_created 
    puts "User Created." 
  end 
End 

In this example, we create a class linked with the database. We call the before_create to check some requirements. Then, call the after_create, which displays the message. 

The harness lets you view high-level application metrics collected from various sources and forward them to the collector. You can use any collector that can simply implement the Statsd interface. The harness takes the metrics from ActiveSupport::Notifications and forwards them to the collector.

The harness automatically assumes that the collector can do proper metric aggregation and statistics. For example, using the statsd will calculate the 70th percentile and averages.

You can use a harness specially for very high-traffic applications. Each metric is processed in a separate thread, where the main thread will do just sufficient work.

A symbol is mostly confused with variables, but both are different. Symbols are written like this: “:something,” preceded by a colon. Typical symbols do not contain spaces. So, if you want to create a symbol with multiple words, you need to use underscores, like so: :another_funny_symbol.

//add use cases// 

A Proc object encapsulates the code block you can store within a local variable, pass to a method or another Proc, and be called.  

For example 

square = Proc.new {|x| x**2 } 
square.call(3)  #=> 9 
# shorthands: 
square.(3)      #=> 9 
square[3]       #=> 9 

Proc objects are closures, meaning they can remember and use the entire context in which they were created. 

def gen_times(factor) 
  Proc.new {|n| n*factor } # remembers the value of factor now of creation 
end  
times3 = gen_times(3) 
times5 = gen_times(5) 
times3.call(12)               #=> 36 
times5.call(5)                #=> 25 
times3.call(times5.call(4))   #=> 60 

count() is an Array class method that returns the total number of elements present within the array. Count uses three different approaches.

Count all: do not require any parameter and will return a count of all the rows.

For example

Person.count # returns the total count of all people

Count using column: pass a column name to count and will return a count of all the rows for that column present.

For example-

Person.count(:age) # returns the total count of all people whose age is present in the database

Count using options will find the row count based on the options.

For example-

Person.count(:conditions => "age > 26") 
  Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN. 
  Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins. 
  Person.count('id', :conditions => "age > 26") # Performs a COUNT(id) 
  Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*') 

The size() is a method that is inbuilt into ruby. It returns the size of the set. Simply put, it will return the number of elements present in the set. 

For example- 

require "set"  
s1 = Set[11,2,3,4,5] 
# size method used 
puts s1.size() 

This question is a frequently asked question in Ruby on Rails interview questions. Ruby offers a mechanism for handling exceptions effectively. We need to enclose the code raising or throwing an exception in a begin/end block and use rescue clauses to tell Ruby the types of exceptions we want to handle.

Below is the syntax for exception handling in Ruby

Syntax

begin   
# -   
rescue OneTypeOfException   
# -   
rescue AnotherTypeOfException   
# -   
else   
# Other exceptions 
ensure 
# Always will be executed 
End 

The code within the begin/rescue block is protected. If any error occurs while executing this block, the control will pass to the block between the rescue and end.

For each rescue block, ruby will compare the raised exception for the match and parameters. If the exception name and the name in the rescue parameter are the same, then the block will execute, and the output will be displayed.

For example-

#!/usr/bin/ruby 
begin 
   file = open("/unexistant_file") 
   if file 
      puts "file is open" 
   end 
rescue 
      file = STDIN 
end 
print file, "==", STDIN, "\n" 

You will get below output-

#<IO:0xb7d16f84>==#<IO:0xb7d16f84> 

Initializers are class instance members that get called whenever a class’s object is created. We must use the name initialize for Initializer.

For example, for an Employee class, we must have an instance method by the name initialize.

Ruby supports two types of initializers.

Parameterless initializer 
Parameterized initializer 
For example- parameterless initializer 
class Employee 
    def initialize 
        @employeeId = 1 
        @employeeName = "sita" 
    end 
 
    def setEmployeeId(empId) 
        @employeeId = empId 
    end 
 
    def setEmployeeName(empName) 
        @employeeName = empName 
    end 
 
    def getEmployeeId 
        return @employeeId 
    end 
 
    def getEmployeeName 
        return @employeeName 
    end 
end 

We can use this initializer when we want to set some default values for employee objects. Now create employee object as shown below.

employee1 = Employee.new 
puts "Employee ID is #{employee1.getEmployeeId()}" 
puts "Employee Name is #{employee1.getEmployeeName()}" 

For example- parameterized initializer

class Employee 
    def initialize(empId, empName) 
        @employeeId   = empId 
        @employeeName = empName 
    end 
    def setEmployeeId(empId) 
        @employeeId = empId 
    end 
    def setEmployeeName(empName) 
        @employeeName = empName 
    end 
 
    def getEmployeeId 
        return @employeeId 
    end 
 
    def getEmployeeName 
        return @employeeName 
    end 
end 

We can use this initializer when we want to set values for employee attributes while creating the object. Here, we have a parameterized constructor for the Employee class accepting ID and name and assigning it to the Employee object.

Now, create an employee object with parameters as shown below.

employee1 = Employee.new(23, "abc") 
puts "Employee ID is #{employee1.getEmployeeId()}" 
puts "Employee Name is #{employee1.getEmployeeName()}" 

Functions are a combination of procedural statements that uses functions to execute specific code. For example, a function to perform addition need to declare two variables and add them. A function can return a value to the method that calls that function. If a function does not return a value to the caller, the value is None. 

For example- 

def add() 
a = 10 
b = 20 
return a + b 
end 
print add() 

Scaffolding refers to the auto-generation of a simple set of a model, views, and controllers, usually for a single table.

Two types of scaffolding are available in Ruby- static and dynamic.

Below is the basic difference between static and dynamic scaffolding.

These are PostgreSQL, DB2, MySQL, SQL, and SQLite.

No doubt, Ruby applications are highly scalable. The significant reasons are: horizontal scaling and is thread-safe. In other words, it will help your application handle more traffic by providing support for additional Ruby processes and adding additional servers.

The Rails console is a command line utility running the Rails applications from the command line, an extension of Ruby IRB. It offers all the facilities of IRB and the ability to auto-load the Rails application environment, including all its classes and components.

If you want to make your application ready for multiple databases, then you need to do that explicitly. Suppose we have an application with a single writer database, and we want to add a new one. Then you must make changes to the database.yml file.

Existing database.yml
production: 
  database: my_prim_database 
  adapter: mysql2 
  username: root 
  password: <%= ENV['ROOT_PASSWORD'] %> 

First, add a replica for the existing configuration, and a second database called pet and a replica for that. 

New database.yml

production: 
  primary: 
    database: my_prim_database 
    username: root 
    password: <%= ENV['ROOT_PASSWORD'] %> 
    adapter: mysql2 
  primary_replica: 
    database: my_prim_database 
    username: root_readonly 
    password: <%= ENV['ROOT_READONLY_PASSWORD'] %> 
    adapter: mysql2 
    replica: true 
  animals: 
    database: my_pet_database 
    username: pet_root 
    password: <%= ENV['PET_ROOT_PASSWORD'] %> 
    adapter: mysql2 
    migrations_paths: db/pet_migrate 
  animals_replica: 
    database: my_pet_database 
    username: pet_readonly 
    password: <%= ENV['PET_READONLY_PASSWORD'] %> 
    adapter: mysql2 
    replica: true 

Note 

• The the primary and primary_replica name should be the same containing the same data. 
• You should use different usernames for the writers and replicas. 
• The replica database should have readonly access. 
• For using the replica database, add a replica: true entry to the replica in the database.yml. 
• If you create a new writer database, set the migrations_paths to the directory where you store migrations for that database.

Rails::Engine lets you wrap a specific Rails application or a subset of functionality to share it with other applications or within a more extensive packaged application. Every Rails::Application is just an engine allowing simple features and application sharing. 

//Add code examples// 

It offers you a framework that compresses JavaScript and CSS assets. You can use it to write these assets in other languages and pre-processors such as CoffeeScript, Sass, and ERB. Using this, you can automatically combine your assets with assets from other gems.

You can implement the asset pipeline using the sprockets-rails gem enabled by default. To disable it while creating a new application, you must pass the --skip-asset-pipeline option.

One of the most frequently posed Ruby interview questions, be ready for it. The closure is a function or a code block with variables bound to the environment from which the closure is called. The closure is used as a variable that you can assign to another variable or pass to any function as an argument.

You can define a closure block in one scope and call it in a different scope.

Closure can recognize the variable available within its scope at the creation time and, while calling it, can access the variable even if they are not in the current scope.

Examples of closure in ruby are- Blocks, procs, and lambda.

Blocks are the simplest form of closure, a code piece enclosed between braces {} or do…end. 

You can pass more than one variable to the block. 

You can use a yield statement to call a block within a method with a value. 

It does not have a specific name. 

Below is the syntax for creating a block. 

block_name { #statements_to_be_executed } 
Using do…end 
block_name do  
   #statement-1   
   #statement-2   . 
End 

For example-

arr = [10, 11, 13, 41, 59] 
arr.each do | item | 
puts item 
End 

The forEach() method allows you to loop through each element of an array/object. The forEach() method takes a callback function as an argument invoked for each array element. It is like the for loop but without a return value.

The map() method loops through each element of an array/object. The map() method takes a callback function as an argument that is invoked for each array element. It is like the forEach() method but returns a new array.

Below is the syntax for the map. 

array = ["a", "b", "c"] 

array.map { |string| string.upcase } 

# ["A", "B", "C"] 

First, we will have an array. It could be a hash or range. Then we will call a map with a block. It will return a new array with the results. The result will not change, but you can use the map to change the original array. 

For example- 

Doubling the numbers of an array. 

array = [1,2,3] 

array.map { |n| n * 2 } 

# [2, 4, 6] 

Converting string to numbers. 

array = ["11", "21", "5"] 

array.map { |str| str.to_i } 

# [11, 21, 5] 

Indexing values with the “with_index” method. 

array = %w(a b c) 

array.map.with_index { |ch, idx| [ch, idx] } 

# [["a", 0], ["b", 1], ["c", 2]] 

Lambdas are procs that have distinguishing factors. They are considered the “regular” methods in two ways: they enforce the number of arguments that need to be passed when called, and they use "normal" returns.

When calling a lambda that expects an argument without one, or if you pass an argument to a lambda that does not expect it, an ArgumentError. Will be raised.

irb> lambda (a) { a }.call 
ArgumentError: wrong number of arguments (given 0, expected 1) 
        from (irb):8:in `block in irb_binding' 
        from (irb):8 
        from /Users/jeff/.asdf/installs/ruby/2.3.0/bin/irb:11:in `<main>' 

Also, for a lambda, the return keyword is same as it is for a method. When calling a proc, the program yields control of the code block. So, if the proc returns, the current scope returns. If a proc is called inside a function and calls return, the function immediately returns.

def return_from_proc 
  a = Proc.new { return 10 }.call 
  puts "not printed." 
end 

The above function will yield control to the proc, so when it returns, the function returns. Calling the function in this example will never print the output and return 10. So we use lambda.

def return_from_lambda 
  a = lambda { return 20 }.call 
  puts "The lambda returned #{a}, and this will be printed." 
End 

When using a lambda, it will be printed. Calling return in the lambda is like calling return in a method, so the “a” variable is populated with “20,” and the line is printed to the console.

With hashes, we can store data as key-value pairs. You can retrieve and modify data using the key. 

For example- 

countryCapitals = {} 
countryCapitals["India"] = "Delhi" 
countryCapitals["United States"] = "D.C." 
countryCapitals["United Kingdom"] = "London" 
puts "Count is = #{countryCapitals.length}" 
# Using Subscript to query the dictionary for a key and get the value. 
puts "Capital of India is = #{countryCapitals['India']}" 
# iterate the hash using each 
countryCapitals.each do |key, value| 
    puts "#{key} => #{value}" 
end  
#  if the hash contains NYC as a key. 
puts "ContainsKey - NYC?: #{countryCapitals.key?("NYC")}" 
# if the dictionary contains London as a value. 
puts "ContainsValue - D.C.?: #{countryCapitals.has_value?("London")}"
# remove an entry from the dictionary. 
countryCapitals.delete("India") 
# Print the hash 

puts countryCapitals

Computer systems are connected via networks. Two commonly used protocols in a network.

TCP - Transmission Control Protocol.

UDP - User Datagram Protocol.

Network protocol implementations for TCP come under the TCPSocket class. TCP protocol provides same-order communication, which is useful for other protocols like HTTP, SecureFTP, etc.

UDP on the other hand, sends independent datagrams. So there is no specific order in which data is received. UDP is connectionless.

A network computer is identified with two parameters.

IP Address

Port- 16-bit numbers that can range from 0 to 65,535.

Let us create a sample client-server program in Ruby to understand basic networking APIs.

Server-

require 'socket' 
cosmic_server = TCPServer.open(8080) 
loop { 
    cosmic_client = cosmic_server.accept 
    cosmic_client.puts "Hello There. I am Cosmic Server" 
    cosmic_client.close 
} 

Client-

require 'socket' 
cosmic_server = TCPServer.open('localhost', 8080) 
while data = cosmic_server.gets 
    puts data 
end 
cosmic_server.close 

The Client receives the message from the local IP address and port 8080.

Serialization is the process that writes an object's data to a stream. 

The inverse process of reading the stream into an object is called Deserialization. This concept is useful when you want to preserve and retrieve the object’s state later

• Serialization is implemented via a class called Marshal. The methods in Marshal that help with Serialization are- 
• Marshal.load- which Read data from the Input stream into an Object. 
• Marshal.dump-that Write data from the Object into the Output stream.  

For example- (serialization) 

class Employee 
    def initialize(empId, empName) 
        @empId = empId 
        @empName = empName 
    end 
 
    def get_empId 
        return @empId 
    end 
 
    def get_empName 
        return @empName 
    end 
end 
 
emp = Employee.new(1, "sita") 
seredObject = Marshal.dump(emp) 

The above example has created an Employee class. In this example, we have used the Marshal.dump to serialize the Employee to a binary object. 

For example- (deserialization) 

class Employee 
    def initialize(empId, empName) 
        @empId = empId 
        @empName = empName 
    end 
 
    def get_empId 
        return @empId 
    end 
 
    def get_empName 
        return @empName 
    end 
end 
 
emp = Employee.new(1, "sita") 
seredObject = Marshal.dump(emp) 
 
emp2 = Marshal.load(seredObject) 
puts "Employee ID = #{emp2.get_empId}" 
puts "Employee Name = #{emp2.get_empName}"

Ruby allows us to open a file using the File module in different modes- read mode, write mode, append mode, etc. we will explain this with an example of how we can open a file for reading.

For example- (reading)

newFile = File.new("C:/Desktop/new.txt", "r") 
while ( line = newFile.gets) 
    puts line 
end 
newFile.close() 

In the above example, we have opened the file and printing the output using “puts.”

For example- (writing).

newFile = File.new("C:/Desktop/godzilla2.txt", "w") 
newFile.write("hello") 
newFile.write("Hii") 
newFile.close() 

In the above example, after writing to the file, we have close it using the “close()” function.

Ruby allows us to create and work with threads with the concept of multithreading. It lets us create several threads, that run in parallel and share process CPU and memory. Multiple threads can share memory and communicate with each other. This can significantly speed up your program execution.

Suppose, we need to parse a large CSV file, for that, we can create as many worker threads to do it and speed up time. Also, if we want to run the task as a background operations in a User Interface program, we can create a background thread to do so.

For example- (creating a thread)

def run 
    puts "running thread" 
end 
t1 = Thread. new{run()} 
T1.join 

For example- (joining a thread)

def cosmicthread1 
    puts "hello?" 
    puts "working" 
end 
def cosmicthread2 
    puts "hello2" 
    puts "I = got it?" 
end 
def cosmicthread3 
    puts "Human Knowledge belongs to the World" 
    puts "Like Asprin" 
end 
cthread1 = Thread.new{cosmicthread1()} 
cthread2 = Thread.new{cosmicthread2()} 
cthread3 = Thread.new{cosmicthread3()} 
cthread1.join() 
cthread2.join() 
cthread3.join() 

Using I/O capabilities, we can provide input and get output from the program. Ruby provides API functions, such as gets and puts to work with console input and output.

For example- puts function.

str = "shortcut" 
puts str 
j = 10 
puts "The value of j is #{j}" 

For example- gets function

puts "enter name:- " 
name = gets 
puts "Hello #{name}" 

class Human

    def talk 
        puts "I’m talking" 
    end 
     private 
     def whisper 
          puts "I’m whispering" 
     end 
end 

What is the output of 

• h=Human.new.talk 
• k=Human.new.send(:talk) 
• l=Human.new.send(:whisper)

%i|select reject|.map { |m| array.partition(&odd?)}

• Get the value of key `:b`.
• Add to this hash the key:value pair `{e:5}`
• Remove all key:value pairs whose value is less than 3.5

• puts "Ruby Version: "+RUBY_VERSION
• puts "Ruby Patch Level: "+RUBY_PATCHLEVEL.to_s

• require 'date'
• current_time = DateTime.now
• cdt = current_time.strftime "%d/%m/%Y %H:%M"
• puts "Current Date and Time: "+cdt