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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Dattakumar Dattu