Top 45 Scala Interview Questions 2026

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

Scala combines object-oriented and functional programming on the JVM, making it the language of choice for Apache Spark, Akka, and data-intensive backend systems. Candidates report that functional collection operations, case classes, Option/Either, and pattern matching are the highest-frequency topics in Scala interviews.

Pair with Python Interview Questions 2026 and Java Interview Questions 2026 for comparison. Confirm current interview requirements on the official careers portal of the company you are targeting.

---

Table of Contents

1. Scala Basics (Q1-Q12)
2. Functional Programming (Q13-Q22)
3. Type System and Implicits (Q23-Q30)
4. Concurrency: Futures and Akka (Q31-Q38)
5. Scala with Spark (Q39-Q45)
6. Mock Interview: 5 Questions
7. FAQ

---

Scala Basics

Q1. What is Scala and what are its main features? Easy

Key features:

• Strong static type system with inference
• First-class functions and immutability by default
• Case classes for algebraic data types
• Pattern matching
• Implicits (given/using in Scala 3)
• Actor model via Akka
• Runs Apache Spark workloads

---

Q2. What is the difference between val, var, and def? Easy

val x = 42       // immutable value, computed once
var y = 0        // mutable variable
y += 1

def square(n: Int): Int = n * n  // method (computed every call)
lazy val z = heavyComputation()   // computed on first access, then cached

// Prefer val (immutability = safer concurrency)
val pi = 3.14159

---

Q3. What are case classes? Easy

case class User(name: String, age: Int, email: String)

val u1 = User("Aditya", 25, "[email protected]")
val u2 = u1.copy(age = 26)       // create modified copy

println(u1 == u2)                // false (structural equality)
println(u1.toString)             // User(Aditya,25,[email protected])

// Destructuring
val User(n, a, e) = u1
println(n)  // Aditya

---

Q4. What is pattern matching in Scala? Medium

sealed trait Shape
case class Circle(r: Double) extends Shape
case class Rectangle(w: Double, h: Double) extends Shape
case class Triangle(base: Double, height: Double) extends Shape

def area(shape: Shape): Double = shape match {
    case Circle(r)           => Math.PI * r * r
    case Rectangle(w, h)     => w * h
    case Triangle(b, h)      => 0.5 * b * h
}

// Guard conditions
def classify(n: Int): String = n match {
    case x if x < 0   => "negative"
    case 0             => "zero"
    case x if x % 2 == 0 => "positive even"
    case _             => "positive odd"
}

Pattern matching is exhaustive when using sealed - the compiler warns if a case is missing.

---

Q5. What is Option in Scala? Medium

def findUser(id: Int): Option[User] = {
    if (id > 0) Some(User("Aditya", 25, "[email protected]"))
    else None
}

// Pattern matching
findUser(1) match {
    case Some(user) => println(user.name)
    case None       => println("not found")
}

// Functional style
val name: String = findUser(1)
    .map(_.name)
    .getOrElse("Anonymous")

// flatMap for chained options
val city: Option[String] = findUser(1)
    .flatMap(_.address)
    .map(_.city)

---

Q6. What is Either in Scala? Medium

def parseAge(s: String): Either[String, Int] = {
    try Right(s.toInt)
    catch { case _: NumberFormatException => Left(s"'$s' is not a valid age") }
}

parseAge("25") match {
    case Right(age) => println(s"Valid age: $age")
    case Left(err)  => println(s"Error: $err")
}

// for-comprehension with Either
val result: Either[String, Int] = for {
    age    <- parseAge("25")
    score  <- parseAge("88")
} yield age + score

Either is right-biased in Scala 2.12+, enabling map/flatMap on the success case directly.

---

Q7. What are sealed traits? Medium

sealed trait Result[+T]
case class Success[T](value: T) extends Result[T]
case class Failure(error: String) extends Result[Nothing]
case object Loading extends Result[Nothing]

// Compiler enforces exhaustive matching
def handle(r: Result[Int]): Unit = r match {
    case Success(v)  => println(s"Value: $v")
    case Failure(e)  => println(s"Error: $e")
    case Loading     => println("Loading...")
    // No warning needed - sealed covers all cases
}

---

Q8. What are traits in Scala? Medium

trait Printable {
    def print(): Unit = println(toString)  // default implementation
}

trait Serializable {
    def serialize: String
}

class User(val name: String) extends Printable with Serializable {
    override def serialize: String = s"""{"name":"$name"}"""
}

Scala traits support concrete implementations (like Java 8 default methods) and can have fields. Multiple trait mixing is called mixin composition.

---

Q9. What is companion objects? Medium

class Circle(val radius: Double) {
    def area: Double = Circle.PI * radius * radius
}

object Circle {
    val PI = 3.14159  // "static" constant
    def apply(r: Double): Circle = new Circle(r)  // factory
    def unit: Circle = new Circle(1.0)
}

val c = Circle(5.0)  // calls apply, no `new` needed
Circle.unit

---

Q10. What is the difference between == and eq in Scala? Easy

val a = "hello"
val b = "hello"
val c = new String("hello")

a == b    // true (structural equality, calls equals())
a == c    // true (content equal)
a eq b    // true (same reference, JVM string pool)
a eq c    // false (different object)

// For case classes, == is structural
case class Point(x: Int, y: Int)
Point(1, 2) == Point(1, 2)  // true

---

Q11. What are for-comprehensions? Medium

// Desugars to flatMap/map/filter/foreach
val result = for {
    x <- List(1, 2, 3)
    y <- List(10, 20)
    if x + y > 12
} yield (x, y)
// List((2,20),(3,10),(3,20))

// With Option
val address: Option[String] = for {
    user    <- findUser(1)
    address <- user.getAddress()
    city    <- address.getCity()
} yield city

---

Q12. Predict the output: Easy

val nums = List(1, 2, 3, 4, 5)
val result = nums.filter(_ % 2 == 0).map(_ * _ ).sum
println(result)

Output: 20

Explanation: Filter keeps [2, 4]. Map squares each: [4, 16]. Sum: 20.

---

Functional Programming

Q13. What are higher-order functions in Scala? Medium

def applyTwice(f: Int => Int, x: Int): Int = f(f(x))

val double = (n: Int) => n * 2
val addTen = (n: Int) => n + 10

println(applyTwice(double, 3))   // 12 (3->6->12)
println(applyTwice(addTen, 5))   // 25 (5->15->25)

// Function composition
val doubleThenAddTen = addTen compose double  // double first, then addTen
val addTenThenDouble = addTen andThen double  // addTen first, then double

println(doubleThenAddTen(5))  // 20
println(addTenThenDouble(5))  // 30

---

Q14. What are currying and partial application? Advanced

// Currying: multi-arg function -> chain of single-arg functions
def add(a: Int)(b: Int): Int = a + b
val add5 = add(5)_   // partial application
println(add5(3))     // 8

// curry any function
def multiply(a: Int, b: Int): Int = a * b
val curriedMultiply = (multiply _).curried
val triple = curriedMultiply(3)
println(triple(7))   // 21

// Practical: filter with partial application
val isMultipleOf: Int => Int => Boolean = m => n => n % m == 0
val isEven = isMultipleOf(2)
println(List(1,2,3,4,5).filter(isEven)) // List(2,4)

---

Q15. What is immutability in Scala? Easy

// Immutable collections (default)
val list = List(1, 2, 3)
val newList = list :+ 4    // new list, original unchanged
val prepended = 0 :: list  // prepend

val map = Map("a" -> 1, "b" -> 2)
val updated = map + ("c" -> 3)  // new map

// Mutable when needed (explicit import)
import scala.collection.mutable
val mutableList = mutable.ListBuffer(1, 2, 3)
mutableList += 4  // modifies in place

---

Q16. What are tail-recursive functions? Advanced

import scala.annotation.tailrec

// Non-tail-recursive (stack overflow for large n)
def factBad(n: Int): Long = if (n <= 1) 1L else n * factBad(n - 1)

// Tail-recursive (compiler optimizes to loop)
def factorial(n: Int): Long = {
    @tailrec
    def loop(n: Int, acc: Long): Long =
        if (n <= 1) acc else loop(n - 1, n * acc)
    loop(n, 1L)
}

println(factorial(20))  // 2432902008176640000

@tailrec causes a compile error if the function is NOT tail-recursive, acting as a safety net.

---

Q17. What are type classes in Scala? Advanced

// Type class definition
trait JsonEncoder[A] {
    def encode(value: A): String
}

// Instances
implicit val intEncoder: JsonEncoder[Int] = (v: Int) => v.toString
implicit val stringEncoder: JsonEncoder[String] = (v: String) => s""""$v""""

// Type class usage
def toJson[A](value: A)(implicit encoder: JsonEncoder[A]): String =
    encoder.encode(value)

println(toJson(42))       // 42
println(toJson("hello"))  // "hello"

---

Q18. What is the Try monad? Medium

import scala.util.{Try, Success, Failure}

def readFile(path: String): Try[String] =
    Try(scala.io.Source.fromFile(path).mkString)

readFile("/etc/hostname") match {
    case Success(content) => println(content)
    case Failure(ex)      => println(s"Error: ${ex.getMessage}")
}

// Chaining
val result: Try[Int] = Try("123".toInt)
    .map(_ * 2)
    .flatMap(n => Try(100 / n))
    .recover { case _: ArithmeticException => 0 }

---

Q19. What are streams (LazyList in Scala 2.13+)? Advanced

// Infinite sequence, evaluated lazily
val naturals: LazyList[Int] = LazyList.from(1)
val evens = naturals.filter(_ % 2 == 0)
evens.take(5).toList  // List(2, 4, 6, 8, 10)

// Fibonacci as infinite stream
def fibs: LazyList[BigInt] = {
    def go(a: BigInt, b: BigInt): LazyList[BigInt] =
        a #:: go(b, a + b)
    go(0, 1)
}
fibs.take(10).toList  // List(0,1,1,2,3,5,8,13,21,34)

---

Q20. What are Scala collection transformations? Medium

val words = List("hello", "world", "scala", "is", "great")

words.map(_.length)                        // List(5,5,5,2,5)
words.filter(_.length > 3)                 // List(hello,world,scala,great)
words.groupBy(_.length)                    // Map(5->List(...), 2->List(is))
words.sortBy(_.length)                     // List(is,hello,world,scala,great)
words.flatMap(_.toList)                    // List of chars
words.foldLeft("")(_ + _)                  // "helloworldscalaisgreat"
words.zip(List(1,2,3,4,5))                // List((hello,1),(world,2),...)
words.sliding(2).toList                    // List(List(hello,world),...)
words.partition(_.length > 3)             // (List(long...), List(is))
words.span(_.length > 3)                   // split at first mismatch
words.collect { case w if w.startsWith("s") => w.toUpperCase }  // List(SCALA)

---

Q21. What is reduce vs fold? Medium

val nums = List(1, 2, 3, 4, 5)

// reduce: no initial value, fails on empty list
nums.reduce(_ + _)        // 15
nums.reduceLeft(_ - _)    // ((((1-2)-3)-4)-5) = -13
nums.reduceRight(_ - _)   // 1-(2-(3-(4-5))) = 3

// fold: with initial value, safe on empty
nums.foldLeft(0)(_ + _)   // 15
nums.foldLeft(1)(_ * _)   // 120 (product)
nums.foldLeft(List.empty[Int]) { (acc, n) => n :: acc }  // reversed

---

Q22. Predict the output: Medium

val result = (1 to 5)
    .view
    .map { n => println(s"mapping $n"); n * 2 }
    .filter { n => println(s"filtering $n"); n > 4 }
    .head
println(s"result: $result")

Output:

mapping 1
filtering 2
mapping 2
filtering 4
mapping 3
filtering 6
result: 6

Explanation: .view creates a lazy view. Operations are applied one element at a time (not the whole collection). .head stops after finding the first match (3*2=6 > 4).

---

Type System and Implicits

Q23. What are Scala's type variance annotations? Advanced

// Covariant (+T): if Dog <: Animal, then List[Dog] <: List[Animal]
sealed trait List[+T]
case class Cons[+T](head: T, tail: List[T]) extends List[T]

// Contravariant (-T): if Dog <: Animal, then Printer[Animal] <: Printer[Dog]
trait Printer[-T] {
    def print(value: T): Unit
}

// Invariant (T): exactly T, not subtype or supertype
class Array[T]  // Array[Dog] is NOT Array[Animal]

---

Q24. What are implicits (and given/using in Scala 3)? Advanced

// Scala 2 implicits
implicit val defaultTimeout: Int = 5000
def fetchData(url: String)(implicit timeout: Int): String = ???
fetchData("https://api.example.com")  // uses implicit timeout

// Scala 3: given/using
given defaultTimeout: Int = 5000
def fetchData(url: String)(using timeout: Int): String = ???

// Implicit conversion (use sparingly)
implicit def intToString(n: Int): String = n.toString
val s: String = 42  // implicitly converted

---

Q25. What is type inference in Scala? Easy

// Scala infers types from context
val x = 42          // Int
val y = 3.14        // Double
val s = "hello"     // String
val list = List(1, 2, 3)  // List[Int]

def add(a: Int, b: Int) = a + b  // return type inferred as Int

// But explicit types are better for public APIs
def add(a: Int, b: Int): Int = a + b  // clearer

---

Q26. What are abstract types and type aliases? Advanced

// Type alias
type Name = String
type Age = Int
type UserId = Long

val userName: Name = "Aditya"  // same as String, better documentation

// Abstract type
trait Container {
    type Item
    def get: Item
}

class StringContainer extends Container {
    type Item = String
    def get: String = "hello"
}

---

Q27. What are Scala 3 union and intersection types? Advanced

// Union types: A | B
def process(input: Int | String): String = input match {
    case n: Int    => s"Number: $n"
    case s: String => s"String: $s"
}

// Intersection types: A & B (type must satisfy both)
trait Named { def name: String }
trait Aged  { def age: Int }

def greet(person: Named & Aged): String =
    s"${person.name} is ${person.age} years old"

---

Q28. What is structural typing in Scala? Advanced

// Structural type: accepts any object with the right methods
def close(resource: { def close(): Unit }): Unit = resource.close()

class Connection { def close(): Unit = println("connection closed") }
class File       { def close(): Unit = println("file closed") }

close(new Connection())  // works
close(new File())        // works

Structural typing uses reflection at runtime - use sparingly for performance.

---

Q29. What are phantom types? Advanced

// Types used only at compile time, no runtime representation
sealed trait Locked
sealed trait Unlocked

case class Door[S](id: Int)

def unlock(door: Door[Locked]): Door[Unlocked] = Door(door.id)
def open(door: Door[Unlocked]): Unit = println("door opened")

val locked: Door[Locked] = Door(1)
val unlocked = unlock(locked)
open(unlocked)
// open(locked)  // compile error - cannot open a locked door

---

Q30. Predict the output: Medium

sealed trait Tree[+A]
case class Leaf[A](value: A) extends Tree[A]
case class Branch[A](left: Tree[A], right: Tree[A]) extends Tree[A]

def sum(t: Tree[Int]): Int = t match {
    case Leaf(v)      => v
    case Branch(l, r) => sum(l) + sum(r)
}

val tree = Branch(Branch(Leaf(1), Leaf(2)), Leaf(3))
println(sum(tree))

Output: 6

---

Concurrency

Q31. What is a Future in Scala? Medium

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global

val f: Future[Int] = Future {
    Thread.sleep(100)
    42
}

// Non-blocking: register callbacks
f.onComplete {
    case scala.util.Success(v) => println(s"Got: $v")
    case scala.util.Failure(e) => println(s"Failed: $e")
}

// map/flatMap/for-comprehension
val result: Future[Int] = for {
    a <- Future(10)
    b <- Future(20)
} yield a + b

---

Q32. What is Await.result? Medium

import scala.concurrent.Await
import scala.concurrent.duration._

val f = Future(complexComputation())
val result = Await.result(f, 10.seconds)  // blocks up to 10 seconds

Await.result blocks the current thread - use only at the application boundary (main), not in production service code.

---

Q33. What is Akka Actor model? Advanced

import akka.actor.{Actor, ActorSystem, Props}

case class Greet(name: String)
case object Done

class GreeterActor extends Actor {
    def receive: Receive = {
        case Greet(name) =>
            println(s"Hello, $name!")
            sender() ! Done
    }
}

val system = ActorSystem("demo")
val greeter = system.actorOf(Props[GreeterActor], "greeter")
greeter ! Greet("Aditya")

---

Q34. What is Promise in Scala? Advanced

import scala.concurrent.Promise

val promise = Promise[Int]()
val future = promise.future

// Complete from another thread
new Thread(() => {
    Thread.sleep(100)
    promise.success(42)
}).start()

future.foreach(println)  // 42

A Promise is the writable side of a Future. Use it to bridge callback-based APIs to Future.

---

Q35. What is backpressure and why does it matter? Advanced

import akka.stream.scaladsl._

Source(1 to 1000)
    .throttle(10, 1.second)  // produce at most 10/sec
    .map(_ * 2)
    .runWith(Sink.foreach(println))

---

Q36. What is ExecutionContext? Medium

// Global (OK for compute-bound work)
import scala.concurrent.ExecutionContext.Implicits.global

// Dedicated for blocking I/O
val ioEC = ExecutionContext.fromExecutorService(
    java.util.concurrent.Executors.newFixedThreadPool(10)
)

Future { blockingDatabaseCall() }(ioEC)

---

Q37. How do you avoid blocking in Futures? Advanced

// WRONG: blocks the thread pool
Future { Thread.sleep(1000); result }

// CORRECT: mark blocking code
import scala.concurrent.blocking
Future { blocking { Thread.sleep(1000) }; result }
// blocking {} tells ForkJoinPool to spawn extra threads to compensate

// BETTER: use dedicated blocking EC
Future { Thread.sleep(1000); result }(blockingEc)

---

Q38. Predict the output: Medium

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._

val f1 = Future { 1 + 1 }
val f2 = Future { 2 + 2 }

val combined = for {
    a <- f1
    b <- f2
} yield a + b

println(Await.result(combined, 1.second))

Output: 6

Explanation: f1 = 2, f2 = 4, combined = 2 + 4 = 6.

---

Scala with Spark

Q39. What is Apache Spark and why is Scala preferred for it? Medium

---

Q40. What is the difference between RDD, DataFrame, and Dataset? Medium

Feature	RDD	DataFrame	Dataset
Type safety	No	No	Yes (Scala/Java only)
Schema	No	Yes	Yes
Optimization	No catalyst	Catalyst optimizer	Catalyst optimizer
API	Functional	SQL-like	Type-safe + SQL
Performance	Base	Fast	Fast

// RDD
val rdd = sc.parallelize(List(1, 2, 3, 4, 5))
rdd.filter(_ > 2).map(_ * 2).collect()  // Array(6, 8, 10)

// DataFrame
val df = spark.read.json("users.json")
df.filter($"age" > 18).select("name", "age").show()

// Dataset: type-safe
case class User(name: String, age: Int)
val ds: Dataset[User] = df.as[User]
ds.filter(_.age > 18).map(_.name).collect()

---

Q41. What are Spark transformations vs actions? Medium

Transformations (lazy)	Actions (eager)
map, filter, flatMap	collect, count, take
groupBy, join	show, save, first
select, where	foreach, reduce

// Lazy chain
val result = df
    .filter($"active" === true)  // lazy
    .groupBy("department")       // lazy
    .agg(count("*").as("count")) // lazy

// Action: triggers execution
result.show()  // executes the whole chain

---

Q42. What is Spark caching? Medium

// Cache in memory (default MEMORY_AND_DISK)
val df = spark.read.parquet("large_dataset.parquet")
df.cache()  // or df.persist()

// Explicitly set storage level
import org.apache.spark.storage.StorageLevel
df.persist(StorageLevel.MEMORY_ONLY_SER)

// Use multiple times without re-reading
val count = df.count()
val avg = df.agg(avg("salary")).collect()

df.unpersist()  // free memory when done

---

Q43. What are Spark window functions? Advanced

import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._

val windowSpec = Window
    .partitionBy("department")
    .orderBy(desc("salary"))

df.withColumn("rank", rank().over(windowSpec))
  .withColumn("dense_rank", dense_rank().over(windowSpec))
  .withColumn("running_total", sum("salary").over(
      windowSpec.rowsBetween(Long.MinValue, 0)
  ))
  .show()

---

Q44. What is a broadcast join in Spark? Advanced

import org.apache.spark.sql.functions.broadcast

// Force broadcast join for a small lookup table
val enriched = largeDf.join(
    broadcast(smallDf),
    "user_id"
)

---

Q45. What is Spark serialization? Advanced

val conf = new SparkConf()
    .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    .set("spark.kryo.registrationRequired", "true")

// Register custom classes for Kryo
conf.registerKryoClasses(Array(classOf[User], classOf[Product]))

---

Mock Interview: 5 Questions

1. Implement a generic Tree ADT with map and fold operations.
2. Write a function that reads a CSV file using Spark, filters rows where age > 25, and writes the result as Parquet.
3. Explain the difference between map and flatMap on Option with a real-world example.
4. What is the output of List(1,2,3).foldRight(List.empty[Int])(_ :: _)?
5. Implement flatten for List[Option[Int]] using flatMap.

---

FAQ

Q: Is Scala being replaced by Python for Spark jobs? A: PySpark is popular for data science, but Scala remains dominant for production Spark pipelines at data engineering teams. The type safety and performance advantages of Dataset API keep Scala relevant for mission-critical pipelines.

Q: What is the difference between Scala 2 and Scala 3? A: Scala 3 (Dotty) replaced implicits with cleaner given/using, added intersection/union types, improved pattern matching, and cleaned up the type system. Most production code is still Scala 2.13, but Scala 3 adoption is growing.

Q: Do I need Akka knowledge for Scala jobs? A: For backend microservices roles, yes. For data engineering/Spark roles, no. Focus on Akka HTTP and Actors for service-side roles.

---

Related reading: Java Interview Questions 2026 | Python Interview Questions 2026 | Spring Boot Interview Questions 2026 | AWS Interview Questions 2026