Publicis Sapient – SAT L1 Interview Experience (3.5 Hours | Java + Spring Boot Heavy) [Selected]
- Posted
- 20 Jan 2026
Summary
I recently interviewed with Publicis Sapient for a SAT L1 role, which was a very in-depth backend interview focusing heavily on Java and Spring Boot internals. I was selected for the role.
How it went
Recently interviewed with Publicis Sapient for SAT L1, and it turned out to be one of the most in-depth backend interviews I’ve faced so far.
⏱️ Interview Structure
Total Duration: ~3.5 hours
- Java Core: ~1.5 hours
- Spring Boot: ~30 mins
- Spring Security: ~15 mins
- Databases: ~30 mins
- Misc / System Design / Infra: Remaining time
🧠 Java & Core Concepts (Deep Dive)
These were not surface-level questions — interviewer kept drilling deeper.
🔹 Coding / Logic
- Find unique alphabets from a string and return them in sorted order
🔹 OOP & Design Patterns
- Coding - Builder Pattern, Singleton
- Builder Pattern – use cases, immutability
- Singleton Pattern – very deep discussion:
- Eager vs Lazy
- Output-based questions on OOP principles
🔹 Multithreading & Concurrency
- Thread lifecycle
- Synchronization
- Volatile vs Atomic
- Race conditions
- Real-world scenarios
🔹 Garbage Collection (Very Important)
Deep dive on latest GC algorithms:
- G1 GC
- ZGC
- Heap structure
- GC tuning basics
- Stop-the-world events
🔹 Java 8+
- Functional Interfaces (explained all with Stream examples)
- Lambda expressions
- Method references
🔹 Serialization
- How serialization works internally
- Serializable vs Externalizable
- How to prevent serialization issues
🔹 Collections (Asked in depth)
- HashMap (internal working, resizing, treeification)
- HashSet
- LinkedHashSet
- Time complexity + real use cases
🔹 Testing
- JUnit basics
- Mockito basics
- Mocking vs Stubbing
🌱 Spring Boot
- Spring Boot fundamentals
- Write a Controller class using best practices
- Exception handling
- API Versioning approaches
- URI based
- Header based
- Bean Scopes (Singleton, Prototype, Request, Session)
🔐 Spring Security
- JWT-based authentication
- Writing JWT filter
- Securing endpoints
- Token flow (generation → validation)
🗄️ Database & SQL
- SQL query:
- Find users who purchased items worth more than 10k from a selected month of the previous year
- JPA Queries
- Pagination strategies
- Handling million+ rows efficiently
☁️ System / Infra / Architecture
- Redis cache usage & strategy
- Sharding concepts
- Cloud & project infra discussion
- How to retrieve large datasets without killing memory
- API performance optimizations
🧩 Overall Experience
Interview was intense but fair
Focused heavily on internals + real-world scenarios
If you claim experience, expect deep cross-questioning
Strong emphasis on Java fundamentals
Questions asked (30)
- 01
Find Unique Sorted Alphabets in String
Data Structures & Algorithms · Easy
Given a string, find all unique alphabets within it and return them in sorted order.
- 02
Builder Pattern Use Cases & Immutability
Other
Discuss the use cases of the Builder Pattern and its relation to immutability.
- 03
Singleton Pattern Deep Dive
Other
Discuss the Singleton Pattern in depth, including Eager vs Lazy initialization, and answer output-based questions on OOP principles related to it.
- 04
Thread Lifecycle
Other
Explain the different states and transitions in a thread's lifecycle.
- 05
Synchronization
Other
Explain synchronization in Java, including its mechanisms and why it's needed.
- 06
Volatile vs Atomic
Other
Compare and contrast 'volatile' keyword with 'Atomic' classes in Java.
- 07
Race Conditions
Other
Explain what race conditions are and how to prevent them.
- 08
Deep Dive on Garbage Collection
Other
Discuss the latest Garbage Collection algorithms (G1 GC, ZGC), heap structure, GC tuning basics, and Stop-the-world events.
- 09
Functional Interfaces with Stream Examples
Other
Explain functional interfaces and demonstrate their usage with Java Stream API examples.
- 10
Internal Working of Serialization
Other
Explain how serialization works internally in Java.
- 11
Serializable vs Externalizable
Other
Compare and contrast Serializable and Externalizable interfaces in Java.
- 12
Preventing Serialization Issues
Other
Discuss common issues with serialization and how to prevent them.
- 13
HashMap Internal Working
Data Structures & Algorithms
Explain the internal working of HashMap, including resizing and treeification.
- 14
JUnit Basics
Other
Explain the basic concepts and usage of JUnit for unit testing.
- 15
Mockito Basics
Other
Explain the basic concepts and usage of Mockito for mocking.
- 16
Mocking vs Stubbing
Other
Differentiate between mocking and stubbing in the context of testing.
- 17
Spring Boot Controller with Best Practices
Other
Demonstrate how to write a Spring Boot Controller class adhering to best practices.
- 18
Spring Boot Exception Handling
Other
Discuss best practices and common approaches for exception handling in Spring Boot applications.
- 19
API Versioning Approaches
System Design
Explain different approaches to API versioning, specifically URI-based and Header-based methods.
- 20
Spring Bean Scopes
Other
Explain different Spring Bean scopes: Singleton, Prototype, Request, and Session.
- 21
Writing a JWT Filter
Other
Explain how to implement a JWT filter for authentication in Spring Security.
- 22
Securing Endpoints with Spring Security
Other
Discuss methods and configurations for securing REST endpoints using Spring Security.
- 23
JWT Token Flow
Other
Describe the end-to-end flow of a JWT token, from generation to validation.
- 24
SQL Query: High-Value Purchases Last Year
Data Structures & Algorithms · Medium
Write an SQL query to find users who purchased items worth more than 10,000 from a selected month of the previous year.
- 25
Database Pagination Strategies
System Design
Discuss different strategies for implementing pagination efficiently in database queries.
- 26
Handling Large Datasets in Database
System Design
Explain techniques for efficiently handling queries and operations on tables with millions of rows.
- 27
Redis Cache Usage and Strategy
System Design
Discuss common use cases for Redis as a cache and different caching strategies.
- 28
Database Sharding Concepts
System Design
Explain the concepts behind database sharding and its benefits/drawbacks.
- 29
Efficient Large Dataset Retrieval
System Design
Explain strategies and techniques to retrieve large datasets from a system without exhausting memory resources.
- 30
API Performance Optimizations
System Design
Discuss various techniques and considerations for optimizing the performance of APIs.
How they prepared
If you’re preparing for SAPIENT / Backend Java roles, focus on:
- Java internals > frameworks
- GC + Multithreading
- Collections & JVM
- Real production use cases