diff --git a/README.md b/README.md
index 15bb106b5..c1c1b3d37 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,66 @@
 # javascript-lotto-precourse
+
+# 🎰 로또
+
+## 📋 구현 기능 목록
+
+---
+
+### 1️⃣ 로또 구입 금액 입력
+
+- [x] 금액 입력 받기
+- [x] 1,000원 단위인지 검증
+- [x] 1,000원 미만 또는 1,000으로 나누어떨어지지 않으면 `[ERROR]` 출력 후 **해당 입력부터 다시 받기**
+
+---
+
+### 2️⃣ 로또 발행
+
+- [x] 구입 금액 ÷ 1,000 = 발행 개수 계산
+- [x] 랜덤으로 로또 번호 생성
+- [x] 1개 로또는 중복 없는 6개 번호
+- [x] 번호는 **오름차순 정렬**해서 보관
+- [x] `N개를 구매했습니다.` 출력 후 각 로또 번호를 `[1, 2, 3, 4, 5, 6]` 형식으로 출력
+
+---
+
+### 3️⃣ 당첨 번호 입력
+
+- [x] 당첨 번호 입력 받기
+- [x] 쉼표(,) 기준으로 6개인지 검증
+- [x] 각 숫자가 1~45 범위인지 검증
+- [x] 중복 숫자 없도록 검증
+- [x] 잘못되면 `[ERROR] ...` 출력 후 **당첨 번호부터 다시 받기**
+
+---
+
+### 4️⃣ 보너스 번호 입력
+
+- [x] 보너스 번호 입력 받기
+- [x] 1~45 범위 검증
+- [x] 당첨 번호와 **겹치지 않도록** 검증
+- [x] 잘못되면 `[ERROR] ...` 출력 후 **보너스 번호부터 다시 받기**
+
+---
+
+### 5️⃣ 당첨 통계 계산
+
+- [x] 사용자가 구매한 모든 로또와 당첨 번호를 비교
+- [x] 일치 개수에 따라 3개/4개/5개/5개+보너스/6개 집계
+- [x] 등수별 상금 합계 계산
+
+---
+
+### 6️⃣ 수익률 계산 및 출력
+
+- [x] 총 상금 ÷ 구입 금액 × 100
+- [x] 소수점 둘째 자리에서 반올림해 **소수 첫째 자리까지만** 출력 (예: `62.5%`)
+- [x] `총 수익률은 62.5%입니다.` 형식으로 출력
+
+---
+
+### 7️⃣ 예외 처리 및 재입력
+
+- [x] 잘못된 값 입력 시 `[ERROR]`로 시작하는 메시지를 출력
+- [x] **예외를 던지되**(throw), `App`에서 잡아서 해당 단계만 다시 입력
+- [x] `process.exit()` 사용하지 않음
diff --git a/__tests__/ApplicationTest.js b/__tests__/ApplicationTest.js
index 872380c9c..990a4b060 100644
--- a/__tests__/ApplicationTest.js
+++ b/__tests__/ApplicationTest.js
@@ -94,4 +94,56 @@ describe("로또 테스트", () => {
   test("예외 테스트", async () => {
     await runException("1000j");
   });
+
+  test("구입 금액이 1000원 단위가 아니면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([
+      [1, 2, 3, 4, 5, 6],
+      [7, 8, 9, 10, 11, 12],
+      [13, 14, 15, 16, 17, 18],
+      [19, 20, 21, 22, 23, 24],
+      [25, 26, 27, 28, 29, 30],
+    ]);
+    mockQuestions(["8500", "2000", "1,2,3,4,5,6", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[ERROR] 구입 금액은 1,000원 단위여야 합니다.")
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("2개를 구매했습니다.")
+    );
+  });
+
+  test("당첨 번호가 6개가 아니면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([[1, 2, 3, 4, 5, 6]]);
+    mockQuestions(["1000", "1,2,3,4,5", "1,2,3,4,5,6", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[ERROR] 당첨 번호는 6개여야 합니다.")
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("당첨 통계"));
+  });
+
+  test("보너스 번호가 당첨 번호와 중복되면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([[1, 2, 3, 4, 5, 6]]);
+    mockQuestions(["1000", "1,2,3,4,5,6", "3", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다."
+      )
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("당첨 통계"));
+  });
 });
diff --git a/__tests__/LottoTest.js b/__tests__/LottoTest.js
index 409aaf69b..d96a7f8b6 100644
--- a/__tests__/LottoTest.js
+++ b/__tests__/LottoTest.js
@@ -14,5 +14,16 @@ describe("로또 클래스 테스트", () => {
     }).toThrow("[ERROR]");
   });
 
-  // TODO: 추가 기능 구현에 따른 테스트 코드 작성
+  test("로또 번호가 6개 보다 적으면 예외가 발생한다.", () => {
+    expect(() => new Lotto([1, 2, 3, 4, 5]).toThrow("[ERROR]"));
+  });
+
+  test("로또 번호가 1~45 범위를 벗어나면 예외가 발생한다.", () => {
+    expect(() => new Lotto([0, 2, 3, 4, 5, 6])).toThrow("[ERROR]");
+    expect(() => new Lotto([1, 2, 3, 4, 5, 100])).toThrow("[ERROR]");
+  });
+
+  test("유효한 로또 번호 6개라면 예외가 발생하지 않는다.", () => {
+    expect(() => new Lotto([1, 2, 3, 4, 5, 6])).not.toThrow();
+  });
 });
diff --git a/src/App.js b/src/App.js
index 091aa0a5d..1e13c9daa 100644
--- a/src/App.js
+++ b/src/App.js
@@ -1,5 +1,37 @@
+import { LOTTO_PRICE } from "./constants/constants.js";
+import InputHandler from "./InputHandler.js";
+import LottoService from "./LottoService.js";
+import { printNewLine } from "./utils/output.js";
+
 class App {
-  async run() {}
+  #inputHandler;
+  #lottoService;
+
+  constructor() {
+    this.#inputHandler = new InputHandler();
+    this.#lottoService = new LottoService();
+  }
+
+  async run() {
+    const purchaseAmount = await this.#inputHandler.readPurchaseAmount();
+    const ticketCount = purchaseAmount / LOTTO_PRICE;
+    printNewLine();
+
+    const tickets = this.#lottoService.publishLottos(ticketCount);
+    this.#lottoService.printTickets(tickets);
+
+    const winningNumbers = await this.#inputHandler.readWinningNumbers();
+    const bonusNumber = await this.#inputHandler.readBonusNumber(
+      winningNumbers
+    );
+
+    const stats = this.#lottoService.calculateStats(
+      tickets,
+      winningNumbers,
+      bonusNumber
+    );
+    this.#lottoService.printStats(stats, purchaseAmount);
+  }
 }
 
 export default App;
diff --git a/src/InputHandler.js b/src/InputHandler.js
new file mode 100644
index 000000000..bfc192676
--- /dev/null
+++ b/src/InputHandler.js
@@ -0,0 +1,117 @@
+import { Console } from "@woowacourse/mission-utils";
+import {
+  LOTTO_COUNT,
+  LOTTO_MAX,
+  LOTTO_MIN,
+  LOTTO_PRICE,
+  NUMBER_REGEX,
+} from "./constants/constants.js";
+import { ERROR_MESSAGES, INPUT_MESSAGES } from "./constants/messages.js";
+import { printNewLine } from "./utils/output.js";
+
+class InputHandler {
+  async readPurchaseAmount() {
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.PURCHASE_AMOUNT);
+      try {
+        return this.#parsePurchaseAmount(input);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #trimInput(input) {
+    return (input ?? "").trim();
+  }
+
+  #parseNumber(input, errorMessage = ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE) {
+    if (!NUMBER_REGEX.test(input)) {
+      throw new Error(errorMessage);
+    }
+    return Number(input);
+  }
+
+  #parsePurchaseAmount(input) {
+    const trimmedInput = this.#trimInput(input);
+    const amount = this.#parseNumber(
+      trimmedInput,
+      ERROR_MESSAGES.PURCHASE_AMOUNT_NOT_NUMBER
+    );
+
+    if (amount < LOTTO_PRICE) {
+      throw new Error(ERROR_MESSAGES.PURCHASE_AMOUNT_TOO_LOW);
+    }
+    if (amount % LOTTO_PRICE !== 0) {
+      throw new Error(ERROR_MESSAGES.PURCHASE_AMOUNT_NOT_DIVISIBLE);
+    }
+    return amount;
+  }
+
+  async readWinningNumbers() {
+    printNewLine();
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.WINNING_NUMBERS);
+      try {
+        return this.#parseWinningNumbers(input);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #parseWinningNumbers(input) {
+    const trimmedInput = this.#trimInput(input);
+    const parts = trimmedInput.split(",").map((value) => value.trim());
+    if (parts.length !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.WINNING_NUMBERS_COUNT_INVALID);
+    }
+
+    const numbers = parts.map((numberString) =>
+      this.#parseNumber(numberString)
+    );
+    this.#validateLottoNumbers(numbers);
+
+    const unique = new Set(numbers);
+    if (unique.size !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.WINNING_NUMBERS_DUPLICATE);
+    }
+    return numbers;
+  }
+
+  #validateLottoNumbers(numbers) {
+    if (
+      !numbers.every(
+        (number) =>
+          Number.isInteger(number) && number >= LOTTO_MIN && number <= LOTTO_MAX
+      )
+    ) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE);
+    }
+  }
+
+  async readBonusNumber(winningNumbers) {
+    printNewLine();
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.BONUS_NUMBER);
+      try {
+        return this.#parseBonusNumber(input, winningNumbers);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #parseBonusNumber(input, winningNumbers) {
+    const trimmedInput = this.#trimInput(input);
+    const bonus = this.#parseNumber(trimmedInput);
+    this.#validateLottoNumbers([bonus]);
+
+    if (winningNumbers.includes(bonus)) {
+      throw new Error(ERROR_MESSAGES.BONUS_NUMBER_DUPLICATE);
+    }
+    return bonus;
+  }
+}
+
+export default InputHandler;
diff --git a/src/Lotto.js b/src/Lotto.js
index cb0b1527e..58f11c5bc 100644
--- a/src/Lotto.js
+++ b/src/Lotto.js
@@ -1,3 +1,6 @@
+import { LOTTO_COUNT, LOTTO_MAX, LOTTO_MIN } from "./constants/constants.js";
+import { ERROR_MESSAGES } from "./constants/messages.js";
+
 class Lotto {
   #numbers;
 
@@ -7,12 +10,24 @@ class Lotto {
   }
 
   #validate(numbers) {
-    if (numbers.length !== 6) {
-      throw new Error("[ERROR] 로또 번호는 6개여야 합니다.");
+    if (numbers.length !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBERS_COUNT_INVALID);
+    }
+
+    if (
+      !numbers.every(
+        (number) =>
+          Number.isInteger(number) && number >= LOTTO_MIN && number <= LOTTO_MAX
+      )
+    ) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE);
     }
-  }
 
-  // TODO: 추가 기능 구현
+    const uniqueCount = new Set(numbers).size;
+    if (uniqueCount !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBERS_DUPLICATE);
+    }
+  }
 }
 
 export default Lotto;
diff --git a/src/LottoService.js b/src/LottoService.js
new file mode 100644
index 000000000..3399ecfac
--- /dev/null
+++ b/src/LottoService.js
@@ -0,0 +1,115 @@
+import { Console, Random } from "@woowacourse/mission-utils";
+import {
+  LOTTO_COUNT,
+  LOTTO_MAX,
+  LOTTO_MIN,
+  PRIZE_TABLE,
+} from "./constants/constants.js";
+import Lotto from "./Lotto.js";
+import { printNewLine } from "./utils/output.js";
+
+class LottoService {
+  publishLottos(count) {
+    const tickets = [];
+    for (let i = 0; i < count; i += 1) {
+      const numbers = Random.pickUniqueNumbersInRange(
+        LOTTO_MIN,
+        LOTTO_MAX,
+        LOTTO_COUNT
+      );
+      const sorted = [...numbers].sort((first, second) => first - second);
+      new Lotto(sorted);
+      tickets.push(sorted);
+    }
+    return tickets;
+  }
+
+  calculateStats(tickets, winningNumbers, bonusNumber) {
+    const stats = {
+      three: 0,
+      four: 0,
+      five: 0,
+      fiveBonus: 0,
+      six: 0,
+    };
+
+    for (const ticket of tickets) {
+      const matchCount = this.#countMatch(ticket, winningNumbers);
+      const hasBonus = ticket.includes(bonusNumber);
+      this.#applyStat(stats, matchCount, hasBonus);
+    }
+    return stats;
+  }
+
+  #countMatch(ticket, winningNumbers) {
+    let matchedCount = 0;
+    for (const number of ticket) {
+      if (winningNumbers.includes(number)) {
+        matchedCount += 1;
+      }
+    }
+    return matchedCount;
+  }
+
+  #applyStat(stats, matchCount, hasBonus) {
+    if (matchCount === 6) {
+      stats.six += 1;
+      return;
+    }
+    if (matchCount === 5 && hasBonus) {
+      stats.fiveBonus += 1;
+      return;
+    }
+    if (matchCount === 5) {
+      stats.five += 1;
+      return;
+    }
+
+    if (matchCount === 4) {
+      stats.four += 1;
+      return;
+    }
+    if (matchCount === 3) {
+      stats.three += 1;
+    }
+  }
+
+  printTickets(tickets) {
+    Console.print(`${tickets.length}개를 구매했습니다.`);
+    for (const ticket of tickets) {
+      Console.print(`[${ticket.join(", ")}]`);
+    }
+  }
+
+  printStats(stats, purchaseAmount) {
+    printNewLine();
+    Console.print("당첨 통계");
+    Console.print("---");
+    Console.print(`${PRIZE_TABLE.three.label}${stats.three}개`);
+    Console.print(`${PRIZE_TABLE.four.label}${stats.four}개`);
+    Console.print(`${PRIZE_TABLE.five.label}${stats.five}개`);
+    Console.print(`${PRIZE_TABLE.fiveBonus.label}${stats.fiveBonus}개`);
+    Console.print(`${PRIZE_TABLE.six.label}${stats.six}개`);
+
+    const profitRate = this.#calculateProfitRate(stats, purchaseAmount);
+    Console.print(`총 수익률은 ${profitRate}%입니다.`);
+  }
+
+  #calculateProfitRate(stats, purchaseAmount) {
+    const totalPrize =
+      stats.three * PRIZE_TABLE.three.money +
+      stats.four * PRIZE_TABLE.four.money +
+      stats.five * PRIZE_TABLE.five.money +
+      stats.fiveBonus * PRIZE_TABLE.fiveBonus.money +
+      stats.six * PRIZE_TABLE.six.money;
+
+    const rate = (totalPrize / purchaseAmount) * 100;
+    const rounded = Math.round(rate * 10) / 10;
+    return new Intl.NumberFormat("ko-KR", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 1,
+    }).format(rounded);
+  }
+}
+
+export default LottoService;
diff --git a/src/constants/constants.js b/src/constants/constants.js
new file mode 100644
index 000000000..e366c16c4
--- /dev/null
+++ b/src/constants/constants.js
@@ -0,0 +1,18 @@
+export const LOTTO_PRICE = 1000;
+export const LOTTO_MIN = 1;
+export const LOTTO_MAX = 45;
+export const LOTTO_COUNT = 6;
+
+export const NUMBER_REGEX = /^\d+$/;
+
+export const PRIZE_TABLE = {
+  three: { match: 3, money: 5000, label: "3개 일치 (5,000원) - " },
+  four: { match: 4, money: 50000, label: "4개 일치 (50,000원) - " },
+  five: { match: 5, money: 1500000, label: "5개 일치 (1,500,000원) - " },
+  fiveBonus: {
+    match: 5,
+    money: 30000000,
+    label: "5개 일치, 보너스 볼 일치 (30,000,000원) - ",
+  },
+  six: { match: 6, money: 2000000000, label: "6개 일치 (2,000,000,000원) - " },
+};
diff --git a/src/constants/messages.js b/src/constants/messages.js
new file mode 100644
index 000000000..188affaa0
--- /dev/null
+++ b/src/constants/messages.js
@@ -0,0 +1,19 @@
+export const ERROR_MESSAGES = {
+  PURCHASE_AMOUNT_NOT_NUMBER: "[ERROR] 구입 금액은 숫자여야 합니다.",
+  PURCHASE_AMOUNT_TOO_LOW: "[ERROR] 구입 금액은 1,000원 이상이어야 합니다.",
+  PURCHASE_AMOUNT_NOT_DIVISIBLE: "[ERROR] 구입 금액은 1,000원 단위여야 합니다.",
+  WINNING_NUMBERS_COUNT_INVALID: "[ERROR] 당첨 번호는 6개여야 합니다.",
+  WINNING_NUMBERS_DUPLICATE: "[ERROR] 당첨 번호는 서로 다른 숫자여야 합니다.",
+  LOTTO_NUMBER_OUT_OF_RANGE:
+    "[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.",
+  LOTTO_NUMBERS_COUNT_INVALID: "[ERROR] 로또 번호는 6개여야 합니다.",
+  LOTTO_NUMBERS_DUPLICATE: "[ERROR] 로또 번호는 중복될 수 없습니다.",
+  BONUS_NUMBER_DUPLICATE:
+    "[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.",
+};
+
+export const INPUT_MESSAGES = {
+  PURCHASE_AMOUNT: "구입금액을 입력해 주세요.\n",
+  WINNING_NUMBERS: "당첨 번호를 입력해 주세요.\n",
+  BONUS_NUMBER: "보너스 번호를 입력해 주세요.\n",
+};
diff --git a/src/utils/output.js b/src/utils/output.js
new file mode 100644
index 000000000..7eb191361
--- /dev/null
+++ b/src/utils/output.js
@@ -0,0 +1,5 @@
+import { Console } from "@woowacourse/mission-utils";
+
+export const printNewLine = () => {
+  Console.print("");
+};
diff --git a/types/woowacourse__mission-utils.d.ts b/types/woowacourse__mission-utils.d.ts
new file mode 100644
index 000000000..fa45d5336
--- /dev/null
+++ b/types/woowacourse__mission-utils.d.ts
@@ -0,0 +1,15 @@
+declare module "@woowacourse/mission-utils" {
+  export const Console: {
+    readLineAsync(prompt?: string): Promise<string>;
+    print(message: string): void;
+  };
+
+  export const Random: {
+    pickNumberInRange(minInclusive: number, maxInclusive: number): number;
+    pickUniqueNumbersInRange(
+      minInclusive: number,
+      maxInclusive: number,
+      count: number
+    ): number[];
+  };
+}