Publicis Sapient – SAT L1 Interview Experience (3.5 Hours | Java + Spring Boot Heavy) [Selected]
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.
Full Experience
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
Interview Questions (30)
Find Unique Sorted Alphabets in String
Given a string, find all unique alphabets within it and return them in sorted order.
Builder Pattern Use Cases & Immutability
Discuss the use cases of the Builder Pattern and its relation to immutability.
Singleton Pattern Deep Dive
Discuss the Singleton Pattern in depth, including Eager vs Lazy initialization, and answer output-based questions on OOP principles related to it.
Thread Lifecycle
Explain the different states and transitions in a thread's lifecycle.
Synchronization
Explain synchronization in Java, including its mechanisms and why it's needed.
Volatile vs Atomic
Compare and contrast 'volatile' keyword with 'Atomic' classes in Java.
Race Conditions
Explain what race conditions are and how to prevent them.
Deep Dive on Garbage Collection
Discuss the latest Garbage Collection algorithms (G1 GC, ZGC), heap structure, GC tuning basics, and Stop-the-world events.
Functional Interfaces with Stream Examples
Explain functional interfaces and demonstrate their usage with Java Stream API examples.
Internal Working of Serialization
Explain how serialization works internally in Java.
Serializable vs Externalizable
Compare and contrast Serializable and Externalizable interfaces in Java.
Preventing Serialization Issues
Discuss common issues with serialization and how to prevent them.
HashMap Internal Working
Explain the internal working of HashMap, including resizing and treeification.
JUnit Basics
Explain the basic concepts and usage of JUnit for unit testing.
Mockito Basics
Explain the basic concepts and usage of Mockito for mocking.
Mocking vs Stubbing
Differentiate between mocking and stubbing in the context of testing.
Spring Boot Controller with Best Practices
Demonstrate how to write a Spring Boot Controller class adhering to best practices.
Spring Boot Exception Handling
Discuss best practices and common approaches for exception handling in Spring Boot applications.
API Versioning Approaches
Explain different approaches to API versioning, specifically URI-based and Header-based methods.
Spring Bean Scopes
Explain different Spring Bean scopes: Singleton, Prototype, Request, and Session.
Writing a JWT Filter
Explain how to implement a JWT filter for authentication in Spring Security.
Securing Endpoints with Spring Security
Discuss methods and configurations for securing REST endpoints using Spring Security.
JWT Token Flow
Describe the end-to-end flow of a JWT token, from generation to validation.
SQL Query: High-Value Purchases Last Year
Write an SQL query to find users who purchased items worth more than 10,000 from a selected month of the previous year.
Database Pagination Strategies
Discuss different strategies for implementing pagination efficiently in database queries.
Handling Large Datasets in Database
Explain techniques for efficiently handling queries and operations on tables with millions of rows.
Redis Cache Usage and Strategy
Discuss common use cases for Redis as a cache and different caching strategies.
Database Sharding Concepts
Explain the concepts behind database sharding and its benefits/drawbacks.
Efficient Large Dataset Retrieval
Explain strategies and techniques to retrieve large datasets from a system without exhausting memory resources.
API Performance Optimizations
Discuss various techniques and considerations for optimizing the performance of APIs.
Preparation Tips
If you’re preparing for SAPIENT / Backend Java roles, focus on:
- Java internals > frameworks
- GC + Multithreading
- Collections & JVM
- Real production use cases