What Is Low-Level Design?

Distinguish High-Level from Low-Level Design, understand what companies actually evaluate in an LLD round, and see how the typical interview unfolds.

Concept: two altitudes of design

High-Level Design (HLD) is the 10,000-foot view: services, databases, queues, load balancers, network boundaries. It answers "how do the big boxes talk, and how does this scale to millions of users?"

Low-Level Design (LLD) is the 100-foot view: the classes, interfaces, methods, and relationships inside one of those boxes. It answers "how is this component structured so it's correct, readable, and easy to extend?" LLD is where object-oriented thinking, SOLID, and design patterns live.

The two meet in the middle. In a full system-design interview you sketch the HLD, then the interviewer zooms into one box and says "now design this part properly" — and you're in LLD territory.

Java in action: same feature, two altitudes

HLD says "a Matching service assigns drivers to riders." LLD turns that sentence into types with clear responsibilities — note how the strategy is an interface, so the matching rule can change without touching the service:

// LLD: the "inside" of the matching box, expressed as collaborating objects.
interface MatchingStrategy {
    Driver selectDriver(Rider rider, List<Driver> nearbyDrivers);
}

class NearestDriverStrategy implements MatchingStrategy {
    public Driver selectDriver(Rider rider, List<Driver> nearbyDrivers) {
        return nearbyDrivers.stream()
                .min(Comparator.comparingDouble(d -> distance(rider, d)))
                .orElseThrow(() -> new NoDriverAvailableException(rider.getId()));
    }
    private double distance(Rider r, Driver d) { /* haversine */ return 0; }
}

class MatchingService {
    private final MatchingStrategy strategy;          // depend on the abstraction
    MatchingService(MatchingStrategy strategy) { this.strategy = strategy; }

    Trip assign(Rider rider, List<Driver> nearby) {
        Driver driver = strategy.selectDriver(rider, nearby);
        return new Trip(rider, driver);
    }
}

This is what "good LLD" looks like at a glance: small types, one job each, and a seam (MatchingStrategy) where future change is expected. We'll build up every technique used here over the coming sections.

What companies actually evaluate

Interviewers are not grading whether your code compiles. They score signals:

• Requirement handling — did you clarify before coding, or assume?
• Abstraction — did the right classes and interfaces emerge?
• Extensibility — can a new requirement be added without rewriting everything?
• Communication — did you think out loud and justify trade-offs?
• Pragmatism — did you avoid both under- and over-engineering?

The typical interview flow