Java Full Stack Developer — Interview Guide

Java Full Stack Developer

Interview Questionnaire & Model Answers
Prepared for interview preparation — [Link]
Covers Core Java, Collections, Multithreading, Spring Boot, REST APIs, Hibernate/JPA, SQL, Microservices, Frontend
Basics, System Design, and HR/Behavioral Rounds

Page 1 of 11
 Java Full Stack Developer — Interview Guide

How to Use This Guide

This questionnaire is organized by topic area, moving from core Java fundamentals through backend frameworks, data layer,
microservices, frontend basics, system design, and finally behavioral/HR questions. Each question includes a model answer
written the way a strong candidate would explain it out loud — concise, structured, and demonstrating depth rather than just
definitions.
Tips for the actual interview: (1) Adapt every answer with a real example from your own project experience wherever
possible — interviewers value specificity over textbook definitions. (2) For behavioral questions, structure your response
using the STAR method (Situation, Task, Action, Result). (3) It's fine to say "I haven't used that in production, but here's my
understanding" for topics you're less sure of — honesty is better than guessing confidently and getting it wrong.

1. Core Java & Object-Oriented Programming

Fundamentals every Java developer is expected to know cold — these are usually the opening questions in a Taggd/client
screening round.

Q1. What are the four pillars of Object-Oriented Programming? Explain each briefly.
Model Answer: The four pillars are Encapsulation, Inheritance, Polymorphism, and Abstraction. Encapsulation means
binding data and methods together in a class and restricting direct access to fields using private modifiers and getters/setters.
Inheritance allows a class to acquire properties and behavior of another class using the extends keyword, promoting code
reuse. Polymorphism allows the same method or object to behave differently in different contexts — achieved through
method overloading (compile-time) and method overriding (runtime). Abstraction means hiding implementation details and
exposing only the necessary functionality, achieved using abstract classes and interfaces.

Q2. What is the difference between an abstract class and an interface?

Model Answer: An abstract class can have both abstract and concrete methods, constructors, instance variables, and access
modifiers, and a class can extend only one abstract class. An interface (pre-Java 8) could only have abstract methods; from
Java 8 onward it can also have default and static methods, but it cannot have constructors or instance state, and a class can
implement multiple interfaces. Use an abstract class when classes share a common base implementation; use an interface
when you want to define a contract that unrelated classes can implement.

Q3. Differentiate between method overloading and method overriding.

Model Answer: Overloading happens within the same class when multiple methods share a name but differ in parameter list
(number, type, or order) — it is resolved at compile time (static polymorphism). Overriding happens between a superclass
and subclass when the subclass provides a specific implementation of a method with the same signature — it is resolved at
runtime based on the actual object type (dynamic polymorphism), and requires the @Override annotation as good practice.

Q4. Explain the difference between JDK, JRE, and JVM.

Model Answer: JVM (Java Virtual Machine) is the runtime engine that executes bytecode and provides platform
independence. JRE (Java Runtime Environment) includes the JVM plus core libraries needed to run Java applications, but no
development tools. JDK (Java Development Kit) includes the JRE plus development tools like the compiler (javac),
debugger, and other utilities needed to write and compile Java programs. In short: JDK ⊇ JRE ⊇ JVM.

Q5. What is the difference between == and .equals() in Java?

Model Answer: == compares references for objects (whether both variables point to the same memory location) and
compares values for primitives. .equals() is a method that compares the actual content/state of two objects, and its behavior
depends on how it's overridden in a class — for example, String and wrapper classes override it to compare values, while the
default Object implementation just falls back to reference comparison. When overriding equals(), hashCode() should also be
overridden to maintain the contract used by collections like HashMap and HashSet.

Page 2 of 11
 Java Full Stack Developer — Interview Guide

Q6. What are functional interfaces and lambda expressions introduced in Java 8?
Model Answer: A functional interface is an interface with exactly one abstract method (it can have multiple default/static
methods), marked optionally with @FunctionalInterface — examples include Runnable, Comparator, and the
[Link] package (Predicate, Function, Supplier, Consumer). A lambda expression provides a concise way to
implement a functional interface inline, for example, (a, b) -> a + b, replacing verbose anonymous inner classes. Lambdas
enabled the Stream API, which allows functional-style operations like filter, map, and reduce on collections.

Q7. What is the difference between String, StringBuilder, and StringBuffer?

Model Answer: String is immutable — every modification creates a new object, which can be costly in loops with many
concatenations. StringBuilder is mutable and not thread-safe, making it faster for single-threaded string manipulation.
StringBuffer is also mutable but thread-safe because its methods are synchronized, making it slightly slower but safe for
concurrent use. As a rule of thumb: use String for constants, StringBuilder for most string-building logic, and StringBuffer
only when multiple threads modify the same string.

2. Collections Framework
Collections questions test whether a candidate understands data structure trade-offs, not just API names.

Q1. What is the difference between ArrayList and LinkedList?

Model Answer: ArrayList is backed by a dynamic array, so it offers O(1) random access (get/set) but O(n) insertion/deletion
in the middle since elements must shift. LinkedList is a doubly linked list, offering O(1) insertion/deletion at known positions
but O(n) random access since it must traverse nodes. Choose ArrayList when reads dominate; choose LinkedList when
frequent insertions/deletions happen, especially at the ends (it also implements Deque, useful for stack/queue behavior).

Q2. Explain the difference between HashMap, Hashtable, and ConcurrentHashMap.

Model Answer: HashMap is not synchronized, allows one null key and multiple null values, and is not thread-safe. Hashtable
is a legacy class that is fully synchronized (locks the whole map), thread-safe but slow under concurrency, and does not allow
null keys/values. ConcurrentHashMap is thread-safe and designed for high concurrency — instead of locking the whole map,
it uses fine-grained locking (bucket-level in older versions, CAS-based operations with synchronized blocks on nodes in Java
8+), giving much better throughput than Hashtable in multi-threaded environments.

Q3. How does HashMap work internally?

Model Answer: HashMap stores entries in an array of buckets. When you put a key-value pair, it computes hashCode() on
the key, applies an internal hash-spreading function, and determines the bucket index using (n-1) & hash. Each bucket holds a
linked list of entries with the same bucket index (to handle collisions); since Java 8, if a bucket's list grows beyond a
threshold (8 entries) and the table is large enough, it converts to a balanced tree (red-black tree) for O(log n) worst-case
lookup instead of O(n). Resizing (rehashing) happens when the number of entries exceeds capacity times load factor (default
0.75).

Q4. What is the difference between Comparable and Comparator?

Model Answer: Comparable is implemented by the class itself to define its natural ordering, using the compareTo() method
— a class can have only one natural ordering. Comparator is a separate class implementing compare(), used to define custom
or multiple sort orders without modifying the original class, and can be passed to methods like [Link]() or
[Link](). Comparator is generally more flexible since you can create as many comparators as needed for different sorting
criteria.

Q5. What are fail-fast and fail-safe iterators?

Model Answer: Fail-fast iterators (used by ArrayList, HashMap, etc.) throw a ConcurrentModificationException if the
collection is structurally modified while iterating, because they check a modCount internally. Fail-safe iterators (used by
CopyOnWriteArrayList, ConcurrentHashMap) operate on a cloned or otherwise isolated view of the collection, so they don't

Page 3 of 11
 Java Full Stack Developer — Interview Guide

throw an exception on concurrent modification, though the iterator may not reflect the latest changes. Fail-safe collections
trade some consistency for thread-safety.

3. Multithreading & Concurrency

Especially important for backend-heavy Java Full Stack roles dealing with high-traffic APIs.

Q1. What is the difference between a process and a thread?

Model Answer: A process is an independent program in execution with its own memory space, while a thread is a
lightweight sub-unit of a process that shares the same memory and resources with other threads of that process. Because
threads share memory, communication between them is faster than inter-process communication, but this also introduces
risks like race conditions that need synchronization.

Q2. What are the ways to create a thread in Java, and which is preferred?
Model Answer: You can create a thread by extending the Thread class and overriding run(), or by implementing the
Runnable interface and passing it to a Thread object, or by implementing Callable (which can return a result and throw
checked exceptions) and submitting it to an ExecutorService. Implementing Runnable/Callable is generally preferred over
extending Thread because Java doesn't support multiple inheritance, so implementing an interface keeps the class free to
extend something else, and it decouples the task from the thread execution mechanism.

Q3. What is synchronization and what is a deadlock?

Model Answer: Synchronization is a mechanism to control access to shared resources by multiple threads, using the
synchronized keyword on methods or blocks, ensuring only one thread executes the critical section at a time. A deadlock
occurs when two or more threads are blocked forever, each waiting for a resource held by the other — a classic example is
Thread A holding Lock 1 and waiting for Lock 2, while Thread B holds Lock 2 and waits for Lock 1. Deadlocks can be
avoided by acquiring locks in a consistent global order, using timeouts (tryLock), or minimizing the scope of synchronized
blocks.

Q4. What is the Executor framework and why is it preferred over manually creating threads?
Model Answer: The Executor framework ([Link]) provides a higher-level API to manage thread pools instead of
manually creating and managing Thread objects. ExecutorService lets you submit Runnable/Callable tasks to a reusable pool
of threads, controlling concurrency limits and reducing the overhead of thread creation/destruction. Common
implementations include FixedThreadPool, CachedThreadPool, and ScheduledThreadPool, created via the Executors factory
class, though in production it's often recommended to configure ThreadPoolExecutor directly for better control over queue
size and rejection policy.

Q5. What does the volatile keyword do?

Model Answer: volatile ensures visibility of changes to a variable across threads — when one thread updates a volatile
variable, the change is immediately visible to other threads by forcing reads/writes to go to main memory rather than a CPU
cache. However, volatile does not guarantee atomicity for compound operations like increment (i++), so it's suitable for
simple flags (like a stop signal) but not for counters, where AtomicInteger or synchronization is needed instead.

4. Exception Handling
Q1. What is the difference between checked and unchecked exceptions?
Model Answer: Checked exceptions (like IOException, SQLException) are checked at compile time — the method must
either handle them with try-catch or declare them with throws. Unchecked exceptions (like NullPointerException,
ArrayIndexOutOfBoundsException) extend RuntimeException and are not checked at compile time; they usually indicate
programming errors. Errors (like OutOfMemoryError) are a separate category representing serious problems that applications
typically shouldn't try to catch.

Page 4 of 11
 Java Full Stack Developer — Interview Guide

Q2. What is try-with-resources and why is it useful?

Model Answer: try-with-resources is a Java 7+ construct that automatically closes resources (like file streams or DB
connections) that implement the AutoCloseable interface, once the try block finishes — even if an exception occurs. It
eliminates the need for a manual finally block to close resources, reducing boilerplate and preventing resource leaks, for
example: try (Connection conn = [Link]()) { ... }.

Q3. When and how would you create a custom exception?

Model Answer: You create a custom exception by extending Exception (for a checked exception) or RuntimeException (for
unchecked), typically to represent a specific business rule violation, like InsufficientBalanceException or
UserNotFoundException. This improves code readability and lets calling code handle specific business scenarios distinctly
rather than catching generic exceptions. Best practice is to include meaningful constructors (message, cause) and keep
custom exceptions in a well-organized package, often paired with a global exception handler like @ControllerAdvice in
Spring.

5. Spring Core & Spring Boot

Since most Java Full Stack roles today are Spring Boot-centric, expect this to be the most heavily weighted section.

Q1. What is the Spring Framework, and what do IoC and Dependency Injection mean?
Model Answer: Spring is a lightweight framework that simplifies Java enterprise development by providing infrastructure
support so developers can focus on business logic. Inversion of Control (IoC) is a principle where the control of object
creation and lifecycle management is transferred from the application code to a container (the Spring IoC container), rather
than objects creating their own dependencies. Dependency Injection (DI) is the mechanism used to implement IoC — the
container 'injects' required dependencies (via constructor, setter, or field injection) into a class rather than the class
instantiating them itself, which improves testability and loose coupling.

Q2. What are Spring bean scopes?

Model Answer: Common scopes include singleton (default — one shared instance per Spring container), prototype (a new
instance every time the bean is requested), request (one instance per HTTP request, web-aware), session (one instance per
HTTP session), and application (one instance per ServletContext). Singleton is used for stateless services, while prototype is
used when you need a fresh, stateful instance each time, such as a non-thread-safe helper object.

Q3. What is the difference between @Autowired constructor injection and field injection? Which is
recommended?
Model Answer: Field injection uses @Autowired directly on a class field, which is concise but makes the class harder to unit
test (you can't easily pass mocks without reflection) and hides required dependencies. Constructor injection passes
dependencies through the constructor, making dependencies explicit, enabling immutability (fields can be final), and
allowing easy unit testing by simply calling the constructor with mocks. Constructor injection is the recommended approach
in modern Spring applications, and Spring even allows omitting @Autowired entirely if there's a single constructor.

Q4. Explain key Spring Boot annotations: @SpringBootApplication, @RestController, @Service,

@Repository, @Component.
Model Answer: @SpringBootApplication is a convenience annotation combining @Configuration,
@EnableAutoConfiguration, and @ComponentScan, marking the main entry-point class. @RestController combines
@Controller and @ResponseBody, meaning methods return data (usually JSON) directly rather than a view name. @Service
marks a class as a business/service-layer bean, @Repository marks a data-access-layer bean and also enables automatic
translation of persistence exceptions into Spring's DataAccessException hierarchy, and @Component is the generic
stereotype annotation that @Service and @Repository specialize — all are picked up by component scanning.

Q5. What is Spring Boot auto-configuration and how does it work?

Page 5 of 11
 Java Full Stack Developer — Interview Guide

Model Answer: Auto-configuration automatically configures Spring beans based on the dependencies present on the
classpath and existing bean definitions, removing the need for extensive manual XML/Java configuration. It's driven by
@EnableAutoConfiguration, which uses conditional annotations like @ConditionalOnClass and
@ConditionalOnMissingBean defined in auto-configuration classes (listed in
META-INF/spring/[Link]) — for example, if spring-boot-
starter-web is on the classpath, Spring Boot auto-configures an embedded Tomcat server and a DispatcherServlet.

Q6. How do you manage configuration and environment-specific properties in Spring Boot?
Model Answer: Configuration is typically stored in [Link] or [Link], and Spring Boot supports
profile-specific files like [Link] or [Link], activated via [Link]. Properties can also
be externalized through environment variables, command-line arguments, or a config server (Spring Cloud Config) in
microservice setups, and injected into beans using @Value or type-safe @ConfigurationProperties classes.

Q7. What is Spring Boot Actuator and why would you use it?
Model Answer: Spring Boot Actuator provides production-ready features like health checks, metrics, environment info, and
thread dumps, exposed via HTTP endpoints (e.g., /actuator/health, /actuator/metrics) or JMX. It's used for monitoring and
managing applications in production — for example, integrating /actuator/health with a Kubernetes liveness/readiness probe,
or exposing metrics to Prometheus/Grafana dashboards.

6. REST APIs & Spring MVC

Q1. What are the key principles of REST?
Model Answer: REST (Representational State Transfer) is an architectural style built around: statelessness (each request
contains all information needed, no server-side session state), a uniform interface using standard HTTP verbs (GET, POST,
PUT, DELETE, PATCH) mapped to CRUD operations, resource-based URLs (nouns, not verbs, e.g., /users/123),
representation of resources typically in JSON, and use of standard HTTP status codes to indicate results. Well-designed
REST APIs are also cacheable and follow a layered client-server architecture.

Q2. Explain common Spring MVC annotations: @RequestMapping, @GetMapping, @PathVariable,

@RequestParam, @RequestBody.
Model Answer: @RequestMapping maps HTTP requests to handler methods/classes and can specify method type, while
@GetMapping, @PostMapping, etc. are shorthand for specific HTTP methods. @PathVariable extracts a value from the URI
path (e.g., /users/{id}), @RequestParam extracts query parameters (e.g., ?sort=name), and @RequestBody deserializes the
JSON request body into a Java object, typically used for POST/PUT requests.

Q3. What HTTP status codes would you use for common REST scenarios?
Model Answer: 200 OK for a successful GET/PUT, 201 Created for a successful POST that creates a resource, 204 No
Content for a successful DELETE with no body to return, 400 Bad Request for invalid client input, 401 Unauthorized when
authentication is missing/invalid, 403 Forbidden when authenticated but not permitted, 404 Not Found when the resource
doesn't exist, and 500 Internal Server Error for unhandled server-side failures.

Q4. How do you handle exceptions globally in a Spring Boot REST API?
Model Answer: Using @ControllerAdvice (or @RestControllerAdvice) combined with @ExceptionHandler methods, you
can centralize exception handling across all controllers instead of repeating try-catch blocks. For example, a method
annotated with @ExceptionHandler([Link]) can return a consistent JSON error response with an
appropriate HTTP status like 404, ensuring the API returns structured, predictable error payloads rather than raw stack traces.

Q5. What does idempotency mean in the context of REST APIs, and which HTTP methods are
idempotent?
Model Answer: An idempotent operation produces the same result no matter how many times it's executed. GET, PUT, and
DELETE are idempotent — calling PUT /users/123 with the same payload repeatedly leaves the resource in the same state,

Page 6 of 11
 Java Full Stack Developer — Interview Guide

and calling DELETE multiple times still results in the resource being absent. POST is generally not idempotent since it
typically creates a new resource each time it's called (e.g., submitting the same order twice creates two orders unless
idempotency keys are used).

7. Hibernate / JPA & Database Layer

Q1. What is ORM, and what problem does Hibernate solve?
Model Answer: Object-Relational Mapping (ORM) is a technique to map Java objects to relational database tables, letting
developers work with objects instead of writing raw SQL for every operation. Hibernate is a popular ORM implementation
(and the reference implementation of JPA) that handles the translation between Java entities and database rows, manages the
object lifecycle, generates SQL automatically, handles caching, and abstracts away database-specific dialect differences.

Q2. What is the difference between Hibernate and JPA?

Model Answer: JPA (Java Persistence API) is a specification — a set of interfaces and annotations (like @Entity, @Id,
@OneToMany) that define how ORM should work in Java, but it has no implementation of its own. Hibernate is a concrete
implementation of the JPA specification (along with EclipseLink, OpenJPA), and also offers additional Hibernate-specific
features beyond the JPA spec, like its own Criteria API extensions and caching strategies. Using JPA annotations rather than
Hibernate-specific ones keeps code portable across ORM providers.

Q3. Explain the entity lifecycle states in JPA/Hibernate.

Model Answer: An entity moves through four states: Transient (a new object, not yet associated with a persistence context or
saved to the DB), Persistent/Managed (attached to a persistence context — any changes are automatically tracked and synced
to the DB on flush/commit), Detached (was persistent but the persistence context is closed, so changes are no longer tracked),
and Removed (marked for deletion, will be deleted on flush/commit). Methods like persist(), merge(), and remove() move
entities between these states.

Q4. What is the difference between lazy loading and eager loading?
Model Answer: Lazy loading ([Link]) delays loading related entities until they are actually accessed, improving
performance by avoiding unnecessary joins/queries — it's the default for @OneToMany and @ManyToMany. Eager loading
([Link]) loads related entities immediately along with the parent entity — it's the default for @ManyToOne and
@OneToOne. Lazy loading is generally preferred for performance, but accessing a lazy association outside an active
persistence context throws a LazyInitializationException, which must be handled carefully (e.g., via DTOs, JOIN FETCH
queries, or keeping the session open appropriately).

Q5. How do you map a One-to-Many / Many-to-One relationship in JPA?

Model Answer: You annotate the 'many' side with @ManyToOne and a @JoinColumn specifying the foreign key column,
and the 'one' side with @OneToMany(mappedBy = "fieldName") pointing to the field on the owning (many) side. For
example, in an Order-OrderItem relationship, OrderItem would have @ManyToOne Order order, and Order would have
@OneToMany(mappedBy = "order") List<OrderItem> items. The 'many' side is typically the owning side of the relationship
since it holds the foreign key.

Q6. What is the N+1 select problem and how do you avoid it?
Model Answer: The N+1 problem occurs when fetching a list of N parent entities triggers one query for the parents, then N
additional queries — one per parent — to lazily fetch each one's related child collection, leading to severe performance
degradation. It can be avoided by using JOIN FETCH in JPQL/HQL to eagerly fetch associations in a single query, using
@EntityGraph to define fetch plans declaratively, or batch-fetching configuration (hibernate.default_batch_fetch_size) to
fetch related entities in batches instead of one at a time.

Page 7 of 11
 Java Full Stack Developer — Interview Guide

8. SQL & Database Fundamentals

Q1. Explain the different types of SQL joins.
Model Answer: INNER JOIN returns only rows with matching values in both tables. LEFT (OUTER) JOIN returns all rows
from the left table and matched rows from the right (nulls where there's no match). RIGHT (OUTER) JOIN is the mirror of
LEFT JOIN. FULL OUTER JOIN returns all rows from both tables, with nulls where there's no match on either side. A
SELF JOIN joins a table to itself, often used for hierarchical data like employee-manager relationships.

Q2. What is an index and how does it improve query performance?

Model Answer: An index is a database structure (commonly a B-tree) that allows the database engine to locate rows faster
than scanning the entire table, similar to a book's index. It significantly speeds up SELECT queries with WHERE, JOIN, and
ORDER BY clauses on indexed columns, at the cost of slightly slower INSERT/UPDATE/DELETE operations (since
indexes must also be updated) and additional storage. Choosing the right columns to index — typically those used frequently
in filters and joins, with high selectivity — is a key part of query optimization.

Q3. What is database normalization, and can you explain the first three normal forms briefly?
Model Answer: Normalization organizes data to reduce redundancy and improve data integrity by dividing large tables into
smaller related tables. 1NF requires atomic column values (no repeating groups/arrays within a column). 2NF requires 1NF
plus no partial dependency — every non-key column must depend on the entire primary key (relevant for composite keys).
3NF requires 2NF plus no transitive dependency — non-key columns must depend only on the primary key, not on other
non-key columns.

Q4. What are the ACID properties of a transaction?

Model Answer: Atomicity ensures a transaction is all-or-nothing — if any part fails, the whole transaction rolls back.
Consistency ensures the database moves from one valid state to another, respecting constraints. Isolation ensures concurrent
transactions don't interfere with each other's intermediate states (governed by isolation levels like Read Committed,
Repeatable Read, Serializable). Durability ensures that once a transaction is committed, it remains so even in the event of a
system failure, typically via write-ahead logging.

Q5. What is the difference between WHERE and HAVING clauses?

Model Answer: WHERE filters individual rows before any grouping/aggregation occurs and cannot reference aggregate
functions like SUM() or COUNT(). HAVING filters groups after a GROUP BY has been applied and can reference
aggregate functions, for example: SELECT department, COUNT(*) FROM employees GROUP BY department HAVING
COUNT(*) > 5.

9. Microservices & System Architecture

Q1. What is the difference between a monolithic and a microservices architecture?
Model Answer: A monolith is a single deployable unit where all modules (UI, business logic, data access) are tightly coupled
and share one codebase and database — simple to develop and deploy initially, but hard to scale specific parts and risky to
deploy since one change requires redeploying the whole app. Microservices break the application into small, independently
deployable services, each owning its own data store and communicating over the network (REST, messaging), allowing
independent scaling, technology choices, and deployments — at the cost of added complexity around distributed data
consistency, network latency, and operational overhead (monitoring, service discovery).

Q2. What roles do service discovery and an API gateway play in a microservices architecture?
Model Answer: Service discovery (e.g., Eureka, Consul) allows services to dynamically find and communicate with each
other's network locations rather than relying on hardcoded IPs/hostnames, which is essential since service instances scale
up/down and their addresses change. An API Gateway (e.g., Spring Cloud Gateway, Netflix Zuul) acts as a single entry point

Page 8 of 11
 Java Full Stack Developer — Interview Guide

for clients, handling cross-cutting concerns like routing to the correct service, authentication, rate limiting, and request
aggregation, so individual services don't need to duplicate that logic.

Q3. What is the Circuit Breaker pattern and why is it used?

Model Answer: The Circuit Breaker pattern (implemented via libraries like Resilience4j or Hystrix) prevents a service from
repeatedly calling a downstream dependency that is failing or slow, which could otherwise cause cascading failures across
the system. It works like an electrical circuit breaker: after a threshold of failures, the circuit 'opens' and calls fail fast (or fall
back to a default response) for a cooldown period, then moves to a 'half-open' state to test if the dependency has recovered
before fully 'closing' again.

Q4. How do microservices typically communicate with each other?

Model Answer: Synchronous communication is usually done via REST (HTTP/JSON) or gRPC, which is simple but couples
the caller to the availability of the callee. Asynchronous communication uses message brokers like Kafka or RabbitMQ,
where services publish events/messages to a topic/queue and consumers process them independently — this decouples
services in time, improves resilience, and supports patterns like event-driven architecture, at the cost of eventual consistency
and added infrastructure complexity.

Q5. How do you handle transactions that span multiple microservices?

Model Answer: Since traditional two-phase-commit distributed transactions don't scale well across independent
services/databases, the common approach is the Saga pattern — breaking a business transaction into a sequence of local
transactions, each with a corresponding compensating transaction to undo its effect if a later step fails. Sagas can be
orchestrated (a central coordinator tells each service what to do) or choreographed (each service reacts to events from others),
and the system as a whole embraces eventual consistency rather than strict ACID guarantees across services.

10. Frontend Fundamentals (Angular / React)

Since the role is 'Full Stack', expect at least a few questions on whichever frontend framework is listed in the JD.

Q1. What are components, modules, and services in Angular?

Model Answer: A component controls a portion of the UI (a template plus a TypeScript class handling logic and data
binding) and is the basic building block of an Angular application. A module (NgModule) groups related components,
directives, and services into a cohesive functional unit, and every Angular app has at least a root module (AppModule). A
service is a class typically used to encapsulate business logic or data-fetching (like HTTP calls) that can be injected into
components via Angular's dependency injection, keeping components focused purely on presentation.

Q2. What are React Hooks and why were they introduced?
Model Answer: Hooks (introduced in React 16.8) are functions like useState and useEffect that let functional components
manage state and side effects, which previously required class components. useState lets you add local state to a functional
component, and useEffect lets you perform side effects (data fetching, subscriptions, DOM manipulation) after render,
optionally cleaning up on unmount. Hooks were introduced to make it easier to reuse stateful logic between components (via
custom hooks) without the complexity of higher-order components or render props.

Q3. What is the Virtual DOM and why does React use it?
Model Answer: The Virtual DOM is an in-memory, lightweight representation of the actual DOM. When state changes,
React first updates the Virtual DOM, then compares (diffs) it against the previous version to compute the minimal set of
actual DOM changes needed, and applies only those changes to the real DOM. This is much faster than directly manipulating
the real DOM for every change, since real DOM operations are comparatively expensive.

Q4. How is two-way data binding implemented in Angular, and how does it differ from React's approach?
Model Answer: Angular supports two-way data binding using the [(ngModel)] directive (banana-in-a-box syntax), which
automatically keeps a form input and a component property in sync in both directions. React follows a one-way data flow by

Page 9 of 11
 Java Full Stack Developer — Interview Guide

design — data flows from parent to child via props, and to update state from a child, you pass a callback function down as a
prop; this makes data flow more predictable and easier to debug in larger applications, at the cost of slightly more boilerplate
for simple forms.

11. System Design / Practical Scenarios

Q1. How would you design a simple URL shortener service (like [Link])?
Model Answer: At a high level: a client submits a long URL via a REST API; the service generates a short, unique key (e.g.,
base62-encoded auto-increment ID, or a hash with collision handling) and stores a mapping of short key → long URL in a
database, ideally with an index on the short key for fast lookups. On a redirect request (GET /{shortKey}), the service looks
up the long URL and returns an HTTP 301/302 redirect. For scale, you'd add a caching layer (like Redis) in front of the
database for frequently accessed keys, and could shard the database by key prefix if volume grows very large; you'd also
want to track analytics (click counts) asynchronously so it doesn't slow down the redirect path.

Q2. A production API is suddenly responding slowly under load. How would you approach diagnosing
this?
Model Answer: First check monitoring/metrics (CPU, memory, GC activity, thread pool utilization, DB connection pool
usage) to identify the bottleneck layer — application, database, or network. Check for slow database queries (via slow query
logs or APM tools) and missing indexes, and check thread dumps for signs of thread contention or deadlocks. Review recent
deployments/config changes as a likely trigger, and check whether a downstream dependency has degraded (which circuit
breakers/timeouts should be protecting against). Based on findings, remediation could range from adding an index, scaling
out instances, tuning connection pool sizes, or adding caching for expensive/read-heavy operations.

12. Behavioral & HR Round Questions

Taggd, as a talent solutions partner, places strong emphasis on communication, culture fit, and structured storytelling in
behavioral rounds. Use the STAR method (Situation, Task, Action, Result) to structure answers.

Q1. Tell me about yourself.

Model Answer: Model approach: Give a brief professional summary (years of experience, core tech stack), highlight 1-2
significant projects or achievements relevant to the JD, and end with why you're interested in this specific opportunity.
Example structure: 'I'm a Java Full Stack Developer with X years of experience building REST APIs with Spring Boot and
Angular/React front-ends. In my current role at [company], I [specific achievement, e.g., led migration of a monolith to
microservices, or reduced API latency by X%]. I'm now looking for a role where I can [growth angle relevant to the target
role], which is what drew me to this opportunity.' Keep it under 90 seconds and tailor the achievement to what's likely valued
by the hiring company.

Q2. Why do you want to work for this company / through Taggd for this client?
Model Answer: Model approach: Show you've done some research — mention something specific about the company/client's
domain, tech stack, or growth stage, and connect it to your own career goals (e.g., 'I want to work on high-scale distributed
systems, and this role's focus on microservices and cloud migration aligns directly with where I want to grow'). Avoid
generic answers like 'good salary and brand name' — focus on genuine alignment between the role's challenges and your
skills/interests.

Q3. Describe a challenging technical problem you solved recently.

Model Answer: Model approach (STAR): Situation — briefly set context (e.g., 'Our order-processing API had intermittent
timeouts under peak load'). Task — what you were responsible for. Action — the specific steps you took (e.g., 'I analyzed
thread dumps, found a synchronized block causing contention, refactored it to use a ConcurrentHashMap, and added
connection pool tuning'). Result — the measurable outcome (e.g., 'reduced p99 latency by 40% and eliminated timeout
errors'). Always end with a quantifiable or clearly observable result.

Q4. How do you handle tight deadlines or conflicting priorities?

Page 10 of 11
 Java Full Stack Developer — Interview Guide

Model Answer: Model approach: Describe a structured approach — clarify scope and priorities with your manager/product
owner, break work into smaller deliverables, communicate risks early rather than at the deadline, and if needed, negotiate
scope (MVP first, enhancements later) rather than silently overcommitting. Back it up with a brief real example showing you
communicated proactively and delivered a working solution, even if it meant a phased approach.

Q5. Where do you see yourself in the next few years?

Model Answer: Model approach: Align your answer with a realistic growth path relevant to the role — for a mid-level
developer, this might be 'growing into a senior/lead role where I can also mentor junior developers and take ownership of
system design decisions,' or for someone earlier in career, 'deepening my expertise in backend architecture and cloud-native
development.' Avoid vague answers or ones that don't logically follow from the role being interviewed for.

Final Preparation Checklist

Before the interview, make sure you can:
● Walk through 1-2 of your recent projects end-to-end (architecture, your specific contribution, challenges faced).
● Write simple Java code on a whiteboard/shared doc without an IDE (collections usage, a basic REST controller, a
stream operation).
● Explain trade-offs, not just definitions — e.g., why you'd choose one collection, join type, or architecture pattern
over another.
● Have 2-3 thoughtful questions ready to ask the interviewer about the team, tech stack, or codebase.
● Review the specific job description once more and map your experience to each listed requirement.

Good luck with your interview!

Page 11 of 11