How low-level design interviews work

// 1. Entities: the nouns from the requirements
interface User { id: string; email: string; phone: string; channels: string[]; } // channels: the user's preferences

class Template {
  constructor(readonly subject: string, readonly body: string) {} // uses {name}-style placeholders
  render(data: Record<string, string>): [string, string] {
    const fill = (s: string) => s.replace(/\{(\w+)\}/g, (_, k: string) => data[k] ?? "");
    return [fill(this.subject), fill(this.body)];
  }
}

// 2. The interface: what varies (the channel) goes behind it
interface Channel {
  readonly name: string;
  send(user: User, subject: string, body: string): string;
}

class EmailChannel implements Channel {
  readonly name = "email";
  send(user: User, subject: string, body: string): string { return `email to ${user.email}: [${subject}] ${body}`; }
}

class SmsChannel implements Channel {
  readonly name = "sms";
  send(user: User, _subject: string, body: string): string { return `sms to ${user.phone}: ${body.slice(0, 40)}`; }
}

// 3. The service: the verbs, using the interface, never a concrete channel
class NotificationService {
  private channels: Map<string, Channel>;
  constructor(channels: Channel[], private templates: Map<string, Template>) {
    this.channels = new Map(channels.map((c) => [c.name, c]));
  }
  notify(user: User, event: string, data: Record<string, string>): string[] {
    const [subject, body] = this.templates.get(event)!.render(data);
    return user.channels.filter((c) => this.channels.has(c)).map((c) => this.channels.get(c)!.send(user, subject, body));
  }
}

const svc = new NotificationService([new EmailChannel(), new SmsChannel()],
  new Map([["order_shipped", new Template("Order {order} shipped", "Hi {name}, order {order} is on its way.")]]));
const ana: User = { id: "u1", email: "ana@example.com", phone: "+1-555-0100", channels: ["email", "sms"] };
const ben: User = { id: "u2", email: "ben@example.com", phone: "+1-555-0101", channels: ["email"] };
for (const [user, name] of [[ana, "Ana"], [ben, "Ben"]] as [User, string][]) {
  for (const line of svc.notify(user, "order_shipped", { name, order: "#42" })) console.log(line);
}

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

// 1. Entities: the nouns from the requirements
record User(String id, String email, String phone, List<String> channels) {} // channels: the user's preferences

record Template(String subject, String body) { // uses {name}-style placeholders
    private static String fill(String s, Map<String, String> data) {
        for (Map.Entry<String, String> e : data.entrySet()) s = s.replace("{" + e.getKey() + "}", e.getValue());
        return s;
    }

    String[] render(Map<String, String> data) {
        return new String[] {fill(subject, data), fill(body, data)};
    }
}

// 2. The interface: what varies (the channel) goes behind it
interface Channel {
    String name();
    String send(User user, String subject, String body);
}

class EmailChannel implements Channel {
    public String name() { return "email"; }

    public String send(User user, String subject, String body) {
        return "email to " + user.email() + ": [" + subject + "] " + body;
    }
}

class SmsChannel implements Channel {
    public String name() { return "sms"; }

    public String send(User user, String subject, String body) {
        return "sms to " + user.phone() + ": " + body.substring(0, Math.min(40, body.length()));
    }
}

// 3. The service: the verbs, using the interface, never a concrete channel
class NotificationService {
    private final Map<String, Channel> channels;
    private final Map<String, Template> templates;

    NotificationService(List<Channel> channels, Map<String, Template> templates) {
        this.channels = channels.stream().collect(Collectors.toMap(Channel::name, Function.identity()));
        this.templates = templates;
    }

    List<String> notify(User user, String event, Map<String, String> data) {
        String[] msg = templates.get(event).render(data);
        return user.channels().stream().filter(channels::containsKey).map(c -> channels.get(c).send(user, msg[0], msg[1])).toList();
    }
}

public class Main {
    public static void main(String[] args) {
        NotificationService svc = new NotificationService(List.of(new EmailChannel(), new SmsChannel()),
                Map.of("order_shipped", new Template("Order {order} shipped", "Hi {name}, order {order} is on its way.")));
        User ana = new User("u1", "ana@example.com", "+1-555-0100", List.of("email", "sms"));
        User ben = new User("u2", "ben@example.com", "+1-555-0101", List.of("email"));
        for (Object[] un : new Object[][] {{ana, "Ana"}, {ben, "Ben"}})
            svc.notify((User) un[0], "order_shipped", Map.of("name", (String) un[1], "order", "#42")).forEach(System.out::println);
    }
}