Design a hotel booking system

“Design a hotel booking system: guests search for a room, book it for some dates, and can change or cancel.” Often with “and the front desk checks them in” a few minutes later.

The obvious model is a calendar per room: book room 101 from the 10th to the 12th, and check for overlaps. It works until the hotel gets busy. Then it starts turning guests away while rooms sit empty, because the rooms were handed out too early.

A hotel doesn’t really sell room 101. It sells “a double for the nights of the 10th and 11th”. Which double the guest sleeps in is decided when they arrive. That one change, counting room types per night instead of assigning rooms, is what this question is about. Everything else is built on those counts.

The framework

1. 01Answer
2. 02Scope
3. 03Build
4. 04Full design
5. 05Stress
6. 06Wrap up

The answer in one minute

If you only have a minute, this is the design. The rest of the page explains how we get here.

1. A stay is a list of nights. Arriving on the 10th and leaving on the 12th uses the nights of the 10th and 11th. So one guest can leave on the same day the next one arrives.
2. The hotel sells room types per night, not rooms. An inventory counts, for each type and night, how many rooms are sold. A booking takes all its nights or none.
3. The room is chosen at check-in. Any empty room of the type works, and if no night is oversold, an empty one always exists.
4. A change takes the new nights before giving back the old ones. So a change that doesn’t fit leaves the guest with the booking they had.
5. One lock per hotel. Checking and taking a night’s count is one step. So the website, travel agencies and the front desk can’t all sell the last suite.

We’ll build this in four stages, then deal with four channels selling the last room at once.

Scope it

Before drawing anything, we ask a few questions. Each answer changes a class. Anything that doesn’t, we assume and move on.

Interviewerminute 0

Design a hotel booking system.

What they are testing

Whether you focus on one hotel’s rooms quickly, and ask what a guest actually books: a room, or a kind of room. Ten minutes on search filters, reviews and photos leaves no time for the part they will ask about.

Here are the questions that matter:

• Does the guest pick a room, or a type of room? A type (double, suite). The actual room is set when they arrive. Picking a room would make every room its own calendar.
• One hotel or many? One hotel’s booking engine. A platform with many hotels runs one copy of this design per hotel.
• What is a stay? A check-in date and a check-out date. The unit is a night.
• Prices? Per night, set by the hotel, with weekends higher.
• Changes, cancellations, guests who never arrive? All three. Late cancels and no-shows pay for one night.

These answers give us one promise that matters more than the others: no night is ever sold beyond the rooms that exist. That holds even when the website, travel agencies and the front desk book at the same moment. Three smaller promises come with it. A guest with a booking always gets a room at check-in. A failed change leaves the original booking exactly as it was. And every night given up goes back on sale: a cancel, an early checkout, or a no-show.

We leave out search across hotels, payment processing, housekeeping and loyalty programs.

Go deeperThree more questions, and what each changes1 min

Question	We assume	If the answer were different
Overbooking?	Never sell more than exist	Capacity becomes rooms plus an allowance; the counts don’t change
Payment?	A card on file, charged at checkout	Prepaid rates add a charge at booking, with a refund rule
Who books?	Website, travel agencies, front desk	All of them share one inventory, which is the concurrency story

Common mistake

A Room class with a booked flag

Room {isBooked} has no dates. A room is free on Tuesday and taken on Wednesday, so a flag can’t answer “is it free from the 10th to the 12th?”. Availability is about nights, and it belongs to something that knows them.

Build it

We’ll build the design in four stages. Each stage adds only the classes that a new requirement needs. In each diagram, the new parts are outlined, and the colors show what each class does (the key is under every diagram).

Stage 1: Rooms, stays, and a booking that picks a room

Interviewerminute 4

Start simple: a guest wants a double from the 10th to the 12th. What are your classes?

What they are testing

How you represent a date range, and whether one guest leaving on the 12th and another arriving on the 12th count as a clash. An off-by-one error here shows up in every later answer.

Start with the smallest thing that works. A Room is a number and a type. A Stay is a check-in date and a check-out date.

How do we count the nights? Arriving on the 10th and leaving on the 12th uses the nights of the 10th and the 11th, but not the 12th. The check-out day isn’t a night. A range that includes its start but not its end is called half-open. It makes back-to-back stays fit with no special case: the 10th to the 12th and the 12th to the 14th share no night. And the number of nights is simply checkOut - checkIn.

The first Hotel keeps a list of bookings, each naming a room. To book, it looks through the rooms of the requested type, and gives the guest the first one with no overlapping booking.

Stage 1: rooms, stays, and a booking per room

Scroll or pinch to zoom, drag to pan

• Color key
• Facade
• Entity
• Value object
• Enum
• Interface
• Implementation
• New in this step

JHotel.javaPyhotel.pyC#Hotel.csGohotel.goTShotel.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

// A physical room, known by its number. Its type ("double", "suite") decides the price and
// what's in it.
record Room(String number, String type) {}

// The nights from check-in up to, but not including, check-out: arriving on the 10th and
// leaving on the 12th uses the nights of the 10th and the 11th. Half-open ranges let one stay
// end on the day the next begins without a special case.
record Stay(LocalDate checkIn, LocalDate checkOut) {
    boolean isValid() { return checkIn.isBefore(checkOut); }

    boolean overlaps(Stay o) { return checkIn.isBefore(o.checkOut) && o.checkIn.isBefore(checkOut); }

    List<LocalDate> nights() { return checkIn.datesUntil(checkOut).toList(); }
}

record Booking(String id, String guest, Room room, Stay stay) {}

class Hotel {
    private final Map<String, Room> rooms = new LinkedHashMap<>();  // by number
    private final List<Booking> bookings = new ArrayList<>();
    private final Supplier<String> ids;

    Hotel(Supplier<String> ids) { this.ids = ids; }

    void addRoom(Room r) { rooms.put(r.number(), r); }

    // flaw 1: the guest gets a specific room the moment they book, which fragments the calendar.
    // With two doubles: Ana stays Monday night in 101, Ben arrives Monday and leaves Wednesday in
    // 102, and Cy arrives Wednesday and gets 101, empty again by then. Dee wants Tuesday to
    // Thursday and is refused: 101 is free Tuesday night but not Wednesday, and 102 the other way
    // round. No night has more than two guests, and had Cy been given 102, Dee would fit in 101.
    // Stage 2 sells room types per night and picks the room at check-in.
    // flaw 2: every request scans every booking the hotel has ever taken.
    Booking book(String guest, String type, Stay stay) {
        if (!stay.isValid()) return null;
        for (Room r : rooms.values()) {
            if (!r.type().equals(type)) continue;
            boolean free = bookings.stream().noneMatch(b -> b.room().equals(r) && b.stay().overlaps(stay));
            if (free) {
                Booking b = new Booking(ids.get(), guest, r, stay);
                bookings.add(b);
                return b;
            }
        }
        return null;
    }

    // flaw 3: no prices, and no way to change or cancel. Stages 3 and 4.
}

It works, but it has a serious flaw. Assigning the room at booking time turns guests away while rooms are free. Let’s watch it happen with two doubles, 101 and 102, and four bookings in this order:

Booking	Monday	Tuesday	Wednesday	Thursday	Room given
Ana, Monday night	101				101
Ben, Monday to Wednesday	102	102			102
Cy, Wednesday to Friday			101	101	101
Dee, Tuesday to Thursday		101?	102?		refused

Dee is refused, even though no night has more than two guests. Room 101 is free on Tuesday but not Wednesday, and 102 the other way round. If Cy had been given 102, Dee would fit in 101.

There are two smaller problems too: every request looks through every booking the hotel has ever taken, and there are no prices, changes or cancellations.

Stage 2: Sell nights per room type, and pick the room at check-in

Interviewerminute 8

Your design just refused Dee with a room free every night. Fix it.

What they are testing

Whether you see that the room shouldn’t be fixed until arrival, and can say why a room will always be free then. Moving existing bookings between rooms to make space is the answer they hear most, and it gets complicated fast.

The guest is promised a double, not room 101, so that’s all the booking should record.

An Inventory keeps, for each room type, how many rooms exist, and how many are sold on each night. Booking a stay checks that every one of its nights has a room left, then adds one to each night’s count, all or nothing. The result is a Reservation: a guest, a room type, a stay, and a status. It has no room yet.

The room is chosen at check-in, and any empty room of the type will do. That sounds hopeful, but it’s guaranteed. Here’s why. On the day Dee arrives, everyone already sleeping in a double tonight holds one of tonight’s sold doubles, and Dee holds another. Tonight isn’t oversold, so fewer doubles are taken than exist. So at least one is empty. Picking a room at arrival can never get stuck, and that’s why the counts are the only thing a booking needs to check.

If check-in ever finds no room, the counts themselves are wrong. So the code throws an error rather than returning a polite answer: it’s a bug, not a normal situation.

Stage 2: an inventory of nights, and reservations without rooms

Scroll or pinch to zoom, drag to pan

• Color key
• Facade
• Entity
• Value object
• Enum
• Interface
• Implementation
• New in this step

JHotel.javaPyhotel.pyC#Hotel.csGohotel.goTShotel.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

// What the hotel sells is a type of room for a set of nights, so that is what it counts:
// for each type, how many rooms exist and how many are sold on each night.
class Inventory {
    private final Map<String, Integer> capacity = new HashMap<>();             // type -> rooms
    private final Map<String, Map<LocalDate, Integer>> sold = new HashMap<>();  // type -> night -> sold

    void addRoom(String type) { capacity.merge(type, 1, Integer::sum); }

    boolean sells(String type) { return capacity.containsKey(type); }

    int free(String type, LocalDate night) {
        return capacity.getOrDefault(type, 0) - sold.getOrDefault(type, Map.of()).getOrDefault(night, 0);
    }

    // All or nothing: check every night, then take every night.
    boolean take(String type, List<LocalDate> nights) {
        for (LocalDate n : nights) if (free(type, n) <= 0) return false;
        Map<LocalDate, Integer> m = sold.computeIfAbsent(type, k -> new HashMap<>());
        for (LocalDate n : nights) m.merge(n, 1, Integer::sum);
        return true;
    }

    // The opposite of take: these nights are on sale again.
    void give(String type, List<LocalDate> nights) {
        Map<LocalDate, Integer> m = sold.get(type);
        for (LocalDate n : nights) m.merge(n, -1, (a, b) -> a + b == 0 ? null : a + b);  // drop zeros
    }
}

enum Status { BOOKED, CHECKED_IN, CHECKED_OUT }

// A promise of a room of some type for some nights. Which room is decided at check-in.
class Reservation {
    final String id;
    final String guest;
    String type;
    Stay stay;
    Status status = Status.BOOKED;
    Room room;  // null until check-in

    Reservation(String id, String guest, String type, Stay stay) {
        this.id = id;
        this.guest = guest;
        this.type = type;
        this.stay = stay;
    }
}

// What a request gets back. TOO_EARLY and TOO_LATE are about the day of check-in.
enum Result { OK, INVALID_DATES, NO_SUCH_TYPE, SOLD_OUT, NO_SUCH_RESERVATION, WRONG_STATUS, TOO_EARLY, TOO_LATE }

// The result, plus the new reservation when it is OK.
record ReserveResult(Result result, Reservation reservation) {}

class Hotel {
    private final List<Room> rooms = new ArrayList<>();
    private final Inventory inventory = new Inventory();
    private final Map<String, Reservation> reservations = new HashMap<>();
    private final Map<String, Reservation> inHouse = new HashMap<>();  // room number -> guest in it
    private final Supplier<String> ids;
    private final Supplier<LocalDate> clock;  // the hotel's local date, injected for tests

    Hotel(Supplier<String> ids, Supplier<LocalDate> clock) {
        this.ids = ids;
        this.clock = clock;
    }

    void addRoom(Room r) {
        rooms.add(r);
        inventory.addRoom(r.type());
    }

    ReserveResult reserve(String guest, String type, Stay stay) {
        if (!stay.isValid() || stay.checkIn().isBefore(clock.get())) return new ReserveResult(Result.INVALID_DATES, null);
        if (!inventory.sells(type)) return new ReserveResult(Result.NO_SUCH_TYPE, null);
        if (!inventory.take(type, stay.nights())) return new ReserveResult(Result.SOLD_OUT, null);
        Reservation r = new Reservation(ids.get(), guest, type, stay);
        reservations.put(r.id, r);
        return new ReserveResult(Result.OK, r);
    }

    // The room is chosen when the guest arrives, and any vacant room of the type will do. Every
    // guest in the house tonight holds one of tonight's sold rooms, and so does this guest, so
    // if tonight isn't oversold a vacant room exists. The exception would mean the counts are
    // wrong, not bad luck.
    Result checkIn(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        if (today.isBefore(r.stay.checkIn())) return Result.TOO_EARLY;
        if (!today.isBefore(r.stay.checkOut())) return Result.TOO_LATE;
        Room room = rooms.stream().filter(x -> x.type().equals(r.type) && isVacant(x, today)).findFirst()
            .orElseThrow(() -> new IllegalStateException("inventory says a " + r.type + " is free, rooms disagree"));
        r.room = room;
        r.status = Status.CHECKED_IN;
        inHouse.put(room.number(), r);
        return Result.OK;
    }

    Result checkOut(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.CHECKED_IN) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        inHouse.remove(r.room.number());
        r.status = Status.CHECKED_OUT;
        // Leaving early gives the remaining nights back to sell.
        if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
        return Result.OK;
    }

    // A room is vacant tonight if nobody in it is staying tonight. A guest due out today may
    // still be packing; housekeeping has the room ready by the afternoon.
    private boolean isVacant(Room room, LocalDate night) {
        Reservation r = inHouse.get(room.number());
        return r == null || !r.stay.checkOut().isAfter(night);
    }

    int free(String type, LocalDate night) { return inventory.free(type, night); }
}

A room counts as empty tonight if nobody in it is staying tonight. A guest due to leave today may still be packing at 10am, but housekeeping will have the room ready for the afternoon arrival. And a guest who leaves early gives their remaining nights back to the inventory, so they can be sold again tonight.

What does this cost? A guest can’t be promised a specific room when they book. Hotels that sell “room 1408, with the view” treat that one room as its own type, with a capacity of one.

Go deeperDee checks in on Tuesday, step by step1 min

Dee arrives. The front desk asks the hotel to check her in. The hotel looks at the doubles: Ben is in 102 tonight, and 101 has nobody staying tonight (Ana left Tuesday morning). So Dee gets 101, and her reservation’s status becomes “checked in”. On Wednesday, Cy arrives and gets whichever double is empty then.

Sequence: Dee checks in on Tuesday

Scroll or pinch to zoom, drag to pan

• Color key
• Facade

Stage 3: Prices per night, and changing a booking

Interviewerminute 14

Weekend nights cost more. And a guest booked Tuesday to Thursday wants to move to Wednesday to Friday. The hotel is full on Wednesday. What happens?

What they are testing

Whether the price is per night rather than per stay, and whether you change a booking by cancelling and rebooking. Cancel first, and a change that fails has lost the guest their room. Rebook first, and a full Wednesday refuses a change that only needs Thursday.

First, prices. A RatePlan answers one question: what does one night of this type cost? The standard plan adds a quarter on Friday and Saturday nights. It’s the Strategy pattern: the hotel can swap in another plan. Hotels change their rates all the time, so the reservation stores the price quoted for each night when it was made. The guest pays what they agreed to.

Now the change, which is where the obvious code goes wrong. “Cancel, then book again” can be done in two orders, and both are bad:

• Give back the old nights first. If the new ones don’t fit, someone else may already have taken the old ones. The guest has lost their booking just by asking to change it.
• Take the new nights first, as a separate booking. Say we move Tuesday–Thursday to Wednesday–Friday. Then we need Wednesday twice: once for the old booking, and once for the new. A full hotel can’t give that.

So modify works with the difference. Old stay: Tuesday and Wednesday nights. New stay: Wednesday and Thursday nights. Wednesday is already held. So modify only takes Thursday. Only once Thursday is safely taken does it give back Tuesday. If taking Thursday fails, nothing has changed, and the guest keeps their original booking.

A change of room type works the same way. Take all the new nights of the new type first. Then give back all the old nights of the old type.

Stage 3: a rate plan, and quoted nights

Scroll or pinch to zoom, drag to pan

• Color key
• Facade
• Entity
• Value object
• Enum
• Interface
• Implementation
• New in this step

JHotel.javaPyhotel.pyC#Hotel.csGohotel.goTShotel.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

// Prices change by night: weekends cost more, and a hotel adjusts rates constantly. The rate
// plan answers "what does one night of this type cost?", and a stay is the sum of its nights.
interface RatePlan {
    long nightlyRate(String type, LocalDate night);  // in cents
}

// One hotel's prices: a base rate per room type, and more for weekend nights.
class StandardRates implements RatePlan {
    private final Map<String, Long> base;

    StandardRates(Map<String, Long> base) { this.base = base; }

    // Friday and Saturday nights cost a quarter more.
    public long nightlyRate(String type, LocalDate night) {
        long rate = base.get(type);
        DayOfWeek d = night.getDayOfWeek();
        return d == DayOfWeek.FRIDAY || d == DayOfWeek.SATURDAY ? rate * 5 / 4 : rate;
    }
}

class Reservation {
    final String id;
    final String guest;
    String type;
    Stay stay;
    List<Long> rates;  // quoted per night when booked or changed; the guest pays what they agreed to
    Status status = Status.BOOKED;
    Room room;

    Reservation(String id, String guest, String type, Stay stay, List<Long> rates) {
        this.id = id;
        this.guest = guest;
        this.type = type;
        this.stay = stay;
        this.rates = rates;
    }

    long total() { return rates.stream().mapToLong(Long::longValue).sum(); }
}

class Hotel {
    private final List<Room> rooms = new ArrayList<>();
    private final Inventory inventory = new Inventory();
    private final Map<String, Reservation> reservations = new HashMap<>();
    private final Map<String, Reservation> inHouse = new HashMap<>();
    private final RatePlan rates;
    private final Supplier<String> ids;
    private final Supplier<LocalDate> clock;

    Hotel(RatePlan rates, Supplier<String> ids, Supplier<LocalDate> clock) {
        this.rates = rates;
        this.ids = ids;
        this.clock = clock;
    }

    void addRoom(Room r) {
        rooms.add(r);
        inventory.addRoom(r.type());
    }

    ReserveResult reserve(String guest, String type, Stay stay) {
        Result bad = check(type, stay);
        if (bad != Result.OK) return new ReserveResult(bad, null);
        if (!inventory.take(type, stay.nights())) return new ReserveResult(Result.SOLD_OUT, null);
        Reservation r = new Reservation(ids.get(), guest, type, stay, quote(type, stay));
        reservations.put(r.id, r);
        return new ReserveResult(Result.OK, r);
    }

    // Change the dates or the room type. Take the nights the new stay needs that the old one
    // doesn't already hold, and only then give back the nights it no longer needs. If the new
    // nights aren't free, nothing has changed and the guest keeps the original booking. Moving
    // Tuesday-Thursday to Wednesday-Friday needs only Thursday night, so it works even when the
    // hotel is full on Wednesday.
    Result modify(String reservationId, String newType, Stay newStay) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        Result bad = check(newType, newStay);
        if (bad != Result.OK) return bad;
        boolean sameType = newType.equals(r.type);
        List<LocalDate> oldNights = r.stay.nights();
        List<LocalDate> newNights = newStay.nights();
        List<LocalDate> toTake = sameType ? minus(newNights, oldNights) : newNights;
        List<LocalDate> toGive = sameType ? minus(oldNights, newNights) : oldNights;
        if (!inventory.take(newType, toTake)) return Result.SOLD_OUT;
        inventory.give(r.type, toGive);
        r.type = newType;
        r.stay = newStay;
        r.rates = quote(newType, newStay);
        return Result.OK;
    }

    Result checkIn(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        if (today.isBefore(r.stay.checkIn())) return Result.TOO_EARLY;
        if (!today.isBefore(r.stay.checkOut())) return Result.TOO_LATE;
        Room room = rooms.stream().filter(x -> x.type().equals(r.type) && isVacant(x, today)).findFirst()
            .orElseThrow(() -> new IllegalStateException("inventory says a " + r.type + " is free, rooms disagree"));
        r.room = room;
        r.status = Status.CHECKED_IN;
        inHouse.put(room.number(), r);
        return Result.OK;
    }

    Result checkOut(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.CHECKED_IN) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        inHouse.remove(r.room.number());
        r.status = Status.CHECKED_OUT;
        if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
        return Result.OK;
    }

    int free(String type, LocalDate night) { return inventory.free(type, night); }

    private Result check(String type, Stay stay) {
        if (!stay.isValid() || stay.checkIn().isBefore(clock.get())) return Result.INVALID_DATES;
        if (!inventory.sells(type)) return Result.NO_SUCH_TYPE;
        return Result.OK;
    }

    private List<Long> quote(String type, Stay stay) {
        return stay.nights().stream().map(n -> rates.nightlyRate(type, n)).toList();
    }

    private boolean isVacant(Room room, LocalDate night) {
        Reservation r = inHouse.get(room.number());
        return r == null || !r.stay.checkOut().isAfter(night);
    }

    private static List<LocalDate> minus(List<LocalDate> a, List<LocalDate> b) {
        Set<LocalDate> drop = new HashSet<>(b);
        return a.stream().filter(n -> !drop.contains(n)).toList();
    }
}

Common mistake

Modify as cancel, then reserve

It’s two lines, and reads naturally. But on a busy night, the cancel frees the room. Another website sells it in the gap, and the reserve fails. Now the guest who only wanted one more night has no booking at all. A change must never leave the guest worse off than not asking.

Go deeperThe move, step by step1 min

The guest holds Tuesday and Wednesday and asks for Wednesday and Thursday. The hotel works out the difference: Thursday is new, Tuesday is no longer needed, Wednesday stays. It asks the inventory to take Thursday. Only if that works does it give back Tuesday, then update the reservation’s stay and its list of quoted prices. If Thursday were full, the answer would be SOLD_OUT, and the guest would still hold Tuesday and Wednesday, exactly as before. At no moment did the guest hold fewer nights than they started with.

Sequence: moving Tuesday to Thursday into Wednesday to Friday

Scroll or pinch to zoom, drag to pan

• Color key
• Entity
• Facade

Go deeperWhy store a price per night, not a total?1 min

Because a change keeps some nights and drops others, and a no-show or a late cancel pays for one night. With only a total, both would need the price of a single night, which may have changed since booking. With a list, the first night’s price is simply the first item.

Stage 4: Cancellations and no-shows

Interviewerminute 20

Guests can cancel for free until two days before arrival. After that, they pay the first night. And some guests just never turn up. Add both.

What they are testing

Whether the cancellation rule is a policy. Whether every way of giving up nights returns them to the inventory. And whether a no-show’s nights from today on are put back on sale. Forgetting the no-show leaves rooms empty for the rest of a stay nobody is using.

The deadline for free cancellation belongs to the hotel, and changes by season and rate. So it’s a CancellationPolicy that the hotel asks, with the reservation and today’s date (Strategy again). Cancelling records the fee, marks the reservation cancelled, and gives every night back. A second cancel finds it already cancelled, so the nights are only given back once.

A no-show is a guest due yesterday or earlier who never checked in. A job each morning finds them, charges the first night, and gives back the nights from today on, so the room can be sold tonight. Running the job twice changes nothing the second time, because it only looks at reservations still waiting for their guest.

Every way a reservation can end now gives back exactly the nights it won’t use:

Stage 4: a reservation's life

Scroll or pinch to zoom, drag to pan

• Color key
• State
• Ends well

Stage 4: a cancellation policy and a fee

Scroll or pinch to zoom, drag to pan

• Color key
• Facade
• Entity
• Value object
• Enum
• Interface
• Implementation
• New in this step

JHotel.javaPyhotel.pyC#Hotel.csGohotel.goTShotel.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

// A reservation's life. CANCELLED and NO_SHOW keep the record, with any fee charged.
enum Status { BOOKED, CHECKED_IN, CHECKED_OUT, CANCELLED, NO_SHOW }

// One guest's booking: a room type for a stay. The room itself is chosen at check-in. rates
// holds each night's price, fixed when booked.
class Reservation {
    final String id;
    final String guest;
    String type;
    Stay stay;
    List<Long> rates;
    Status status = Status.BOOKED;
    Room room;
    long fee;  // charged to the card on file for a late cancellation or a no-show

    Reservation(String id, String guest, String type, Stay stay, List<Long> rates) {
        this.id = id;
        this.guest = guest;
        this.type = type;
        this.stay = stay;
        this.rates = rates;
    }

    long total() { return rates.stream().mapToLong(Long::longValue).sum(); }
}

// Hotels set the deadline for free cancellation, and change it by season and rate, so it's a
// policy the hotel asks.
interface CancellationPolicy {
    long feeFor(Reservation r, LocalDate today);  // in cents; 0 means free
}

// Free until two days before arrival; after that, the first night.
class StandardCancellation implements CancellationPolicy {
    public long feeFor(Reservation r, LocalDate today) {
        long daysBefore = ChronoUnit.DAYS.between(today, r.stay.checkIn());
        return daysBefore >= 2 ? 0 : r.rates.get(0);
    }
}

// The front desk and the booking site both go through here. The inventory answers "is there a
// room?"; actual rooms are given out only at check-in.
class Hotel {
    private final List<Room> rooms = new ArrayList<>();
    private final Inventory inventory = new Inventory();
    private final Map<String, Reservation> reservations = new HashMap<>();
    private final Map<String, Reservation> inHouse = new HashMap<>();  // room number -> guest staying now
    private final RatePlan rates;
    private final CancellationPolicy cancellations;
    private final Supplier<String> ids;
    private final Supplier<LocalDate> clock;

    Hotel(RatePlan rates, CancellationPolicy cancellations, Supplier<String> ids, Supplier<LocalDate> clock) {
        this.rates = rates;
        this.cancellations = cancellations;
        this.ids = ids;
        this.clock = clock;
    }

    void addRoom(Room r) {
        rooms.add(r);
        inventory.addRoom(r.type());
    }

    ReserveResult reserve(String guest, String type, Stay stay) {
        Result bad = check(type, stay);
        if (bad != Result.OK) return new ReserveResult(bad, null);
        if (!inventory.take(type, stay.nights())) return new ReserveResult(Result.SOLD_OUT, null);
        Reservation r = new Reservation(ids.get(), guest, type, stay, quote(type, stay));
        reservations.put(r.id, r);
        return new ReserveResult(Result.OK, r);
    }

    // Change the dates or the room type. Take the nights the new stay needs that the old one
    // doesn't already hold, and only then give back the nights it no longer needs. If the new
    // nights aren't free, nothing has changed and the guest keeps the original booking. Moving
    // Tuesday-Thursday to Wednesday-Friday needs only Thursday night, so it works even when the
    // hotel is full on Wednesday.
    Result modify(String reservationId, String newType, Stay newStay) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        Result bad = check(newType, newStay);
        if (bad != Result.OK) return bad;
        boolean sameType = newType.equals(r.type);
        List<LocalDate> oldNights = r.stay.nights();
        List<LocalDate> newNights = newStay.nights();
        List<LocalDate> toTake = sameType ? minus(newNights, oldNights) : newNights;
        List<LocalDate> toGive = sameType ? minus(oldNights, newNights) : oldNights;
        if (!inventory.take(newType, toTake)) return Result.SOLD_OUT;
        inventory.give(r.type, toGive);
        r.type = newType;
        r.stay = newStay;
        r.rates = quote(newType, newStay);
        return Result.OK;
    }

    // Only on a night of the stay. Any vacant room of the booked type will do: this is where a
    // reservation becomes a room.
    Result checkIn(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        if (today.isBefore(r.stay.checkIn())) return Result.TOO_EARLY;
        if (!today.isBefore(r.stay.checkOut())) return Result.TOO_LATE;
        Room room = rooms.stream().filter(x -> x.type().equals(r.type) && isVacant(x, today)).findFirst()
            .orElseThrow(() -> new IllegalStateException("inventory says a " + r.type + " is free, rooms disagree"));
        r.room = room;
        r.status = Status.CHECKED_IN;
        inHouse.put(room.number(), r);
        return Result.OK;
    }

    // Leaving early puts the unused nights back on sale.
    Result checkOut(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.CHECKED_IN) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        inHouse.remove(r.room.number());
        r.status = Status.CHECKED_OUT;
        if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
        return Result.OK;
    }

    // The nights go back on sale and the policy decides the fee. Cancelling twice finds the
    // reservation already cancelled, so the nights are given back once.
    Result cancel(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        r.fee = cancellations.feeFor(r, clock.get());
        r.status = Status.CANCELLED;
        inventory.give(r.type, r.stay.nights());
        return Result.OK;
    }

    // Run each morning. A guest who was due yesterday or earlier and never arrived is a no-show:
    // they're charged the first night, and the nights from today on go back on sale so the
    // room can be sold tonight. Running it twice changes nothing the second time.
    int markNoShows() {
        LocalDate today = clock.get();
        int marked = 0;
        for (Reservation r : reservations.values()) {
            if (r.status != Status.BOOKED || !r.stay.checkIn().isBefore(today)) continue;
            r.status = Status.NO_SHOW;
            r.fee = r.rates.get(0);
            if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
            marked++;
        }
        return marked;
    }

    int free(String type, LocalDate night) { return inventory.free(type, night); }

    // What every new or changed booking needs: real dates, not in the past, a type we sell.
    private Result check(String type, Stay stay) {
        if (!stay.isValid() || stay.checkIn().isBefore(clock.get())) return Result.INVALID_DATES;
        if (!inventory.sells(type)) return Result.NO_SUCH_TYPE;
        return Result.OK;
    }

    // Each night's price, fixed now, so a later rate change doesn't touch this booking.
    private List<Long> quote(String type, Stay stay) {
        return stay.nights().stream().map(n -> rates.nightlyRate(type, n)).toList();
    }

    // Free tonight if nobody is in it, or the guest in it leaves today.
    private boolean isVacant(Room room, LocalDate night) {
        Reservation r = inHouse.get(room.number());
        return r == null || !r.stay.checkOut().isAfter(night);
    }

    // The nights in a that aren't in b.
    private static List<LocalDate> minus(List<LocalDate> a, List<LocalDate> b) {
        Set<LocalDate> drop = new HashSet<>(b);
        return a.stream().filter(n -> !drop.contains(n)).toList();
    }
}

This is enough for a mid-level answer. Stays are half-open. Room types are sold per night, all or nothing. And the room is chosen at check-in. The rest of the page is what makes it a senior answer.

The full design

Here is everything together. Each class is here because a requirement needed it. Rooms appear only at check-in.

Hotel booking: full class diagram

Scroll or pinch to zoom, drag to pan

• Color key
• Facade
• Entity
• Value object
• Enum
• Interface
• Implementation

</>hotel-booking· read only

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

Explorer

• JAllInOne.java
• src
• JCancellationPolicy.java
• JHotel.java
• JInventory.java
• JRatePlan.java
• JReservation.java
• JReserveResult.java
• JResult.java
• JRoom.java
• JSharedHotel.java
• JStandardCancellation.java
• JStandardRates.java
• JStatus.java
• JStay.java

JAllInOne.java

AllInOne.javasrc/CancellationPolicy.javasrc/Hotel.javasrc/Inventory.javasrc/RatePlan.javasrc/Reservation.javasrc/ReserveResult.javasrc/Result.javasrc/Room.javasrc/SharedHotel.javasrc/StandardCancellation.javasrc/StandardRates.javasrc/Status.javasrc/Stay.java

AllInOne.java

// The complete design, built from every stage on this page.

import java.util.*;
import java.util.concurrent.locks.*;
import java.util.function.*;
import java.time.*;
import java.time.temporal.*;

// A physical room, known by its number. Its type ("double", "suite") decides the price and
// what's in it.
record Room(String number, String type) {}

// The nights from check-in up to, but not including, check-out: arriving on the 10th and
// leaving on the 12th uses the nights of the 10th and the 11th. Half-open ranges let one stay
// end on the day the next begins without a special case.
record Stay(LocalDate checkIn, LocalDate checkOut) {
    boolean isValid() { return checkIn.isBefore(checkOut); }

    boolean overlaps(Stay o) { return checkIn.isBefore(o.checkOut) && o.checkIn.isBefore(checkOut); }

    List<LocalDate> nights() { return checkIn.datesUntil(checkOut).toList(); }
}

// The front desk and the booking site both go through here. The inventory answers "is there a
// room?"; actual rooms are given out only at check-in.
class Hotel {
    private final List<Room> rooms = new ArrayList<>();
    private final Inventory inventory = new Inventory();
    private final Map<String, Reservation> reservations = new HashMap<>();
    private final Map<String, Reservation> inHouse = new HashMap<>();  // room number -> guest staying now
    private final RatePlan rates;
    private final CancellationPolicy cancellations;
    private final Supplier<String> ids;
    private final Supplier<LocalDate> clock;

    Hotel(RatePlan rates, CancellationPolicy cancellations, Supplier<String> ids, Supplier<LocalDate> clock) {
        this.rates = rates;
        this.cancellations = cancellations;
        this.ids = ids;
        this.clock = clock;
    }

    void addRoom(Room r) {
        rooms.add(r);
        inventory.addRoom(r.type());
    }

    ReserveResult reserve(String guest, String type, Stay stay) {
        Result bad = check(type, stay);
        if (bad != Result.OK) return new ReserveResult(bad, null);
        if (!inventory.take(type, stay.nights())) return new ReserveResult(Result.SOLD_OUT, null);
        Reservation r = new Reservation(ids.get(), guest, type, stay, quote(type, stay));
        reservations.put(r.id, r);
        return new ReserveResult(Result.OK, r);
    }

    // Change the dates or the room type. Take the nights the new stay needs that the old one
    // doesn't already hold, and only then give back the nights it no longer needs. If the new
    // nights aren't free, nothing has changed and the guest keeps the original booking. Moving
    // Tuesday-Thursday to Wednesday-Friday needs only Thursday night, so it works even when the
    // hotel is full on Wednesday.
    Result modify(String reservationId, String newType, Stay newStay) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        Result bad = check(newType, newStay);
        if (bad != Result.OK) return bad;
        boolean sameType = newType.equals(r.type);
        List<LocalDate> oldNights = r.stay.nights();
        List<LocalDate> newNights = newStay.nights();
        List<LocalDate> toTake = sameType ? minus(newNights, oldNights) : newNights;
        List<LocalDate> toGive = sameType ? minus(oldNights, newNights) : oldNights;
        if (!inventory.take(newType, toTake)) return Result.SOLD_OUT;
        inventory.give(r.type, toGive);
        r.type = newType;
        r.stay = newStay;
        r.rates = quote(newType, newStay);
        return Result.OK;
    }

    // Only on a night of the stay. Any vacant room of the booked type will do: this is where a
    // reservation becomes a room.
    Result checkIn(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        if (today.isBefore(r.stay.checkIn())) return Result.TOO_EARLY;
        if (!today.isBefore(r.stay.checkOut())) return Result.TOO_LATE;
        Room room = rooms.stream().filter(x -> x.type().equals(r.type) && isVacant(x, today)).findFirst()
            .orElseThrow(() -> new IllegalStateException("inventory says a " + r.type + " is free, rooms disagree"));
        r.room = room;
        r.status = Status.CHECKED_IN;
        inHouse.put(room.number(), r);
        return Result.OK;
    }

    // Leaving early puts the unused nights back on sale.
    Result checkOut(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.CHECKED_IN) return Result.WRONG_STATUS;
        LocalDate today = clock.get();
        inHouse.remove(r.room.number());
        r.status = Status.CHECKED_OUT;
        if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
        return Result.OK;
    }

    // The nights go back on sale and the policy decides the fee. Cancelling twice finds the
    // reservation already cancelled, so the nights are given back once.
    Result cancel(String reservationId) {
        Reservation r = reservations.get(reservationId);
        if (r == null) return Result.NO_SUCH_RESERVATION;
        if (r.status != Status.BOOKED) return Result.WRONG_STATUS;
        r.fee = cancellations.feeFor(r, clock.get());
        r.status = Status.CANCELLED;
        inventory.give(r.type, r.stay.nights());
        return Result.OK;
    }

    // Run each morning. A guest who was due yesterday or earlier and never arrived is a no-show:
    // they're charged the first night, and the nights from today on go back on sale so the
    // room can be sold tonight. Running it twice changes nothing the second time.
    int markNoShows() {
        LocalDate today = clock.get();
        int marked = 0;
        for (Reservation r : reservations.values()) {
            if (r.status != Status.BOOKED || !r.stay.checkIn().isBefore(today)) continue;
            r.status = Status.NO_SHOW;
            r.fee = r.rates.get(0);
            if (today.isBefore(r.stay.checkOut())) inventory.give(r.type, new Stay(today, r.stay.checkOut()).nights());
            marked++;
        }
        return marked;
    }

    int free(String type, LocalDate night) { return inventory.free(type, night); }

    // What every new or changed booking needs: real dates, not in the past, a type we sell.
    private Result check(String type, Stay stay) {
        if (!stay.isValid() || stay.checkIn().isBefore(clock.get())) return Result.INVALID_DATES;
        if (!inventory.sells(type)) return Result.NO_SUCH_TYPE;
        return Result.OK;
    }

    // Each night's price, fixed now, so a later rate change doesn't touch this booking.
    private List<Long> quote(String type, Stay stay) {
        return stay.nights().stream().map(n -> rates.nightlyRate(type, n)).toList();
    }

    // Free tonight if nobody is in it, or the guest in it leaves today.
    private boolean isVacant(Room room, LocalDate night) {
        Reservation r = inHouse.get(room.number());
        return r == null || !r.stay.checkOut().isAfter(night);
    }

    // The nights in a that aren't in b.
    private static List<LocalDate> minus(List<LocalDate> a, List<LocalDate> b) {
        Set<LocalDate> drop = new HashSet<>(b);
        return a.stream().filter(n -> !drop.contains(n)).toList();
    }
}

// What the hotel sells is a type of room for a set of nights, so that is what it counts:
// for each type, how many rooms exist and how many are sold on each night.
class Inventory {
    private final Map<String, Integer> capacity = new HashMap<>();             // type -> rooms
    private final Map<String, Map<LocalDate, Integer>> sold = new HashMap<>();  // type -> night -> sold

    void addRoom(String type) { capacity.merge(type, 1, Integer::sum); }

    boolean sells(String type) { return capacity.containsKey(type); }

    int free(String type, LocalDate night) {
        return capacity.getOrDefault(type, 0) - sold.getOrDefault(type, Map.of()).getOrDefault(night, 0);
    }

    // All or nothing: check every night, then take every night.
    boolean take(String type, List<LocalDate> nights) {
        for (LocalDate n : nights) if (free(type, n) <= 0) return false;
        Map<LocalDate, Integer> m = sold.computeIfAbsent(type, k -> new HashMap<>());
        for (LocalDate n : nights) m.merge(n, 1, Integer::sum);
        return true;
    }

    // The opposite of take: these nights are on sale again.
    void give(String type, List<LocalDate> nights) {
        Map<LocalDate, Integer> m = sold.get(type);
        for (LocalDate n : nights) m.merge(n, -1, (a, b) -> a + b == 0 ? null : a + b);  // drop zeros
    }
}

// A reservation's life. CANCELLED and NO_SHOW keep the record, with any fee charged.
enum Status { BOOKED, CHECKED_IN, CHECKED_OUT, CANCELLED, NO_SHOW }

// One guest's booking: a room type for a stay. The room itself is chosen at check-in. rates
// holds each night's price, fixed when booked.
class Reservation {
    final String id;
    final String guest;
    String type;
    Stay stay;
    List<Long> rates;
    Status status = Status.BOOKED;
    Room room;
    long fee;  // charged to the card on file for a late cancellation or a no-show

    Reservation(String id, String guest, String type, Stay stay, List<Long> rates) {
        this.id = id;
        this.guest = guest;
        this.type = type;
        this.stay = stay;
        this.rates = rates;
    }

    long total() { return rates.stream().mapToLong(Long::longValue).sum(); }
}

// What a request gets back. TOO_EARLY and TOO_LATE are about the day of check-in.
enum Result { OK, INVALID_DATES, NO_SUCH_TYPE, SOLD_OUT, NO_SUCH_RESERVATION, WRONG_STATUS, TOO_EARLY, TOO_LATE }

// The result, plus the new reservation when it is OK.
record ReserveResult(Result result, Reservation reservation) {}

// Prices change by night: weekends cost more, and a hotel adjusts rates constantly. The rate
// plan answers "what does one night of this type cost?", and a stay is the sum of its nights.
interface RatePlan {
    long nightlyRate(String type, LocalDate night);  // in cents
}

// One hotel's prices: a base rate per room type, and more for weekend nights.
class StandardRates implements RatePlan {
    private final Map<String, Long> base;

    StandardRates(Map<String, Long> base) { this.base = base; }

    // Friday and Saturday nights cost a quarter more.
    public long nightlyRate(String type, LocalDate night) {
        long rate = base.get(type);
        DayOfWeek d = night.getDayOfWeek();
        return d == DayOfWeek.FRIDAY || d == DayOfWeek.SATURDAY ? rate * 5 / 4 : rate;
    }
}

// Hotels set the deadline for free cancellation, and change it by season and rate, so it's a
// policy the hotel asks.
interface CancellationPolicy {
    long feeFor(Reservation r, LocalDate today);  // in cents; 0 means free
}

// Free until two days before arrival; after that, the first night.
class StandardCancellation implements CancellationPolicy {
    public long feeFor(Reservation r, LocalDate today) {
        long daysBefore = ChronoUnit.DAYS.between(today, r.stay.checkIn());
        return daysBefore >= 2 ? 0 : r.rates.get(0);
    }
}

// The website, a travel agency's feed and the front desk all book the same hotel at once. Two
// requests for the last double on Friday both find free("double", Friday) == 1 and both take
// it, and the hotel has sold a room it doesn't have. Every operation reads counts, then
// changes them, so each must run alone. One hotel takes a few bookings a minute, so one lock
// per hotel is plenty; a booking platform runs many hotels side by side, and they never
// share a lock.
class SharedHotel {
    private final Hotel hotel;
    private final ReentrantLock lock = new ReentrantLock();

    SharedHotel(Hotel hotel) { this.hotel = hotel; }

    ReserveResult reserve(String guest, String type, Stay stay) { return locked(() -> hotel.reserve(guest, type, stay)); }
    Result modify(String id, String type, Stay stay) { return locked(() -> hotel.modify(id, type, stay)); }
    Result cancel(String id) { return locked(() -> hotel.cancel(id)); }
    Result checkIn(String id) { return locked(() -> hotel.checkIn(id)); }
    Result checkOut(String id) { return locked(() -> hotel.checkOut(id)); }
    int markNoShows() { return locked(hotel::markNoShows); }
    int free(String type, LocalDate night) { return locked(() -> hotel.free(type, night)); }

    // Runs one operation with the lock held. finally releases it even if the operation throws.
    private <T> T locked(Supplier<T> op) {
        lock.lock();
        try {
            return op.get();
        } finally {
            lock.unlock();
        }
    }
}

Read onlyJava 21Every file builds in CI14 files289 lines

Explorer

• Pyall_in_one.py
• hotel_booking
• Pycancellation_policy.py
• Pyhotel.py
• Pyinventory.py
• Pyrate_plan.py
• Pyreservation.py
• Pyresult.py
• Pyroom.py
• Pyshared_hotel.py
• Pystandard_cancellation.py
• Pystandard_rates.py
• Pystatus.py
• Pystay.py

Pyall_in_one.py

all_in_one.pyhotel_booking/cancellation_policy.pyhotel_booking/hotel.pyhotel_booking/inventory.pyhotel_booking/rate_plan.pyhotel_booking/reservation.pyhotel_booking/result.pyhotel_booking/room.pyhotel_booking/shared_hotel.pyhotel_booking/standard_cancellation.pyhotel_booking/standard_rates.pyhotel_booking/status.pyhotel_booking/stay.py

all_in_one.py

Read onlyPython 3.12Every file builds in CI13 files313 lines

Explorer

• C#AllInOne.cs
• src
• C#Hotel.cs
• C#ICancellationPolicy.cs
• C#Inventory.cs
• C#IRatePlan.cs
• C#Reservation.cs
• C#Result.cs
• C#Room.cs
• C#SharedHotel.cs
• C#StandardCancellation.cs
• C#StandardRates.cs
• C#Status.cs
• C#Stay.cs

C#AllInOne.cs

AllInOne.cssrc/Hotel.cssrc/ICancellationPolicy.cssrc/Inventory.cssrc/IRatePlan.cssrc/Reservation.cssrc/Result.cssrc/Room.cssrc/SharedHotel.cssrc/StandardCancellation.cssrc/StandardRates.cssrc/Status.cssrc/Stay.cs

AllInOne.cs

Read onlyC# · .NET 10Every file builds in CI13 files253 lines

Explorer

• Goall_in_one.go
• Gocancellation_policy.go
• Gohotel.go
• Goinventory.go
• Gorate_plan.go
• Goreservation.go
• Goresult.go
• Goroom.go
• Goshared_hotel.go
• Gostandard_cancellation.go
• Gostandard_rates.go
• Gostatus.go
• Gostay.go

Goall_in_one.go

all_in_one.gocancellation_policy.gohotel.goinventory.gorate_plan.goreservation.goresult.goroom.goshared_hotel.gostandard_cancellation.gostandard_rates.gostatus.gostay.go

all_in_one.go

Read onlyGo 1.24Every file builds in CI13 files403 lines

Explorer

• TSall-in-one.ts
• src
• TScancellation-policy.ts
• TSday.ts
• TSdb.ts
• TShotel.ts
• TSinventory.ts
• TSrate-plan.ts
• TSreservation.ts
• TSresult.ts
• TSroom.ts
• TSsold-out-error.ts
• TSstandard-cancellation.ts
• TSstandard-rates.ts
• TSstatus.ts
• TSstay.ts

TSall-in-one.ts

all-in-one.tssrc/cancellation-policy.tssrc/day.tssrc/db.tssrc/hotel.tssrc/inventory.tssrc/rate-plan.tssrc/reservation.tssrc/result.tssrc/room.tssrc/sold-out-error.tssrc/standard-cancellation.tssrc/standard-rates.tssrc/status.tssrc/stay.ts

all-in-one.ts

Read onlyTypeScript, strictEvery file builds in CI15 files338 lines

Three ideas hold it together:

• Nights are the unit. Stays, prices, availability and refunds are all lists of nights, and a half-open stay makes the list clear.
• The count is the promise. A reservation holds one of each night’s sold rooms of its type. The room is chosen at arrival, and the counting argument guarantees one is free. Choosing as late as possible is what fixed stage 1.
• Nights move one way at a time. Taking always happens before giving back, so a failed operation leaves everything as it was. Rates and cancellation rules sit behind policies (Strategy), and every channel calls the Hotel class, a simple front door (a facade).

Stress it

So far, one request runs at a time. But the hotel’s website, two travel agencies and the front desk all sell the same rooms.

Four channels, one last suite

Interviewerminute 26

The hotel’s website, two travel agencies and the front desk all sell the last suite on Friday at the same moment. What stops it being sold four times?

What they are testing

Whether you name the race (each checks the count, each takes it), make check-and-take one step, and pick a sensible thing to lock. In a database answer, they listen for locking the nights in a fixed order, or a conditional update with a row count check.

Every operation reads counts and then changes them. Without protection, four requests ask “is a suite free on Friday?”, all see 1, and all add one to Friday’s count. The hotel has sold four suites it doesn’t have. Three guests will be sent to another hotel, at this hotel’s expense. A stay of several nights makes it worse: two requests can each take some of their nights before finding the other has the rest.

The clearly correct fix is a lock per hotel, and it’s the one we choose. Every operation runs alone. Is that too slow? One hotel takes a few bookings a minute, so nobody waits in practice. A platform with thousands of hotels runs one Hotel per hotel, and they never share a lock.

Why not lock each night instead? A stay covers several nights, so a booking would have to take several locks, always in the same order. That’s more rules for no real gain at a hotel’s traffic.

Sequence: two channels race for the last suite

Scroll or pinch to zoom, drag to pan

• Color key
• Facade

Option	How	Correct?	Cost
1. One lock per hotel (our choice in memory)	Every SharedHotel method holds the lock	Yes	One server owns each hotel’s inventory
2. Lock the night rows, in date order	SELECT ... ORDER BY night FOR UPDATE, then update	Yes	The real answer with many servers
3. One conditional update with a count check	UPDATE ... SET sold = sold + 1 WHERE sold < capacity; compare rows changed	Yes, with rollback	Without ordered locks, overlapping stays can block each other forever
4. A version number per night row	Update only where the version matches; retry on conflict	Yes	Retries pile up on a popular weekend
5. Read the counts, then write	Two separate statements	No: the race above	None, which is why it ships by mistake

JSharedHotel.javaPyshared_hotel.pyC#SharedHotel.csGoshared_hotel.goTSdb.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

// The website, a travel agency's feed and the front desk all book the same hotel at once. Two
// requests for the last double on Friday both find free("double", Friday) == 1 and both take
// it, and the hotel has sold a room it doesn't have. Every operation reads counts, then
// changes them, so each must run alone. One hotel takes a few bookings a minute, so one lock
// per hotel is plenty; a booking platform runs many hotels side by side, and they never
// share a lock.
class SharedHotel {
    private final Hotel hotel;
    private final ReentrantLock lock = new ReentrantLock();

    SharedHotel(Hotel hotel) { this.hotel = hotel; }

    ReserveResult reserve(String guest, String type, Stay stay) { return locked(() -> hotel.reserve(guest, type, stay)); }
    Result modify(String id, String type, Stay stay) { return locked(() -> hotel.modify(id, type, stay)); }
    Result cancel(String id) { return locked(() -> hotel.cancel(id)); }
    Result checkIn(String id) { return locked(() -> hotel.checkIn(id)); }
    Result checkOut(String id) { return locked(() -> hotel.checkOut(id)); }
    int markNoShows() { return locked(hotel::markNoShows); }
    int free(String type, LocalDate night) { return locked(() -> hotel.free(type, night)); }

    // Runs one operation with the lock held. finally releases it even if the operation throws.
    private <T> T locked(Supplier<T> op) {
        lock.lock();
        try {
            return op.get();
        } finally {
            lock.unlock();
        }
    }
}

Why is this correct? Every operation holds the hotel’s lock from its first check to its last change. So “is a suite free on Friday?” and “take it” happen together, and no other channel can act in between. That includes changes that take and give back nights of two types: one lock covers them all.

What does it cost? In-memory locks only work on one server. So each hotel must live on one server, or move to the database version. A huge resort on a holiday weekend might feel the single lock, and locking night rows in the database spreads that load.

Go deeperThe database version, step by step1 min

In TypeScript, the in-memory Hotel needs no lock. reserve checks and takes every night with no await in between, so nothing else can run in the middle. So the TypeScript tab shows the database version instead. That’s where the race comes back, once counts live in a table shared by many servers.

It works in three steps. Lock the rows for the stay’s nights, in date order. Add one to each where a room is left. If fewer rows changed than nights requested, roll everything back.

Why date order? Picture two overlapping stays. One locks Tuesday and wants Wednesday. The other locks Wednesday and wants Tuesday. Each waits for the other forever. That’s a deadlock. If everyone locks nights from earliest to latest, that circle can’t form.

How you’d prove it works

The clock is a function the test controls, set to a Monday, so weekend prices and the two-day cancellation deadline land on known dates. The tests that matter:

• The four bookings from stage 1 are all accepted, and check-in gives Dee and Cy rooms.
• Back-to-back stays fit in one suite. Bad dates and unknown types are refused.
• Friday and Saturday nights are priced higher, night by night.
• Moving a stay by one night succeeds when only the new night is free.
• A change that doesn’t fit leaves the reservation and the counts unchanged.
• Cancelling early is free, late costs one night, and twice is refused.
• A no-show pays one night, its remaining nights go back on sale, and the job is safe to rerun.
• Leaving early returns the remaining nights.
• Sixteen threads booking the last suite produce exactly one booking.

Go deeperThe tests in five languages2 min

The first test protects the main decision. It replays the exact sequence that stage 1 refused, then walks the days through check-in. If someone brings back room assignment at booking time, Dee’s reservation fails.

JMain.javaPyworld.pyC#Program.csGoworld.goTSexample.ts

JavaPythonC#GoTypeScript

JavaPythonC#GoTypeScript

LocalDate today = LocalDate.of(2026, 6, 1);  // a Monday
AtomicInteger nextId = new AtomicInteger();
Hotel hotel;

static LocalDate june(int day) { return LocalDate.of(2026, 6, day); }

static Stay stay(int from, int to) { return new Stay(june(from), june(to)); }

// Two doubles and one suite; a double is 100.00 a night and a suite 200.00.
@BeforeEach
void setUp() {
    hotel = new Hotel(new StandardRates(Map.of("double", 10000L, "suite", 20000L)), new StandardCancellation(),
        () -> "r" + nextId.incrementAndGet(), () -> today);
    hotel.addRoom(new Room("101", "double"));
    hotel.addRoom(new Room("102", "double"));
    hotel.addRoom(new Room("201", "suite"));
}

Reservation reserve(String guest, String type, Stay s) {
    ReserveResult r = hotel.reserve(guest, type, s);
    assertEquals(Result.OK, r.result());
    return r.reservation();
}

@Test
void countingNightsSellsAStayThatFixedRoomsWouldRefuse() {
    Reservation ana = reserve("ana", "double", stay(8, 9));
    Reservation ben = reserve("ben", "double", stay(8, 10));
    Reservation cy = reserve("cy", "double", stay(10, 12));
    Reservation dee = reserve("dee", "double", stay(9, 11));  // refused by stage 1's fixed rooms
    assertEquals(Result.SOLD_OUT, hotel.reserve("eve", "double", stay(9, 10)).result());

    today = june(8);
    hotel.checkIn(ana.id);
    hotel.checkIn(ben.id);
    today = june(9);
    hotel.checkOut(ana.id);
    assertEquals(Result.OK, hotel.checkIn(dee.id));
    assertEquals("101", dee.room.number());  // Ana's room, ready the day she leaves
    today = june(10);
    hotel.checkOut(ben.id);
    assertEquals(Result.OK, hotel.checkIn(cy.id));
    assertEquals("102", cy.room.number());
}

@Test
void oneStayCanEndTheDayTheNextBegins() {
    reserve("ana", "suite", stay(8, 10));
    reserve("ben", "suite", stay(10, 12));
}

@Test
void badRequestsAreRefused() {
    assertEquals(Result.INVALID_DATES, hotel.reserve("ana", "double", stay(10, 10)).result());
    assertEquals(Result.INVALID_DATES, hotel.reserve("ana", "double", new Stay(LocalDate.of(2026, 5, 30), june(2))).result());
    assertEquals(Result.NO_SUCH_TYPE, hotel.reserve("ana", "penthouse", stay(8, 9)).result());
}

@Test
void weekendNightsCostMoreAndThePriceIsQuotedPerNight() {
    assertEquals(25000, reserve("ana", "double", stay(12, 14)).total());  // Friday and Saturday
    assertEquals(10000, reserve("ben", "double", stay(11, 12)).total());  // Thursday
}

@Test
void movingAStayOnlyNeedsTheNightsItDoesNotAlreadyHold() {
    Reservation ana = reserve("ana", "suite", stay(9, 11));  // the only suite, Tuesday and Wednesday
    assertEquals(Result.OK, hotel.modify(ana.id, "suite", stay(10, 12)));  // full on Wednesday, still fine
    assertEquals(1, hotel.free("suite", june(9)));
    assertEquals(0, hotel.free("suite", june(11)));
}

@Test
void aChangeThatDoesNotFitLeavesTheBookingAlone() {
    Reservation ana = reserve("ana", "double", stay(8, 10));
    reserve("ben", "suite", stay(9, 10));
    assertEquals(Result.SOLD_OUT, hotel.modify(ana.id, "suite", stay(8, 10)));
    assertEquals("double", ana.type);
    assertEquals(1, hotel.free("double", june(8)));
}

@Test
void cancellingIsFreeUntilTwoDaysBeforeThenCostsTheFirstNight() {
    Reservation early = reserve("ana", "double", stay(8, 10));
    assertEquals(Result.OK, hotel.cancel(early.id));
    assertEquals(0, early.fee);
    assertEquals(2, hotel.free("double", june(8)));

    Reservation late = reserve("ben", "double", stay(2, 4));
    assertEquals(Result.OK, hotel.cancel(late.id));
    assertEquals(10000, late.fee);
    assertEquals(Result.WRONG_STATUS, hotel.cancel(late.id));
}

@Test
void aNoShowPaysOneNightAndTheRestGoesBackOnSale() {
    Reservation ana = reserve("ana", "suite", stay(2, 5));
    today = june(3);
    assertEquals(1, hotel.markNoShows());
    assertEquals(20000, ana.fee);
    assertEquals(1, hotel.free("suite", june(3)));
    assertEquals(0, hotel.markNoShows());  // running it again changes nothing
}

@Test
void leavingEarlyGivesTheRemainingNightsBack() {
    Reservation ana = reserve("ana", "suite", stay(2, 6));
    today = june(2);
    hotel.checkIn(ana.id);
    today = june(4);
    hotel.checkOut(ana.id);
    assertEquals(1, hotel.free("suite", june(4)));
    assertEquals(1, hotel.free("suite", june(5)));
}

@Test
void racingRequestsForTheLastRoomSellItOnce() throws Exception {
    SharedHotel shared = new SharedHotel(hotel);
    ExecutorService pool = Executors.newFixedThreadPool(16);
    CountDownLatch start = new CountDownLatch(1);
    List<Future<Result>> results = new ArrayList<>();
    for (int i = 0; i < 16; i++) {
        String guest = "g" + i;
        results.add(pool.submit(() -> { start.await(); return shared.reserve(guest, "suite", stay(12, 13)).result(); }));
    }
    start.countDown();
    int ok = 0;
    for (Future<Result> f : results) if (f.get() == Result.OK) ok++;
    pool.shutdown();
    assertEquals(1, ok);
    assertEquals(0, shared.free("suite", june(12)));
}

Go deeperEvery edge case, and where it is handled2 min

Case	What happens	Where
Check-out on or before check-in	INVALID_DATES	Hotel.check
Check-in in the past	INVALID_DATES	Hotel.check
Unknown room type	NO_SUCH_TYPE	Hotel.check
One night of several is full	SOLD_OUT, no night taken	Inventory.take
Back-to-back stays in one room	Allowed: the stays share no night	Stay.nights
Change that doesn’t fit	SOLD_OUT, original booking untouched	Hotel.modify
Change that only adds one night	Only that night is taken	Hotel.modify
Cancel twice	WRONG_STATUS, nights given back once	Hotel.cancel
Check in before arrival, or after departure	TOO_EARLY or TOO_LATE	Hotel.checkIn
Guest never arrives	Morning job: one night’s fee, nights from today back on sale	Hotel.markNoShows
Guest leaves early	Remaining nights back on sale	Hotel.checkOut
Previous guest hasn’t left yet at check-in	Their room counts as empty tonight	Hotel.isVacant
A room is out of order	Lower the type’s capacity for those nights	an extension

Wrap up

The decisions, and what each one costs

Decision	We chose	We gave up
Date ranges	Half-open stays, a list of nights	Nothing; it removes an off-by-one error
What is sold	Room types per night, all nights or none	A room number promised at booking
When a room is chosen	At check-in, any empty room of the type	Room numbers in confirmation emails
Prices	A rate plan, quoted per night and stored	A rate change doesn’t reach existing bookings
Changes	Take the difference, then give back	A little more code than cancel and rebook
Endings	Every ending gives back exactly the nights it won’t use	A morning job for no-shows
The last room	One lock per hotel; ordered row locks in the database	Each hotel’s inventory lives in one place

Go deeperGenuinely different designs, and when to pick them2 min

Assign rooms at booking, and reshuffle. Some hotel systems assign rooms early, so a guest can be told their room number. They run an optimizer each night that moves future bookings between rooms, to close gaps. It works, but the optimizer is the hard part. And a guest promised room 101 can’t be moved. Counting per type gets the same capacity with no optimizer.

One row per room per night. Instead of counts, mark each room-night as sold, choosing the room at booking. It makes “who is in 101 on Tuesday?” a quick lookup, but it brings back the gaps unless rooms are reassigned before arrival. Counts with rooms chosen at check-in avoid both problems.

A channel manager in front. Real hotels sell through many websites that each keep a copy of the availability, updated every few minutes. The hotel’s own inventory stays the truth. A booking that arrives for a night that just sold out is refused, or overbooked by policy. The design here is the inventory those copies are updated from.

How to spend 45 minutes

• 0 to 3. Room type or room, one hotel, half-open stays, changes and cancellations.
• 3 to 5. The promises. Name “no night oversold” as the hard one.
• 5 to 25. The four-booking example, counts per night with rooms at check-in, prices per night and modify, cancellations and no-shows. Code Inventory.take, modify and checkIn, and describe the policies.
• 25 to 27. Walk through the full diagram: nights are the unit, the count is the promise.
• 27 to 33. The last suite: a lock per hotel, and the database version with ordered locks.
• 33 to 45. Out-of-order rooms or overbooking, then your own questions.

If time is short, skip no-shows and spend the time on stage 2’s check-in argument and on modify. Those two are where this question separates candidates.

Follow-up questions

Interviewerminute 32

A room has a burst pipe and is out of order for a week. What changes?

What they are testing

Whether you see that capacity is per night too, and what to do when nights are already sold beyond the new capacity. Deleting the room breaks the reservations that counted on it.

Most extensions fit into one place:

Extension	What changes	Touches the counts?
Out-of-order rooms	Capacity per night, not per type	Yes, capacity only
Deliberate overbooking	Capacity is rooms plus an allowance based on past no-shows	Capacity only
Holding a room while paying	A reservation with a deadline, as in the movie booking	No
Minimum stay on weekends	check refuses a one-night Saturday arrival	No
Prices that follow demand	A different RatePlan, maybe one that reads how full the night is	No
Room preferences (high floor)	A preference on the reservation that check-in tries first	No
A specific room sold on its own	Its own type with a capacity of one	No

Go deeperHandling an out-of-order room, step by step2 min

Today, capacity is one number per type: “8 doubles”. A burst pipe in room 104 for a week means there are only 7 doubles on those seven nights, and 8 again after.

1. Capacity becomes per night. The inventory keeps a capacity for each type and night, with the usual number as the default. Taking room 104 out lowers capacity by one on each night of the repair.
2. Check for oversold nights. If any of those nights already had 8 doubles sold, it’s now oversold by one. The inventory shows this the moment the room is taken out, not on the evening a guest arrives to find no room.
3. The hotel fixes it, using tools it already has. It can upgrade one guest to a suite. That’s just a modify to a type with space, using the same “take the new nights first” rule. Or it can move a guest to a partner hotel. Either way, the count goes back to 7.
4. Check-in skips room 104. It’s simply not offered as an empty room during the repair. The counting argument still holds, because the capacity already went down.

Notice what didn’t change: reservations, prices, the check-in rule, and the lock. One number became a number per night.

Go deeperAdding deliberate overbooking, step by step2 min

Airlines and hotels both sell a little more than they have, on purpose. If one guest in twenty never turns up, a full hotel of 100 rooms has 5 empty rooms every night. Selling 103 rooms fills most of them. This sounds like it breaks our main promise, so let’s be careful about what changes.

1. Capacity gets an allowance. For each type and night, capacity becomes “rooms that exist plus an allowance”. The allowance comes from history: how many guests usually don’t arrive on that kind of night. A revenue manager sets it, so it’s a policy, not a number in the code.
2. The booking code doesn’t change at all. It still checks “is the count below capacity?” and takes the night. It just sees a bigger capacity.
3. The counting argument changes, honestly. At check-in, an empty room is now only guaranteed if enough guests didn’t arrive. So check-in can fail, and it becomes a normal answer, not an error: NO_ROOM. The front desk then upgrades the guest with a modify, or moves them to a partner hotel, at the hotel’s cost.
4. Keep the two kinds of capacity apart. The inventory must still know the real number of rooms. Then a report can show “tonight we sold 103 against 100 rooms”. Mixing them up is how hotels lose track of how much risk they took.

The main promise becomes “never sell beyond capacity”, and the hotel chooses what capacity means. The lock, the counts and the change logic all stay as they were.

Go deeperFour more follow-up questions2 min

Interviewer asksHow do you show availability for a whole month quickly?

Ask the inventory for each night’s free count, which is one lookup per night, so a month is thirty lookups per type. For a search across many hotels, a platform keeps a ready-made “lowest free count over the stay” index, updated as bookings change. The booking itself still checks the real counts.

Interviewer asksWhy does check-in pick any empty room, not the best one?

It can pick the best one: the argument only needs one to exist. Preferences (a quiet floor, near the lift, a room ready early) just sort the empty rooms. None of them can make check-in fail, because any choice leaves the remaining nights with enough rooms.

Interviewer asksWhat if a guest stays past their check-out date?

The hotel treats it as a new night: a modify that adds it, which takes the night if one is free. If tonight is full, the front desk knows before the next guest arrives. The counting argument still holds, because the extra night was sold like any other.

Interviewer asksWhy is a no-show charged one night, not the whole stay?

It’s the usual hotel policy, and it’s a policy here too. The nights from today on go back on sale, so the hotel can still earn them. Charging for them as well would charge twice for a room someone else may sleep in tonight.

Further reading

• Strategy pattern, State pattern
• Design a movie ticket booking system, seats sold per show with holds that expire
• Design a library management system, copies lent by count with a hold queue
• Interval graph, the theory behind why rooms always fit at check-in: stays as intervals, colored greedily by arrival
• PostgreSQL: explicit locking, row locks and how deadlocks arise