If you are new to Java jobs, Spring sounds like a huge syllabus. In real companies it is simpler: Spring is the kitchen that cooks API requests for you. Think of a restaurant A user opening your app is a customer. They do not walk into the kitchen. They tell a waiter what they want. Browser / mobile app = the customer DispatcherServlet = the waiter who takes every order Controller = the menu item: “login”, “create order”, “get profile” Service = the kitchen: business rules (is the password correct?) Repository = the store room: talk to the database Database = the fridge where user rows actually live You almost never talk to the fridge from the waiter. That is why we split Controller → Service → Repository. Freshers mix these layers and then bugs become hard to find. Spring vs Spring Boot (the interview trap) Spring Framework is the recipe book: dependency injection, web, security, data. You can assemble it yourself, but it takes many XML/Java config files. Spring Boot is a restaurant that already has gas, plates, and a default kitchen. You write a main method, add starters like spring-boot-starter-web , and Tomcat starts for you. In 2026 almost every fresher job uses Boot, not raw Spring XML. Realtime path: POST /login Imagine the JSON body is {"email":"ria@company.com","password":"..."} . The waiter (DispatcherServlet) sees URL /login and HTTP POST. A @RestController method matches that mapping and reads the JSON into a Java object. The controller does not check the password. It calls authService.login(...) . The service loads the user through a repository: userRepository.findByEmail(email) . Hibernate/JPA turns that into SQL: SELECT * FROM users WHERE email = ? . The service compares the hashed password (never store plain text). If it matches, you return a session cookie or a JWT. If not, you return 401. That is “Spring in production” for a login. Same pipeline for “place order”, “upload resume”, “fetch notifications”. The magic word: Dependency Injection Without Spring you would write new UserRepository() inside the service. Then the service is glued to one database and unit tests become painful. Spring creates the repository once and hands it to the service. Like HR assigning you a laptop instead of you buying your own. That is why you see constructors like this: @Service public class AuthService { private final UserRepository users; public AuthService(UserRepository users) { this.users = users; } } You did not call new AuthService . Spring did, at startup, and wired the pieces. That is Inversion of Control: you describe the beans, Spring owns the lifecycle. What you actually type on day one @SpringBootApplication on the main class — start the kitchen @RestController + @PostMapping("/login") — a menu item @Service — kitchen logic @Repository + JpaRepository — fridge access application.properties — DB URL, port 8080, profiles for dev vs prod Annotations are not decoration. They are labels so Spring can find and wire your classes at startup. If a bean is missing, the app fails at boot, not in the middle of a user request. That fail-fast is a feature. Fresher mistakes I see in real teams Putting SQL or password checks inside the controller — hard to test, easy to copy-paste bugs Using new for services instead of letting Spring inject them — you lose transactions and mocks Returning the whole User entity (including password hash) in JSON — leak Forgetting @Transactional on a method that writes two tables — order saved, payment row missing Running only on localhost, then wondering why prod cannot reach MySQL — config/profiles How to practice this week Build one tiny Boot app: register + login + “me” endpoint. Use Postgres or even H2 in memory. Hit it with Postman. Then add a second feature, like “create a note for the logged-in user”. If you can explain that flow on a whiteboard without memorizing the whole Spring docs, you are job-ready for a junior Java interview. Spring is not 200 annotations to memorize. It is a waiter, a kitchen, and a fridge — and Boot starts the restaurant for you.
We moved session checks to the edge to cut latency on every page load. It worked in staging, then failed on preview deploys when cookies crossed domains. Clock skew between edge and origin made short-lived tokens look expired. We fixed cookie domains per environment and added skew-tolerant expiry. Median auth path dropped about 120ms, with fewer cold-start surprises. Lesson: test cookies across every environment before calling a migration done.
I used to think more indexes always meant faster queries. Production taught me about write amplification and table bloat instead. We had three indexes that nothing queried, slowing every insert. EXPLAIN ANALYZE finally showed which plans actually used which indexes. After dropping the dead ones, writes got healthier without hurting reads. Now I review unused indexes in the same ritual as reviewing slow queries.
No spike in CPU. Error budgets looked fine at a glance. Users still reported blank pages in a thin slice of traffic. Logs only showed upstream resets with no clear application exception. The culprit was a stale keep-alive timeout between nginx and the app. Aligning idle timeouts stopped the intermittent 502s within an hour. We also added a dashboard for upstream reset reasons so the next page is faster.
Our provider retries aggressively and out of order under failure. Naive fixtures make CI slow and still miss race conditions. Looking for patterns that keep suites fast and realistic. Do you fake the provider clock, or replay recorded payloads? How do you assert idempotency without flaky sleeps? Share a setup that survived production incident recreations.
Influence without owning every PR took longer than I expected. Saying no clearly protected the roadmap more than heroic overtime. Writing the docs nobody wants to write still changes team speed. I spent more time unblocking others than shipping my own features. Staff work is often invisible until the org feels the absence of it. Still learning how to measure impact without vanity metrics.
No spike in CPU. Error budgets looked fine at a glance. Users still reported blank pages in a thin slice of traffic. Logs only showed upstream resets with no clear application exception. The culprit was a stale keep-alive timeout between nginx and the app. Aligning idle timeouts stopped the intermittent 502s within an hour. We also added a dashboard for upstream reset reasons so the next page is faster.
No spike in CPU. Error budgets looked fine at a glance. Users still reported blank pages in a thin slice of traffic. Logs only showed upstream resets with no clear application exception. The culprit was a stale keep-alive timeout between nginx and the app. Aligning idle timeouts stopped the intermittent 502s within an hour. We also added a dashboard for upstream reset reasons so the next page is faster.
No spike in CPU. Error budgets looked fine at a glance. Users still reported blank pages in a thin slice of traffic. Logs only showed upstream resets with no clear application exception. The culprit was a stale keep-alive timeout between nginx and the app. Aligning idle timeouts stopped the intermittent 502s within an hour. We also added a dashboard for upstream reset reasons so the next page is faster.
No spike in CPU. Error budgets looked fine at a glance. Users still reported blank pages in a thin slice of traffic. Logs only showed upstream resets with no clear application exception. The culprit was a stale keep-alive timeout between nginx and the app. Aligning idle timeouts stopped the intermittent 502s within an hour. We also added a dashboard for upstream reset reasons so the next page is faster.
Dattakumar Dattu
sunilraju ch
kumar p