The Java Developer Projects That Actually Create Conversation

Employee Management System
- Built REST APIs using Spring Boot and MySQL
- Implemented CRUD operations for employees
- Used Hibernate for ORM and Postman for testing

What I think: fine, but nothing to ask beyond
"what is @RestController?"

Employee Leave Service (Spring Boot, MySQL)
- Prevented double-approval of leave when two managers
  approved at the same time, using optimistic locking
  (@Version) and a retry on conflict
- Wrote a concurrency test with ExecutorService that
  fires 20 parallel approvals and checks only one wins

What I think: I want to hear about that race condition.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class FixedWindowRateLimiter {

    private final int limit;
    private final long windowMillis;
    private final ConcurrentHashMap<String, Window> windows = new ConcurrentHashMap<>();

    public FixedWindowRateLimiter(int limit, long windowMillis) {
        this.limit = limit;
        this.windowMillis = windowMillis;
    }

    public boolean allow(String userId) {
        long now = System.currentTimeMillis();
        Window w = windows.compute(userId, (k, old) ->
            (old == null || now - old.start >= windowMillis)
                ? new Window(now) : old);
        return w.count.incrementAndGet() <= limit;
    }

    private static final class Window {
        final long start;
        final AtomicInteger count = new AtomicInteger();
        Window(long start) { this.start = start; }
    }
}

What this small class lets you discuss:

1. Why ConcurrentHashMap.compute and not get-then-put
   (compute is atomic per key, get-then-put is not).
2. Why AtomicInteger for the counter.
3. The fixed-window weakness: a burst at the end of
   one window plus the start of the next can allow
   up to 2x the limit in a short span.
4. What a sliding window or token bucket would fix.
5. Why this only works on ONE instance, and why a
   shared store like Redis is needed for several.
6. Memory: old user entries are never removed.
   How would you clean them up?

@Entity
public class Book {

    @Id @GeneratedValue
    private Long id;

    private int availableCopies;

    @Version
    private long version;

    public void borrow() {
        if (availableCopies <= 0) {
            throw new IllegalStateException("No copies left");
        }
        availableCopies--;
    }
}

// When two transactions load version 5 and both save,
// the second update finds version 6 in the DB and
// Hibernate throws ObjectOptimisticLockingFailureException.

@Test
void onlyOneBorrowWinsForLastCopy() throws Exception {
    Long bookId = createBookWithCopies(1);
    ExecutorService pool = Executors.newFixedThreadPool(10);
    AtomicInteger success = new AtomicInteger();

    List<Callable<Void>> tasks = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        tasks.add(() -> {
            try {
                borrowService.borrow(bookId);
                success.incrementAndGet();
            } catch (Exception ignored) { }
            return null;
        });
    }
    pool.invokeAll(tasks);
    pool.shutdown();

    assertEquals(1, success.get());
}

CONVERSATION TEST (per project)

[ ] Is there a place where two things happen at once?
[ ] Is there input that can be wrong or messy?
[ ] Is there an external call that can fail or be slow?
[ ] Did I make a choice between two real options?
[ ] Can I show a test or measurement as evidence?
[ ] Is the problem in the FIRST resume bullet?

0-2 ticks: likely skipped
3-4 ticks: some conversation
5-6 ticks: interviewers will want to dig in

UPGRADE PLANNER

Project: ______________________

The problem I will add:
  ____________________________________
Why a naive version fails:
  ____________________________________
Technique I will use:
  ____________________________________
Alternative I considered:
  ____________________________________
Test that proves it:
  ____________________________________
New first resume bullet:
  ____________________________________

FOLLOW-UP PREP

Write and say aloud your answer to each:

1. Walk me through how you found this problem.
2. What would happen without your fix?
3. Why this technique and not the other option?
4. How did you test it? What did the test show?
5. What are the limits of your solution?
6. How would it change with several servers?

If you cannot answer 5 and 6, research them before
the interview. They are the most likely deep questions.