Backend Engineering
Interview Preparation

How to Use This Section

Most interview prep fails because it treats questions as isolated facts to memorise. You memorise 200 answers, panic on question 201, and forget half of the 200 under pressure. This section takes a different approach: every topic is anchored to a mental model — a logical chain that, once understood, regenerates the answer from first principles.

Topic 1 — Spring Core & Internals

The mental model: Spring is a container that owns object lifetimes and wires them together. Every Spring question is an extension of this idea. If you understand how beans are created, proxied, and destroyed, you can reason through any Spring question.

Topic 2 — Database & JPA

The mental model: JPA is a translation layer between Java objects and relational rows. Every JPA question is about the cost of that translation, its failure modes, and when to bypass it entirely.

Topic 3 — Concurrency & Thread Safety

The mental model: concurrency bugs only happen when shared mutable state is accessed without coordination. If state is immutable, or if it’s not shared, there is no bug. Every concurrency question reduces to: what is shared, what is mutable, and who coordinates access?

Topic 4 — REST API Design

The mental model: a good API is a contract. It makes correct usage easy, incorrect usage impossible, and evolution painless. Every API design question asks: does this contract serve clients well under change?

Topic 5 — Caching

The mental model: a cache is a bet that you’ll read the same data again before it changes. Every caching question is about whether the bet is worth making, and what happens when you lose it.

Topic 6 — Security

The mental model: security is about answering three questions: Who are you? What are you allowed to do? Can I trust this request? Authentication answers #1, authorisation answers #2, and everything else (CSRF, CORS, rate limiting) answers #3.

Topic 7 — System Design Framework

The mental model: system design interviews test whether you think like an engineer under uncertainty. There is no single correct answer. The interviewer watches how you decompose a problem, make tradeoffs explicit, and handle constraints. Follow a consistent framework so you never freeze.

Topic 8 — Microservices & Distributed Systems

The mental model: microservices trade code complexity for operational complexity. Every microservices question is about whether that trade is worth making, and how to manage the operational complexity once you’ve made it.

Mock Interview: Live Debugging Round

Debugging rounds give you a broken application and ask you to diagnose it. The pattern: look at symptoms, form a hypothesis, find evidence, confirm or eliminate, propose fix. Never guess — always reason from evidence.

Common Code Review Bugs to Spot

@RestController
public class UserController {

    @Autowired
    private UserService userService;  // BUG 1: Field injection — prefer constructor

    private List<User> userCache = new ArrayList<>(); // BUG 2: Mutable instance state in singleton

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable String id) {
        User user = userCache.stream()
            .filter(u -> u.getId().equals(id))
            .findFirst()
            .orElse(null);  // BUG 3: Return null — should throw or return Optional

        if (user == null) {
            user = userService.findById(id); // BUG 4: No null check on service result
            userCache.add(user); // BUG 5: Race condition — not thread-safe, unbounded growth
        }
        return user; // BUG 6: Returns null if not found — should be 404
    }

    @DeleteMapping("/users/{id}")
    @Transactional
    public void deleteUser(@PathVariable String id) {
        userService.delete(id); // BUG 7: @Transactional on controller — won't work,
                                // controllers should not be transaction boundaries
        userCache.remove(id);   // BUG 8: Should also invalidate cache, but List.remove(String)
    }                           // won't work — need to remove by predicate
}

// FIXED VERSION:
@RestController
@RequiredArgsConstructor
public class UserController {

    private final UserService userService; // Constructor injection

    @GetMapping("/users/{id}")
    public ResponseEntity<UserResponse> getUser(@PathVariable UUID id) {
        return userService.findById(id)
            .map(UserResponse::from)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/users/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable UUID id) {
        userService.delete(id); // Transaction boundary belongs in service layer
        return ResponseEntity.noContent().build();
    }
}

Rapid-Fire Revision Cards

The questions interviewers ask in the first 5 minutes to gauge your level. Get these right without hesitation.