Video summary
Infosys Real Interview For Experienced Candidate
Main summary
Key takeaways
Key technical concepts & features discussed
Microservices (and comparison to monoliths)
-
Definition/meaning: Microservices are independent services that can be:
- Deployed independently
- Scaled independently
- Developed independently
-
Monolith vs microservices scaling/deployment:
- With monolithic services, the whole application must be scaled together.
- With microservices, only the required service(s) can be scaled and deployed.
API Gateway request routing
- Incoming requests go to an API Gateway.
- The gateway uses port/IP information to forward requests to the correct microservice.
Microservice reliability & observability patterns
- Circuit breaker pattern: Used when one microservice calls another and the called service fails; it returns an appropriate response.
- Distributed tracing: Used to trace a request across multiple microservices (i.e., follow request flow across services).
REST APIs / Spring Boot (web service concepts)
RESTful endpoints & HTTP methods (as asked)
Mentioned/used in Spring Boot with mappings such as:
- GET (retrieve data)
- POST (create/save data)
- PUT (intended as “save/update data”)
- PATCH (partial update)
- DELETE (delete)
Status codes discussed:
- 200 (“OK”)
- 404 (“page not found”)
- 500 (“internal server error”)
- 401 was mentioned, but other success codes (e.g., 201/204) were not clearly recalled.
Spring Boot layer flow (request → response)
Client request (e.g., Postman) goes through:
- Dispatcher Servlet / Front controller
- Controller
- Service layer (business logic)
- View resolver & View (described as part of the flow; implies MVC-style handling)
Follow-up asked about common layer names:
- Controller layer
- Service layer
- Repository / Persistence layer (mapped to persistence concept)
Spring Boot project configuration
- Maven dependencies:
- Dependencies are added in
pom.xml. - They are stored in an internal Maven repository/cache location (a local user location was mentioned, but the exact path wasn’t clearly detailed).
- Dependencies are added in
Java access specifiers
Covered:
- private
- protected
- public
- default/package-private
With basic intended visibility:
- class-only
- subclass-only
- any
- same package
Client/server flow exercise (algorithm sketch)
The candidate gave a structured flow example:
- POST mapping to save data to the database
- GET mapping to retrieve data by path variable (e.g.,
studentId)
Example architecture in the sketch:
- Controller receives request body/params
- Service processes and calls
- Repository (DAO/persistence layer) for persistence methods like:
save(...)findAll(...)/ retrieval methods (mentioned generally)
Docker concepts & commands
- Docker described as a containerized platform.
Dockerfile components (conceptually)
FROM(base image, e.g., Java)- Working directory (
WORKDIR) - Optional metadata (
LABEL) - Execution command via
ENTRYPOINT
Docker lifecycle commands
- Docker build (build image from Dockerfile)
- Docker run (run container from image)
- Docker stop (stop container)
- Docker push (push image to Docker Hub/repository)
Commands for inspection
- Docker images (list images)
- Docker ps (list running containers)
Hosting / running Spring Boot microservices locally
- Hosting/run explained as:
- Configure port/IP in application properties
- Start Spring Boot application; it runs on the configured port
Mentioned:
- Default Tomcat support
- A confusing statement about “default port is 80” (though typical Spring Boot defaults are often 8080 unless changed)
Reviews / guides / tutorials
- No formal “review” of products/tools; the video functions mainly as a mock interview / technical Q&A.
- Includes a mini tutorial-style request flow walkthrough for REST:
- POST (save) and GET (fetch) across Controller → Service → Repository.
Main speakers / sources
- Interviewer: Jack
- Interviewee (candidate): S (appears as “Sh Jack…;” full name not captured)