Ver3.5 ๐ ์ ๊ธฐ ๊ฒฐ์ & ๊ตฌ๋ ์๋น์ค ๋ชจ๋ธ ๊ตฌํ ๊ธฐ๋ฒ

๐ ์ ๊ธฐ ๊ฒฐ์ & ๊ตฌ๋ ์๋น์ค ๋ชจ๋ธ ๊ตฌํ ๊ธฐ๋ฒ
์ผํ๋ชฐ ๊ฐ๋ฐ์๋ผ๋ฉด ๋ฐ๋์ ์์์ผ ํ ๊ตฌ๋
๊ฒฝ์ ์ ๋ชจ๋ ๊ฒ ๐ฅ
์ฌ๋ฏธ์๊ฒ ๋ฐฐ์ฐ๋ ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ ์ง์ ๐ปโจ
์ผ ์์งํ ๋งํด์ ์์ฆ ๊ตฌ๋
์๋น์ค ์๋ ์ถ์ด ์์์ด ๊ฐ? ใ
ใ
ใ
๋ทํ๋ฆญ์ค, ์ ํ๋ธ ํ๋ฆฌ๋ฏธ์, ์ฟ ํก ๋ก์ผ์์ฐ, ๋ฉ๋ก ... ์ฐ๋ฆฌ ์ง๊ฐ์์ ๋งค๋ฌ ์๋์ผ๋ก ๋น ์ ธ๋๊ฐ๋ ๋๋ค ์๊ฐํด๋ด ๐
์ด๊ฒ ๋ฐ๋ก ๊ตฌ๋
๊ฒฝ์ (Subscription Economy)์ ์๋ ฅ์ด์ผ!
์ผํ๋ชฐ ๊ฐ๋ฐ์ ์
์ฅ์์ ์ด ๊ตฌ๋
๋ชจ๋ธ์ ์ง์ ๊ตฌํํด์ผ ํ๋ค๋ฉด? ์ฒ์์ ๋ง๋งํ์ง... ๊ทผ๋ฐ ๊ฑฑ์ ๋ง!
์ค๋ ์ด ๊ธ ํ๋๋ก ์ ๊ธฐ ๊ฒฐ์ & ๊ตฌ๋
์๋น์ค ๋ชจ๋ธ ๊ตฌํ์ A to Z๋ฅผ ๋ค ๋ฝ์์ค๊ฒ ๐ฏ
๊ธฐ์ ์ ์ธ ๋ด์ฉ๋ ๋นก์ธ๊ฒ ๋ค๋ฃจ์ง๋ง, ์ต๋ํ ์ฝ๊ณ ์ฌ๋ฐ๊ฒ ํ์ด๋ณผ ํ
๋๊น ๋๊น์ง ๋ฐ๋ผ์๋ด ๐ช
๐ ๊ตฌ๋ ์๋น์ค ๋ชจ๋ธ์ด๋? ๊ธฐ์ด๋ถํฐ ์ก์
๊ตฌ๋
์๋น์ค ๋ชจ๋ธ์ ํ ์ค๋ก ์ ์ํ๋ฉด?
"๊ณ ๊ฐ์ด ์ผ์ ๊ธ์ก์ ์ฃผ๊ธฐ์ ์ผ๋ก ๊ฒฐ์ ํ๊ณ , ๊ทธ์ ๋ง๋ ์๋น์ค๋ ์ํ์ ์ง์์ ์ผ๋ก ๋ฐ๋ ๋น์ฆ๋์ค ๋ชจ๋ธ"์ด์ผ.
์ผํ๋ชฐ ๊ด์ ์์ ๋ณด๋ฉด ํฌ๊ฒ 3๊ฐ์ง ์ ํ์ผ๋ก ๋๋์ด:
์: ๋ทฐํฐ ๋ฐ์ค, ๋ฐ๋ ค๋๋ฌผ ๊ฐ์ ๋ฐ์ค, ์ฑ ๊ตฌ๋ ์๋น์ค ๋ฑ
โป๏ธ ๋ณด์ถฉํ (Replenishment)
์๋ชจํ์ ์ ๊ธฐ์ ์ผ๋ก ์๋ ๋ฐฐ์กํด์ฃผ๋ ๋ฐฉ์.
์: ๋ฉด๋๋ , ๋นํ๋ฏผ, ์ปคํผ ์๋ ์ ๊ธฐ ๋ฐฐ์ก
๐ ์ ๊ทผ๊ถํ (Access)
ํ๋ฆฌ๋ฏธ์ ํํ์ด๋ ์ฝํ ์ธ ์ ๋ํ ์ ๊ทผ๊ถ์ ํ๋งคํ๋ ๋ฐฉ์.
์: ์ฟ ํก ๋ก์ผ์์ฐ, ๋ค์ด๋ฒ ํ๋ฌ์ค ๋ฉค๋ฒ์ญ
๊ฐ๋ฐ์ ์
์ฅ์์ ์ด ์ธ ๊ฐ์ง ์ ํ์ ๋ฐ์ดํฐ ๋ชจ๋ธ๊ณผ ๊ฒฐ์ ๋ก์ง์ด ์กฐ๊ธ์ฉ ๋ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ ์ฒ์ ์ค๊ณํ ๋ ์ด๋ค ์ ํ์ธ์ง ๋ช
ํํ ํด์ผ ํด!
ํ๋ ์ด์
ํ์ ๋ฐฐ์ก ๊ด๋ฆฌ๊ฐ ํต์ฌ์ด๊ณ , ๋ณด์ถฉํ์ ์ฌ๊ณ ์ฐ๋์ด ์ค์ํ๊ณ , ์ ๊ทผ๊ถํ์ ๊ถํ ๊ด๋ฆฌ๊ฐ ํต์ฌ์ด๊ฑฐ๋ ๐
๊ตฌ๋ ์๋น์ค์ ํต์ฌ ์งํ (KPI)
๊ตฌ๋ ์๋น์ค๋ฅผ ๊ฐ๋ฐํ๋ฉด์ ๋น์ฆ๋์ค ํ์ด๋ ์ํตํ ๋ ์ด ์ฉ์ด๋ค์ ๊ธฐ๋ณธ์ผ๋ก ์์์ผ ํด ใ ใ
โ ๋งค๋ฌ ์์ ์ ์ผ๋ก ๋ค์ด์ค๋ ๊ตฌ๋ ๋งค์ถ ์ดํฉ
ARR (Annual Recurring Revenue) - ์ฐ๊ฐ ๋ฐ๋ณต ๋งค์ถ
โ MRR ร 12. ํฌ์์๋ค์ด ์ ์ผ ์ข์ํ๋ ์งํ ใ ใ
Churn Rate - ์ดํ๋ฅ
โ ๊ตฌ๋ ์ ์ทจ์ํ ๊ณ ๊ฐ ๋น์จ. ๋ฎ์์๋ก ์ข์!
LTV (Lifetime Value) - ๊ณ ๊ฐ ์์ ๊ฐ์น
โ ํ ๊ณ ๊ฐ์ด ๊ตฌ๋ ๊ธฐ๊ฐ ๋์ ๊ฐ์ ธ๋ค์ฃผ๋ ์ด ๋งค์ถ
CAC (Customer Acquisition Cost) - ๊ณ ๊ฐ ํ๋ ๋น์ฉ
โ ์ ๊ท ๊ตฌ๋ ์ ํ ๋ช ์ ์ ์นํ๋ ๋ฐ ๋๋ ๋น์ฉ
๐๏ธ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ค๊ณ: ๊ตฌ๋ ์๋น์ค์ ๋ผ๋
์, ์ด์ ์ง์ง ๊ฐ๋ฐ ์๊ธฐ ๋ค์ด๊ฐ๋ณด์!
๊ตฌ๋
์๋น์ค์์ DB ์ค๊ณ๊ฐ ์ ์ผ ์ค์ํด. ์ฒ์์ ์๋ชป ์ง๋ฉด ๋์ค์ ํผ ๋ด ใ
ใ
ํต์ฌ ํ
์ด๋ธ ๊ตฌ์กฐ๋ฅผ ์ดํด๋ณผ๊ฒ:
ํต์ฌ ํ ์ด๋ธ ๊ตฌ์กฐ
CREATE TABLE plans (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100) NOT NULL, -- ํ๋๋ช
(๋ฒ ์ด์ง, ํ๋ฆฌ๋ฏธ์ ๋ฑ)
description TEXT, -- ํ๋ ์ค๋ช
price DECIMAL(10,2) NOT NULL, -- ๊ฐ๊ฒฉ
currency VARCHAR(3) DEFAULT 'KRW', -- ํตํ
interval ENUM('day','week','month','year') NOT NULL, -- ๊ฒฐ์ ์ฃผ๊ธฐ
interval_count INT DEFAULT 1, -- ์ฃผ๊ธฐ ๋ฐฐ์ (2๋ฉด 2๊ฐ์๋ง๋ค)
trial_days INT DEFAULT 0, -- ๋ฌด๋ฃ ์ฒดํ ๊ธฐ๊ฐ
is_active TINYINT(1) DEFAULT 1, -- ํ์ฑํ ์ฌ๋ถ
created_at DATETIME DEFAULT NOW(),
updated_at DATETIME DEFAULT NOW()
);
CREATE TABLE subscriptions (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
user_id BIGINT NOT NULL, -- ๊ตฌ๋
์ ID
plan_id BIGINT NOT NULL, -- ํ๋ ID
status ENUM(
'trialing', -- ์ฒดํ ์ค
'active', -- ํ์ฑ
'past_due', -- ๊ฒฐ์ ์ฐ์ฒด
'canceled', -- ์ทจ์๋จ
'expired' -- ๋ง๋ฃ๋จ
) NOT NULL,
current_period_start DATETIME NOT NULL, -- ํ์ฌ ๊ตฌ๋
๊ธฐ๊ฐ ์์
current_period_end DATETIME NOT NULL, -- ํ์ฌ ๊ตฌ๋
๊ธฐ๊ฐ ์ข
๋ฃ
trial_start DATETIME, -- ์ฒดํ ์์์ผ
trial_end DATETIME, -- ์ฒดํ ์ข
๋ฃ์ผ
canceled_at DATETIME, -- ์ทจ์ ์์ฒญ ์๊ฐ
cancel_at_period_end TINYINT(1) DEFAULT 0, -- ๊ธฐ๊ฐ ์ข
๋ฃ ์ ์ทจ์ ์ฌ๋ถ
payment_method_id BIGINT, -- ๊ฒฐ์ ์๋จ ID
created_at DATETIME DEFAULT NOW(),
updated_at DATETIME DEFAULT NOW(),
FOREIGN KEY (user_id) REFERENCES users(id),
FOREIGN KEY (plan_id) REFERENCES plans(id)
);
CREATE TABLE invoices (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
subscription_id BIGINT NOT NULL,
user_id BIGINT NOT NULL,
amount DECIMAL(10,2) NOT NULL,
currency VARCHAR(3) DEFAULT 'KRW',
status ENUM('draft','open','paid','void','uncollectible') NOT NULL,
due_date DATETIME, -- ๊ฒฐ์ ๊ธฐํ
paid_at DATETIME, -- ์ค์ ๊ฒฐ์ ์๊ฐ
attempt_count INT DEFAULT 0, -- ๊ฒฐ์ ์๋ ํ์
next_attempt_at DATETIME, -- ๋ค์ ์ฌ์๋ ์๊ฐ
pg_transaction_id VARCHAR(200), -- PG์ฌ ๊ฑฐ๋ ID
created_at DATETIME DEFAULT NOW(),
FOREIGN KEY (subscription_id) REFERENCES subscriptions(id)
);
๊ฒฐ์ ์๋จ ์ ์ฅ ํ ์ด๋ธ
CREATE TABLE payment_methods (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
user_id BIGINT NOT NULL,
type ENUM('card','bank_transfer','kakao_pay','naver_pay') NOT NULL,
pg_customer_key VARCHAR(200), -- PG์ฌ์์ ๋ฐ๊ธํ ๊ณ ๊ฐ ํค (๋น๋งํค)
card_last4 VARCHAR(4), -- ์นด๋ ๋ 4์๋ฆฌ (ํ์์ฉ)
card_brand VARCHAR(50), -- ์นด๋์ฌ (์ผ์ฑ, ํ๋ ๋ฑ)
is_default TINYINT(1) DEFAULT 0,
created_at DATETIME DEFAULT NOW()
);
๐ณ PG์ฌ ์ฐ๋๊ณผ ๋น๋งํค ๋ฐ๊ธ: ์๋๊ฒฐ์ ์ ํต์ฌ
๊ตฌ๋
์๋น์ค์์ ์ ์ผ ์ค์ํ ๊ฒ ๋ญ๋๊ณ ? ๋ฐ๋ก ์๋ ๊ฒฐ์ ์ผ!
๊ณ ๊ฐ์ด ๋งค๋ฌ ์ง์ ๊ฒฐ์ ํ๋ฌ ๋ค์ด์ค๋ ๊ฒ ์๋๋ผ, ์์คํ
์ด ์์์ ๊ฒฐ์ ํด์ค์ผ ํ์์.
์ด๊ฑธ ๊ฐ๋ฅํ๊ฒ ํด์ฃผ๋ ๊ฒ ๋ฐ๋ก ๋น๋งํค(Billing Key) ๋ฐฉ์์ด์ผ ๐
๋น๋งํค ๋ฐ๊ธ ํ๋ก์ธ์ค
PG์ฌ๊ฐ ์ ๊ณตํ๋ ๊ฒฐ์ ์ฐฝ(ํ์ /iframe)์์ ์นด๋ ์ ๋ณด๋ฅผ ์ ๋ ฅํด. ์ด ๊ณผ์ ์์ ์นด๋ ์ ๋ณด๋ PG์ฌ ์๋ฒ๋ก๋ง ์ ์ก๋๊ณ , ์ฐ๋ฆฌ ์๋ฒ์๋ ์ ๋ ์ ์!
PG์ฌ๊ฐ ์นด๋ ์ ๋ณด๋ฅผ ๊ฒ์ฆํ๊ณ , ์ฐ๋ฆฌ ์๋ฒ์ ๊ณ ์ ํ ๋น๋งํค๋ฅผ ๋ฐ๊ธํด์ค. ์ด ๋น๋งํค๊ฐ ๋์ค์ ์๋๊ฒฐ์ ํ ๋ ์ฌ์ฉ๋๋ ์ด์ ์ผ!
๋ฐ๊ธ๋ฐ์ ๋น๋งํค๋ฅผ payment_methods ํ ์ด๋ธ์ ์ ์ฅํด. ์นด๋ ๋ฒํธ ์์ฒด๋ ์ ์ฅ ์ ํ๊ณ ์ด ํค๋ง ์ ์ฅํ๋ ๊ฑฐ์ผ.
๊ฒฐ์ ์ฃผ๊ธฐ๊ฐ ๋๋ฉด ์๋ฒ์์ ๋น๋งํค๋ฅผ ์ด์ฉํด PG์ฌ API๋ฅผ ํธ์ถํด์ ์๋์ผ๋ก ๊ฒฐ์ ๋ฅผ ์งํํด!
๊ตญ๋ด ์ฃผ์ PG์ฌ ๋น๊ต
โ ํ ์คํธ ํ๊ฒฝ์ด ์ ๊ฐ์ถฐ์ ธ ์์ด์ ๊ฐ๋ฐํ๊ธฐ ํธํจ
โ ์คํํธ์ ๋ค์ด ๋ง์ด ์ ํํ๋ PG์ฌ
๐ฆ ์์ํฌํธ / ํฌํธ์ (PortOne)
โ ์ฌ๋ฌ PG์ฌ๋ฅผ ํ๋์ API๋ก ํตํฉ ๊ด๋ฆฌ ๊ฐ๋ฅ
โ ๊ตญ๋ด PG์ฌ ํตํฉ ์๋ฃจ์ ์ผ๋ก ์ ๋ช
โ ์นด์นด์คํ์ด, ๋ค์ด๋ฒํ์ด ๋ฑ ๊ฐํธ๊ฒฐ์ ๋ ํตํฉ ์ง์
๐ฆ KG์ด๋์์ค
โ ๊ตญ๋ด ์ต๋ PG์ฌ ์ค ํ๋
โ ๋๊ธฐ์ ์ผํ๋ชฐ์์ ๋ง์ด ์ฌ์ฉ
โ ์์ ์ฑ์ด ๋์ง๋ง ๊ฐ๋ฐ ๋ฌธ์๊ฐ ์กฐ๊ธ ๊ตฌ์์ธ ํธ
๐ฆ NHN KCP
โ ์ ๊ธฐ๊ฒฐ์ ๊ธฐ๋ฅ ์ง์
โ ๋ํ ์ผํ๋ชฐ ๋ ํผ๋ฐ์ค ๋ค์ ๋ณด์
ํ ์คํ์ด๋จผ์ธ ๋น๋ง API ์์ ์ฝ๋
์ค์ ๋ก ์ด๋ป๊ฒ ์ฝ๋๋ฅผ ์ง๋์ง ๋ณด์ฌ์ค๊ฒ! Node.js ๊ธฐ์ค์ด์ผ:
// ๋น๋งํค ๋ฐ๊ธ ์์ฒญ (๊ณ ๊ฐ์ด ์นด๋ ๋ฑ๋ก ํ ์๋ฒ๋ก authKey ์ ๋ฌ)
const axios = require('axios');
async function issueBillingKey(authKey, customerKey) {
const response = await axios.post(
'https://api.tosspayments.com/v1/billing/authorizations/issue',
{
authKey: authKey,
customerKey: customerKey
},
{
headers: {
Authorization: `Basic ${Buffer.from(process.env.TOSS_SECRET_KEY + ':').toString('base64')}`,
'Content-Type': 'application/json'
}
}
);
// ์๋ต์์ billingKey ์ถ์ถ ํ DB ์ ์ฅ
const { billingKey, card } = response.data;
await db.query(
`INSERT INTO payment_methods
(user_id, type, pg_customer_key, card_last4, card_brand, is_default)
VALUES (?, 'card', ?, ?, ?, 1)`,
[userId, billingKey, card.number.slice(-4), card.company]
);
return billingKey;
}
// ์๋๊ฒฐ์ ์คํ ํจ์
async function chargeSubscription(billingKey, amount, orderId, orderName) {
try {
const response = await axios.post(
`https://api.tosspayments.com/v1/billing/${billingKey}`,
{
customerKey: customerKey,
amount: amount,
orderId: orderId,
orderName: orderName,
customerEmail: customerEmail,
customerName: customerName
},
{
headers: {
Authorization: `Basic ${Buffer.from(process.env.TOSS_SECRET_KEY + ':').toString('base64')}`,
'Content-Type': 'application/json'
}
}
);
return { success: true, data: response.data };
} catch (error) {
return { success: false, error: error.response.data };
}
}
โฐ ์ ๊ธฐ ๊ฒฐ์ ์ค์ผ์ค๋ฌ ๊ตฌํ
๋น๋งํค ๋ฐ๊ธ๊น์ง ๋์ผ๋ฉด ์ด์ ์๋์ผ๋ก ๊ฒฐ์ ๋ฅผ ์คํํ๋ ์ค์ผ์ค๋ฌ๋ฅผ ๋ง๋ค์ด์ผ ํด!
์ด๊ฒ ๊ตฌ๋
์๋น์ค์ ์ฌ์ฅ์ด๋ผ๊ณ ํ ์ ์์ด ๐
์ค์ผ์ค๋ฌ ๊ตฌํ ๋ฐฉ์์ ํฌ๊ฒ ๋ ๊ฐ์ง์ผ:
๋งค์ผ ์์ ์ "์ค๋ ๊ฒฐ์ ํด์ผ ํ ๊ตฌ๋ ๋ชฉ๋ก"์ ๋ฝ์์ ์ผ๊ด ์ฒ๋ฆฌํ๋ ๋ฐฉ์.
๐ ๋ฐฉ์ 2: ์ด๋ฒคํธ ๊ธฐ๋ฐ (Event-Driven)
๊ฐ ๊ตฌ๋ ์ ๋ง๋ฃ ์๊ฐ์ ๋ง์ถฐ ๊ฐ๋ณ ์ด๋ฒคํธ๋ฅผ ์์ฝํด๋๋ ๋ฐฉ์.
Redis, Bull Queue ๊ฐ์ ๋ฉ์์ง ํ๋ฅผ ํ์ฉํด.
Cron Job ๋ฐฉ์ ๊ตฌํ (Node.js + node-cron)
const cron = require('node-cron');
// ๋งค์ผ ์ค์ 9์์ ์คํ
cron.schedule('0 9 * * *', async () => {
console.log('์ ๊ธฐ๊ฒฐ์ ์ค์ผ์ค๋ฌ ์์:', new Date());
// ์ค๋ ๊ฒฐ์ ํด์ผ ํ ๊ตฌ๋
๋ชฉ๋ก ์กฐํ
const dueSubscriptions = await db.query(`
SELECT s.*, pm.pg_customer_key as billing_key,
p.price, p.name as plan_name,
u.email, u.name as user_name
FROM subscriptions s
JOIN plans p ON s.plan_id = p.id
JOIN payment_methods pm ON s.payment_method_id = pm.id
JOIN users u ON s.user_id = u.id
WHERE s.status = 'active'
AND s.current_period_end <= NOW()
AND s.cancel_at_period_end = 0
`);
for (const subscription of dueSubscriptions) {
await processSubscriptionRenewal(subscription);
}
});
async function processSubscriptionRenewal(subscription) {
// 1. ์ธ๋ณด์ด์ค ์์ฑ (draft ์ํ)
const invoiceId = await createInvoice(subscription);
// 2. ๊ฒฐ์ ์๋
const orderId = `SUB_${subscription.id}_${Date.now()}`;
const result = await chargeSubscription(
subscription.billing_key,
subscription.price,
orderId,
`${subscription.plan_name} ๊ตฌ๋
๊ฐฑ์ `
);
if (result.success) {
// 3-A. ๊ฒฐ์ ์ฑ๊ณต ์ฒ๋ฆฌ
await handlePaymentSuccess(subscription, invoiceId, result.data);
} else {
// 3-B. ๊ฒฐ์ ์คํจ ์ฒ๋ฆฌ
await handlePaymentFailure(subscription, invoiceId, result.error);
}
}
๊ฒฐ์ ์ฑ๊ณต/์คํจ ์ฒ๋ฆฌ ๋ก์ง
// ๊ฒฐ์ ์ฑ๊ณต ์ฒ๋ฆฌ
async function handlePaymentSuccess(subscription, invoiceId, pgData) {
const now = new Date();
const nextPeriodEnd = calculateNextPeriodEnd(subscription);
await db.transaction(async (trx) => {
// ์ธ๋ณด์ด์ค ์ํ ์
๋ฐ์ดํธ
await trx.query(
`UPDATE invoices SET status='paid', paid_at=?, pg_transaction_id=? WHERE id=?`,
[now, pgData.paymentKey, invoiceId]
);
// ๊ตฌ๋
๊ธฐ๊ฐ ๊ฐฑ์
await trx.query(
`UPDATE subscriptions
SET current_period_start=?, current_period_end=?, updated_at=?
WHERE id=?`,
[now, nextPeriodEnd, now, subscription.id]
);
});
// ๊ฒฐ์ ์๋ฃ ์ด๋ฉ์ผ ๋ฐ์ก
await sendPaymentSuccessEmail(subscription.email, subscription.price);
console.log(`โ
๊ฒฐ์ ์ฑ๊ณต: ๊ตฌ๋
ID ${subscription.id}`);
}
// ๊ฒฐ์ ์คํจ ์ฒ๋ฆฌ
async function handlePaymentFailure(subscription, invoiceId, error) {
const attemptCount = subscription.attempt_count + 1;
const maxAttempts = 3; // ์ต๋ 3ํ ์ฌ์๋
if (attemptCount >= maxAttempts) {
// ์ต๋ ์ฌ์๋ ์ด๊ณผ โ ๊ตฌ๋
์ํ๋ฅผ past_due๋ก ๋ณ๊ฒฝ
await db.query(
`UPDATE subscriptions SET status='past_due' WHERE id=?`,
[subscription.id]
);
await sendSubscriptionSuspendedEmail(subscription.email);
} else {
// ์ฌ์๋ ์์ฝ (1์ผ ํ)
const nextAttempt = new Date(Date.now() + 24 * 60 * 60 * 1000);
await db.query(
`UPDATE invoices
SET attempt_count=?, next_attempt_at=? WHERE id=?`,
[attemptCount, nextAttempt, invoiceId]
);
await sendPaymentFailedEmail(subscription.email, attemptCount);
}
console.log(`โ ๊ฒฐ์ ์คํจ: ๊ตฌ๋
ID ${subscription.id}, ์๋ ${attemptCount}ํ`);
}
๐ ๊ตฌ๋ ํ๋ ๋ณ๊ฒฝ (์ ๊ทธ๋ ์ด๋/๋ค์ด๊ทธ๋ ์ด๋)
๊ตฌ๋
์๋น์ค์์ ์๊ฐ๋ณด๋ค ๋ณต์กํ ๊ฒ ํ๋ ๋ณ๊ฒฝ ๋ก์ง์ด์ผ!
๊ณ ๊ฐ์ด ๋ฒ ์ด์ง์์ ํ๋ฆฌ๋ฏธ์์ผ๋ก ์
๊ทธ๋ ์ด๋ํ๊ฑฐ๋, ๋ฐ๋๋ก ๋ค์ด๊ทธ๋ ์ด๋ํ ๋
์ด๋ฏธ ๊ฒฐ์ ํ ๊ธ์ก์ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊ฒ์ธ๊ฐ?๊ฐ ํต์ฌ ๋ฌธ์ ์ผ ๐ค
ํ๋ ๋ณ๊ฒฝ ์ฒ๋ฆฌ ๋ฐฉ์ 3๊ฐ์ง
โ ์ ๊ทธ๋ ์ด๋ ์ ๋ง์ด ์ฌ์ฉ
๐ ๋ฐฉ์ B: ๊ธฐ๊ฐ ์ข ๋ฃ ํ ๋ณ๊ฒฝ (At Period End)
ํ์ฌ ๊ตฌ๋ ๊ธฐ๊ฐ์ด ๋๋๋ฉด ์ ํ๋์ผ๋ก ์๋ ์ ํ.
โ ๋ค์ด๊ทธ๋ ์ด๋ ์ ๋ง์ด ์ฌ์ฉ (์ด๋ฏธ ๊ฒฐ์ ํ ๊ธฐ๊ฐ์ ํ์ฌ ํ๋ ํํ ์ ์ง)
๐ ๋ฐฉ์ C: ์ฆ์ ๋ณ๊ฒฝ + ํฌ๋ ๋ง ์ ์ฉ
์ฆ์ ๋ณ๊ฒฝํ๋, ๋จ์ ๊ธฐ๊ฐ์ ๊ธ์ก์ ํฌ๋ ๋ง์ผ๋ก ์ ๋ฆฝํด์ ๋ค์ ๊ฒฐ์ ์ ์ฌ์ฉ.
โ ๊ฐ์ฅ ๊ณ ๊ฐ ์นํ์ ์ธ ๋ฐฉ์
์ผํ ๊ณ์ฐ (Proration) ๋ก์ง
์ ๊ทธ๋ ์ด๋ ์ฆ์ ๋ณ๊ฒฝ ์ ์ฐจ์ก ๊ณ์ฐ ์์:
/**
* ํ๋ ์
๊ทธ๋ ์ด๋ ์ ์ผํ ๊ณ์ฐ
* ์: ๋ฒ ์ด์ง(์ 9,900์) โ ํ๋ฆฌ๋ฏธ์(์ 19,900์)
* ๊ตฌ๋
๊ธฐ๊ฐ ์ค 15์ผ ๋จ์ ์์ ์ ์
๊ทธ๋ ์ด๋
*/
function calculateProration(subscription, newPlan) {
const now = new Date();
const periodEnd = new Date(subscription.current_period_end);
const periodStart = new Date(subscription.current_period_start);
// ์ ์ฒด ๊ตฌ๋
๊ธฐ๊ฐ (์ผ)
const totalDays = Math.ceil(
(periodEnd - periodStart) / (1000 * 60 * 60 * 24)
);
// ๋จ์ ๊ธฐ๊ฐ (์ผ)
const remainingDays = Math.ceil(
(periodEnd - now) / (1000 * 60 * 60 * 24)
);
// ํ์ฌ ํ๋์ ๋จ์ ๊ธฐ๊ฐ ํ๋ถ์ก
const currentPlanRefund =
(subscription.plan.price / totalDays) * remainingDays;
// ์ ํ๋์ ๋จ์ ๊ธฐ๊ฐ ์ฒญ๊ตฌ์ก
const newPlanCharge =
(newPlan.price / totalDays) * remainingDays;
// ์ค์ ์ถ๊ฐ ์ฒญ๊ตฌ์ก (์
๊ทธ๋ ์ด๋์ ๊ฒฝ์ฐ ์์)
const additionalCharge = Math.round(newPlanCharge - currentPlanRefund);
return {
totalDays,
remainingDays,
currentPlanRefund: Math.round(currentPlanRefund),
newPlanCharge: Math.round(newPlanCharge),
additionalCharge
};
}
// ์ฌ์ฉ ์์
// ๋ฒ ์ด์ง 9,900์, ํ๋ฆฌ๋ฏธ์ 19,900์, 30์ผ ์ค 15์ผ ๋จ์
// currentPlanRefund: 4,950์
// newPlanCharge: 9,950์
// additionalCharge: 5,000์ ์ถ๊ฐ ์ฒญ๊ตฌ!
๐ ๋ฌด๋ฃ ์ฒดํ (Free Trial) ๊ตฌํ
"์ฒซ ๋ฌ ๋ฌด๋ฃ!" ์ด๊ฑฐ ๊ตฌ๋
์๋น์ค์์ ์์ฒญ ๊ฐ๋ ฅํ ๋ง์ผํ
๋๊ตฌ์์ ใ
ใ
๊ฐ๋ฐ ๊ด์ ์์ ๋ฌด๋ฃ ์ฒดํ ๊ธฐ๊ฐ์ ์ด๋ป๊ฒ ๊ตฌํํ๋์ง ์์๋ณด์!
- โ ์ฒดํ ๊ธฐ๊ฐ ์ค์๋ ๊ฒฐ์ ๊ฐ ๋ฐ์ํ์ง ์์
- โ ์ฒดํ ๊ธฐ๊ฐ ์ข ๋ฃ ์ ์๋์ผ๋ก ์ ๋ฃ ์ ํ (๋น๋งํค ํ์)
- โ ์ฒดํ ๊ธฐ๊ฐ ์ค ์ทจ์ํ๋ฉด ๊ฒฐ์ ์์ด ์ข ๋ฃ
- โ ๋์ผ ์ฌ์ฉ์๊ฐ ๋ฌด๋ฃ ์ฒดํ์ ์ค๋ณต์ผ๋ก ๋ฐ์ง ๋ชปํ๊ฒ ๋ฐฉ์ง
- โ ์ฒดํ ์ข ๋ฃ D-3, D-1์ ์๋ฆผ ์ด๋ฉ์ผ ๋ฐ์ก
// ๊ตฌ๋
์์ฑ (๋ฌด๋ฃ ์ฒดํ ํฌํจ)
async function createSubscription(userId, planId, paymentMethodId) {
const plan = await getPlan(planId);
const now = new Date();
// ์ด๋ฏธ ๋ฌด๋ฃ ์ฒดํ์ ์ฌ์ฉํ ์ ์๋์ง ํ์ธ
const hadTrial = await db.query(
`SELECT id FROM subscriptions
WHERE user_id = ? AND trial_start IS NOT NULL`,
[userId]
);
const hasTrial = plan.trial_days > 0 && hadTrial.length === 0;
let trialStart = null;
let trialEnd = null;
let periodStart = now;
let periodEnd;
let status;
if (hasTrial) {
// ๋ฌด๋ฃ ์ฒดํ ๊ธฐ๊ฐ ์ค์
trialStart = now;
trialEnd = new Date(now.getTime() + plan.trial_days * 24 * 60 * 60 * 1000);
periodStart = now;
periodEnd = trialEnd;
status = 'trialing';
} else {
// ์ฆ์ ๊ฒฐ์
periodEnd = calculateNextPeriodEnd({ plan, current_period_start: now });
status = 'active';
// ์ฆ์ ๊ฒฐ์ ์ฒ๋ฆฌ
await chargeSubscription(/* ... */);
}
const subscriptionId = await db.query(
`INSERT INTO subscriptions
(user_id, plan_id, status, current_period_start, current_period_end,
trial_start, trial_end, payment_method_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
[userId, planId, status, periodStart, periodEnd,
trialStart, trialEnd, paymentMethodId]
);
return subscriptionId;
}
// ์ฒดํ ๊ธฐ๊ฐ ์ข
๋ฃ ์ฒ๋ฆฌ ์ค์ผ์ค๋ฌ (๋งค์ผ ์คํ)
cron.schedule('0 8 * * *', async () => {
// ์ค๋ ์ฒดํ ๊ธฐ๊ฐ์ด ๋๋๋ ๊ตฌ๋
์กฐํ
const expiringTrials = await db.query(`
SELECT s.*, pm.pg_customer_key as billing_key, p.price, p.name
FROM subscriptions s
JOIN plans p ON s.plan_id = p.id
JOIN payment_methods pm ON s.payment_method_id = pm.id
WHERE s.status = 'trialing'
AND DATE(s.trial_end) = CURDATE()
`);
for (const sub of expiringTrials) {
// ์ฒดํ ์ข
๋ฃ โ ์ ๋ฃ ์ ํ ๊ฒฐ์ ์๋
const result = await chargeSubscription(
sub.billing_key, sub.price,
`SUB_TRIAL_END_${sub.id}`, `${sub.name} ๊ตฌ๋
์์`
);
if (result.success) {
// ์ ๋ฃ ์ ํ ์ฑ๊ณต
await db.query(
`UPDATE subscriptions
SET status='active',
current_period_start=NOW(),
current_period_end=?
WHERE id=?`,
[calculateNextPeriodEnd(sub), sub.id]
);
} else {
// ๊ฒฐ์ ์คํจ โ ๊ตฌ๋
๋ง๋ฃ
await db.query(
`UPDATE subscriptions SET status='expired' WHERE id=?`,
[sub.id]
);
}
}
});
๐ ์นํ (Webhook) ์ฒ๋ฆฌ: PG์ฌ ์ด๋ฒคํธ ์์
PG์ฌ์์ ๊ฒฐ์ ๊ด๋ จ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ์ฐ๋ฆฌ ์๋ฒ๋ก ์๋ฆผ์ ๋ณด๋ด์ค.
์ด๊ฒ ๋ฐ๋ก ์นํ
(Webhook)์ด์ผ!
๊ตฌ๋
์๋น์ค์์ ์นํ
์ฒ๋ฆฌ๋ ์ ํ์ด ์๋๋ผ ํ์์ผ ๐ฏ
payment.completed - ๊ฒฐ์ ์๋ฃ๐
payment.failed - ๊ฒฐ์ ์คํจ๐
payment.canceled - ๊ฒฐ์ ์ทจ์๐
billing.key.issued - ๋น๋งํค ๋ฐ๊ธ ์๋ฃ๐
billing.key.deleted - ๋น๋งํค ์ญ์ (์นด๋ ํด์ง)๐
subscription.renewed - ๊ตฌ๋
๊ฐฑ์ ์๋ฃ๐
subscription.canceled - ๊ตฌ๋
์ทจ์
// Express.js ์นํ
์๋ํฌ์ธํธ
const express = require('express');
const crypto = require('crypto');
const router = express.Router();
router.post('/webhook/toss', express.raw({type: 'application/json'}), async (req, res) => {
// 1. ์นํ
์๋ช
๊ฒ์ฆ (๋ณด์ ํ์!)
const signature = req.headers['toss-signature'];
const webhookSecret = process.env.TOSS_WEBHOOK_SECRET;
const expectedSignature = crypto
.createHmac('sha256', webhookSecret)
.update(req.body)
.digest('hex');
if (signature !== expectedSignature) {
console.error('์นํ
์๋ช
๊ฒ์ฆ ์คํจ!');
return res.status(401).json({ error: 'Invalid signature' });
}
// 2. ์ด๋ฒคํธ ํ์ฑ
const event = JSON.parse(req.body);
// 3. ์ด๋ฒคํธ ํ์
๋ณ ์ฒ๋ฆฌ
try {
switch (event.eventType) {
case 'PAYMENT_STATUS_CHANGED':
await handlePaymentStatusChanged(event.data);
break;
case 'BILLING_KEY_ISSUED':
await handleBillingKeyIssued(event.data);
break;
case 'BILLING_KEY_DELETED':
await handleBillingKeyDeleted(event.data);
break;
default:
console.log('์ฒ๋ฆฌํ์ง ์๋ ์ด๋ฒคํธ:', event.eventType);
}
// 4. ์ฑ๊ณต ์๋ต (๋ฐ๋์ 200 ๋ฐํ!)
res.status(200).json({ received: true });
} catch (error) {
console.error('์นํ
์ฒ๋ฆฌ ์ค๋ฅ:', error);
// ์คํจ ์ PG์ฌ๊ฐ ์ฌ์ ์กํจ
res.status(500).json({ error: 'Processing failed' });
}
});
2. ์นํ ์ฒ๋ฆฌ๋ ๋น ๋ฅด๊ฒ 200 ์๋ต ๋จผ์ ๋ณด๋ด๊ณ , ์ค์ ์ฒ๋ฆฌ๋ ๋น๋๊ธฐ๋ก ํด. ํ์์์ ๋ฐฉ์ง!
3. ๋ชจ๋ ์นํ ์ด๋ฒคํธ๋ฅผ DB์ ๋ก๊น ํด๋๋ฉด ๋์ค์ ๋๋ฒ๊น ํ ๋ ์์ฒญ ํธํด ใ ใ
๐ ๊ตฌ๋ ์ทจ์ ๋ฐฉ์ง ์ ๋ต (Churn Prevention)
๊ฐ๋ฐ์๋ ๋น์ฆ๋์ค ๋ก์ง์ ์ดํดํด์ผ ๋ ์ข์ ์์คํ
์ ๋ง๋ค ์ ์์ด!
๊ตฌ๋
์ทจ์์จ(Churn Rate)์ ๋ฎ์ถ๋ ๊ฑด ๊ตฌ๋
์๋น์ค์ ์์กด๊ณผ ์ง๊ฒฐ๋ผ.
๊ฐ๋ฐ์ ์ผ๋ก ๊ตฌํํ ์ ์๋ ์ดํ ๋ฐฉ์ง ์ ๋ต๋ค์ ์์๋ณด์ ๐ก๏ธ
๋จ๊ณ 1: ์ทจ์ ์ด์ ๋ฌผ์ด๋ณด๊ธฐ (์ค๋ฌธ)
๋จ๊ณ 2: ์ด์ ์ ๋ง๋ ํํ ์ ์ (์: "๊ฐ๊ฒฉ์ด ๋ถ๋ด์ค๋ฌ์ฐ์๋ฉด ํ ์ธ ์ฟ ํฐ ๋๋ฆด๊ฒ์!")
๋จ๊ณ 3: ์ผ์ ์ ์ง ์ต์ ์ ์ (๊ตฌ๋ ์ทจ์ ๋์ 1~3๊ฐ์ ์ ์ง)
๋จ๊ณ 4: ์ต์ข ์ทจ์ ํ์ธ
// ๊ตฌ๋
์ผ์ ์ ์ง ๊ธฐ๋ฅ
async function pauseSubscription(subscriptionId, pauseMonths) {
const subscription = await getSubscription(subscriptionId);
if (subscription.status !== 'active') {
throw new Error('ํ์ฑ ๊ตฌ๋
๋ง ์ผ์ ์ ์งํ ์ ์์ต๋๋ค.');
}
const pauseUntil = new Date(subscription.current_period_end);
pauseUntil.setMonth(pauseUntil.getMonth() + pauseMonths);
await db.query(
`UPDATE subscriptions
SET status='paused',
pause_until=?,
updated_at=NOW()
WHERE id=?`,
[pauseUntil, subscriptionId]
);
// ์ผ์ ์ ์ง ๊ธฐ๊ฐ ๋์ ๊ฒฐ์ ์ค์ผ์ค๋ฌ์์ ์ ์ธ๋จ
// pause_until ์ดํ์ ์๋์ผ๋ก ์ฌ๊ฐ
}
// ์ผ์ ์ ์ง ํด์ ์ค์ผ์ค๋ฌ
cron.schedule('0 9 * * *', async () => {
const resumeSubscriptions = await db.query(`
SELECT * FROM subscriptions
WHERE status='paused' AND pause_until <= NOW()
`);
for (const sub of resumeSubscriptions) {
await db.query(
`UPDATE subscriptions
SET status='active',
current_period_start=NOW(),
current_period_end=?,
pause_until=NULL
WHERE id=?`,
[calculateNextPeriodEnd(sub), sub.id]
);
// ์ฌ๊ฐ ์๋ฆผ ์ด๋ฉ์ผ ๋ฐ์ก
await sendSubscriptionResumedEmail(sub.user_id);
}
});
์ดํ ์์ธก ์๋ฆผ ์์คํ
๋ฐ์ดํฐ๋ฅผ ๋ถ์ํด์ ์ดํ ๊ฐ๋ฅ์ฑ์ด ๋์ ๊ณ ๊ฐ์๊ฒ ์ ์ ์ ์ผ๋ก ์ ๊ทผํ๋ ๋ฐฉ์์ด์ผ.
์ดํ ์ ํธ ์งํ๋ค:
๐ ๊ฒฐ์ ์คํจ ์ด๋ ฅ ์์
๐ ๊ณ ๊ฐ ์ง์ ๋ฌธ์ ์ฆ๊ฐ
๐ ๊ตฌ๋ ์ทจ์ ํ์ด์ง ๋ฐฉ๋ฌธ ์ด๋ ฅ
๐ ์ด๋ฉ์ผ ์คํ์จ ๊ธ๊ฐ
โ ์ด๋ฐ ์ ํธ๊ฐ ๊ฐ์ง๋๋ฉด ์๋์ผ๋ก ํ ์ธ ์ฟ ํฐ ๋ฐ์ก ๋๋ CSํ ์๋ฆผ!
๐ ๋ณด์ & ์ปดํ๋ผ์ด์ธ์ค
๊ตฌ๋
์๋น์ค์์ ๋ณด์์ ํํ์ด ์์ด! ๊ณ ๊ฐ์ ๊ฒฐ์ ์ ๋ณด์ ๊ฐ์ธ์ ๋ณด๋ฅผ ๋ค๋ฃจ๋ ๋งํผ
๋ฒ์ ์๊ฑด๊ณผ ๋ณด์ ๊ธฐ์ค์ ๋ฐ๋์ ์ง์ผ์ผ ํด ๐ก๏ธ
PCI DSS ์ค์
โ ์นด๋ ๋ฒํธ, CVV๋ฅผ ์ง์ ์๋ฒ์์ ์ฒ๋ฆฌํ์ง ์๊ธฐ (PG์ฌ ์์)
โ HTTPS ํ์ ์ ์ฉ
โ ๊ฒฐ์ ๊ด๋ จ ๋ก๊ทธ์์ ๋ฏผ๊ฐ ์ ๋ณด ๋ง์คํน
โ ์ ๊ธฐ์ ์ธ ๋ณด์ ์ทจ์ฝ์ ์ ๊ฒ
โ ์ ๊ทผ ๊ถํ ์ต์ํ ์์น ์ ์ฉ
๊ฐ์ธ์ ๋ณด๋ณดํธ๋ฒ ์ค์
๐ ๊ฒฐ์ ์ ๋ณด ๋ณด๊ด ๊ธฐ๊ฐ ๋ช ์ (๋ณดํต 5๋ , ์ ์์๊ฑฐ๋๋ฒ ๊ธฐ์ค)
๐ ๊ตฌ๋ ์ทจ์ ํ ๊ฐ์ธ์ ๋ณด ํ๊ธฐ ์ ์ฑ ์๋ฆฝ
๐ ๊ฐ์ธ์ ๋ณด ์ฒ๋ฆฌ๋ฐฉ์นจ์ ๊ตฌ๋ ์๋น์ค ๊ด๋ จ ๋ด์ฉ ํฌํจ
๐ ์๋๊ฒฐ์ ๊ด๋ จ ๋ณ๋ ๋์ ํญ๋ชฉ ์ถ๊ฐ
์ ์์๊ฑฐ๋๋ฒ ์ค์ ์ฌํญ
2. ๊ฒฐ์ ํ์ธ ์ด๋ฉ์ผ/SMS: ๋งค ๊ฒฐ์ ์ ๊ณ ๊ฐ์๊ฒ ํ์ธ ํต๋ณด
3. ์ทจ์ ๋ฐฉ๋ฒ ๋ช ์: ์ทจ์ ๋ฐฉ๋ฒ์ ์ฝ๊ฒ ์ฐพ์ ์ ์๊ฒ ์ ๊ณต
4. ์ฒญ์ฝ์ฒ ํ๊ถ: ๋์งํธ ์ฝํ ์ธ ์ธ ์ํ์ 7์ผ ์ด๋ด ์ฒญ์ฝ์ฒ ํ ๊ฐ๋ฅ
5. ๊ฒฐ์ ๋ด์ญ ์กฐํ: ๊ณ ๊ฐ์ด ์ธ์ ๋ ๊ฒฐ์ ๋ด์ญ์ ํ์ธํ ์ ์์ด์ผ ํจ
๐ ๊ตฌ๋ ๊ด๋ฆฌ ๋์๋ณด๋ ๊ตฌํ
๊ด๋ฆฌ์๊ฐ ๊ตฌ๋
ํํฉ์ ํ๋์ ๋ณผ ์ ์๋ ๋์๋ณด๋๋ ํ์์ผ!
์ด๋ค ๋ฐ์ดํฐ๋ฅผ ๋ณด์ฌ์ค์ผ ํ๋์ง ์์๋ณด์ ๐
ํต์ฌ ๋์๋ณด๋ ์ฟผ๋ฆฌ๋ค
-- MRR (์๊ฐ ๋ฐ๋ณต ๋งค์ถ) ๊ณ์ฐ
SELECT
SUM(
CASE p.interval
WHEN 'month' THEN p.price * p.interval_count
WHEN 'year' THEN p.price / 12
WHEN 'week' THEN p.price * 4.33
ELSE p.price
END
) as mrr
FROM subscriptions s
JOIN plans p ON s.plan_id = p.id
WHERE s.status IN ('active', 'trialing');
-- ํ๋๋ณ ๊ตฌ๋
์ ์
SELECT
p.name as plan_name,
COUNT(s.id) as subscriber_count,
SUM(p.price) as total_revenue
FROM subscriptions s
JOIN plans p ON s.plan_id = p.id
WHERE s.status = 'active'
GROUP BY p.id, p.name
ORDER BY subscriber_count DESC;
-- ์๋ณ ์ ๊ท ๊ตฌ๋
vs ์ทจ์ ์ถ์ด
SELECT
DATE_FORMAT(created_at, '%Y-%m') as month,
COUNT(CASE WHEN status != 'canceled' THEN 1 END) as new_subscriptions,
COUNT(CASE WHEN status = 'canceled' THEN 1 END) as cancellations
FROM subscriptions
WHERE created_at >= DATE_SUB(NOW(), INTERVAL 12 MONTH)
GROUP BY month
ORDER BY month;
-- Churn Rate ๊ณ์ฐ (์ด๋ฒ ๋ฌ)
SELECT
(
SELECT COUNT(*) FROM subscriptions
WHERE status = 'canceled'
AND canceled_at >= DATE_FORMAT(NOW(), '%Y-%m-01')
) / (
SELECT COUNT(*) FROM subscriptions
WHERE status IN ('active', 'canceled')
AND created_at < DATE_FORMAT(NOW(), '%Y-%m-01')
) * 100 as churn_rate_percent;
๊ณ ๊ฐ์ฉ ๊ตฌ๋ ๊ด๋ฆฌ ํ์ด์ง ํ์ ๊ธฐ๋ฅ
- โ ํ์ฌ ๊ตฌ๋ ํ๋ ๋ฐ ๋ค์ ๊ฒฐ์ ์ผ ํ์ธ
- โ ๊ฒฐ์ ์๋จ ๋ณ๊ฒฝ (์นด๋ ๊ต์ฒด)
- โ ํ๋ ์ ๊ทธ๋ ์ด๋/๋ค์ด๊ทธ๋ ์ด๋
- โ ๊ตฌ๋ ์ผ์ ์ ์ง
- โ ๊ตฌ๋ ์ทจ์ (์ทจ์ ํ์๋ ๊ธฐ๊ฐ ์ข ๋ฃ๊น์ง ์ด์ฉ ๊ฐ๋ฅ)
- โ ๊ฒฐ์ ๋ด์ญ ์กฐํ ๋ฐ ์์์ฆ ๋ค์ด๋ก๋
- โ ์ฒญ๊ตฌ์ ์ด๋ฉ์ผ ์์ ์ค์
๐ Stripe ํ์ฉ: ๊ธ๋ก๋ฒ ๊ตฌ๋ ์๋น์ค
ํด์ธ ๊ณ ๊ฐ๋ ๋ฐ์ ๊ณํ์ด๋ผ๋ฉด? Stripe๊ฐ ์ต๊ณ ์ ์ ํ์ด์ผ!
Stripe๋ ๊ตฌ๋
์๋น์ค๋ฅผ ์ํ ๊ธฐ๋ฅ์ด ์๋ ์ ๊ฐ์ถฐ์ ธ ์์ด์
์ง์ ๊ตฌํํ๋ ๊ฒ๋ณด๋ค Stripe๋ฅผ ํ์ฉํ๋ ๊ฒ ํจ์ฌ ํจ์จ์ ์ผ ์ ์์ด ๐
๐ Subscriptions API: ๊ตฌ๋ ์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ
๐ Customer Portal: ๊ณ ๊ฐ ์ ํ ๊ด๋ฆฌ ํ์ด์ง (์ฝ๋ฉ ์์ด!)
๐ Smart Retries: AI ๊ธฐ๋ฐ ๊ฒฐ์ ์คํจ ์ฌ์๋ ์ต์ ํ
๐ Revenue Recovery: ์ดํ ๋ฐฉ์ง ์๋ํ
๐ Tax Automation: ๊ธ๋ก๋ฒ ์ธ๊ธ ์๋ ๊ณ์ฐ
๐ Dunning Management: ์ฐ์ฒด ๊ด๋ฆฌ ์๋ํ
// Stripe๋ก ๊ตฌ๋
์์ฑํ๊ธฐ
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
async function createStripeSubscription(customerId, priceId, trialDays) {
const subscription = await stripe.subscriptions.create({
customer: customerId,
items: [{ price: priceId }],
trial_period_days: trialDays || 0,
payment_settings: {
payment_method_types: ['card'],
save_default_payment_method: 'on_subscription'
},
expand: ['latest_invoice.payment_intent']
});
return subscription;
}
// Stripe ์นํ
์ฒ๋ฆฌ
app.post('/webhook/stripe', express.raw({type: 'application/json'}), (req, res) => {
const sig = req.headers['stripe-signature'];
let event;
try {
event = stripe.webhooks.constructEvent(
req.body, sig, process.env.STRIPE_WEBHOOK_SECRET
);
} catch (err) {
return res.status(400).send(`Webhook Error: ${err.message}`);
}
switch (event.type) {
case 'invoice.payment_succeeded':
// ๊ฒฐ์ ์ฑ๊ณต ์ฒ๋ฆฌ
break;
case 'invoice.payment_failed':
// ๊ฒฐ์ ์คํจ ์ฒ๋ฆฌ
break;
case 'customer.subscription.deleted':
// ๊ตฌ๋
์ทจ์ ์ฒ๋ฆฌ
break;
case 'customer.subscription.trial_will_end':
// ์ฒดํ ์ข
๋ฃ 3์ผ ์ ์๋ฆผ
break;
}
res.json({ received: true });
});
โ ๊ธ๋ก๋ฒ ์๋น์ค: Stripe ์ถ์ฒ
โ ๊ตญ๋ด+ํด์ธ ๋์: ํฌํธ์(๊ตญ๋ด) + Stripe(ํด์ธ) ์ด์ค ๊ตฌ์กฐ
์ฌ๋ฅ๋ท์ฒ๋ผ ๊ตญ๋ด ํ๋ซํผ์ด๋ผ๋ฉด ํ ์คํ์ด๋จผ์ธ ๋ ํฌํธ์์ด ๊ฐ๋ฐ ํธ์์ฑ ๋ฉด์์ ํจ์ฌ ์ข์!
๐งช ํ ์คํธ ์ ๋ต: ๊ตฌ๋ ์๋น์ค QA
๊ตฌ๋
์๋น์ค๋ ๋์ด ์ง์ ์ค๊ฐ๋ ์์คํ
์ด๋ผ ํ
์คํธ๊ฐ ์์ฒญ ์ค์ํด!
์ด๋ค ์๋๋ฆฌ์ค๋ฅผ ํ
์คํธํด์ผ ํ๋์ง ์ฒดํฌ๋ฆฌ์คํธ๋ก ์ ๋ฆฌํด์ค๊ฒ โ
โ ์ ๊ท ๊ตฌ๋ ์์ฑ (์ฆ์ ๊ฒฐ์ )
โ ๋ฌด๋ฃ ์ฒดํ ๊ตฌ๋ ์์ฑ
โ ๋ฌด๋ฃ ์ฒดํ โ ์ ๋ฃ ์ ํ
โ ๊ตฌ๋ ๊ฐฑ์ (๋ค์ ์ฃผ๊ธฐ ๊ฒฐ์ )
โ ํ๋ ์ ๊ทธ๋ ์ด๋ (์ฆ์ ๋ณ๊ฒฝ)
โ ํ๋ ๋ค์ด๊ทธ๋ ์ด๋ (๊ธฐ๊ฐ ์ข ๋ฃ ํ ๋ณ๊ฒฝ)
โ ๊ตฌ๋ ์ทจ์ (๊ธฐ๊ฐ ์ข ๋ฃ ํ ๋ง๋ฃ)
โ ๊ตฌ๋ ์ฆ์ ์ทจ์
[์์ธ ํ๋ก์ฐ]
โ ๊ฒฐ์ ์คํจ ์ฒ๋ฆฌ
โ ๊ฒฐ์ ์คํจ ์ฌ์๋ (1์ฐจ, 2์ฐจ, 3์ฐจ)
โ ์ต๋ ์ฌ์๋ ์ด๊ณผ โ ๊ตฌ๋ ์ ์ง
โ ์นด๋ ๋ณ๊ฒฝ ํ ์ฌ๊ฒฐ์
โ ์นํ ์ค๋ณต ์์ ์ฒ๋ฆฌ
โ ์นํ ์๋ช ๊ฒ์ฆ ์คํจ
โ PG์ฌ API ํ์์์
โ ๋์ ๊ฒฐ์ ์์ฒญ (Race Condition)
[์ฃ์ง ์ผ์ด์ค]
โ ์ค๋ 2์ 29์ผ ๊ตฌ๋ (๋ค์ ๋ฌ ์ฒ๋ฆฌ)
โ ์๋ง ๊ตฌ๋ (31์ผ โ ๋ค์ ๋ฌ 28/30์ผ)
โ ์๊ฐ๋(Timezone) ์ฒ๋ฆฌ
โ ๊ตฌ๋ ์ค ํ๋ ๊ฐ๊ฒฉ ๋ณ๊ฒฝ ์ ๊ธฐ์กด ๊ตฌ๋ ์ ์ฒ๋ฆฌ
// Jest๋ฅผ ์ด์ฉํ ๊ตฌ๋
๊ฐฑ์ ๋จ์ ํ
์คํธ ์์
describe('๊ตฌ๋
๊ฐฑ์ ํ
์คํธ', () => {
test('์ ์ ๊ฒฐ์ ์ฑ๊ณต ์ ๊ตฌ๋
๊ธฐ๊ฐ์ด ๊ฐฑ์ ๋์ด์ผ ํจ', async () => {
// Given
const mockSubscription = {
id: 1,
plan: { price: 9900, interval: 'month', interval_count: 1 },
current_period_end: new Date('2024-01-31'),
billing_key: 'test_billing_key'
};
// PG์ฌ API ๋ชจํน
jest.spyOn(pgService, 'charge').mockResolvedValue({
success: true,
data: { paymentKey: 'test_payment_key_123' }
});
// When
await processSubscriptionRenewal(mockSubscription);
// Then
const updated = await getSubscription(1);
expect(updated.status).toBe('active');
expect(new Date(updated.current_period_end))
.toEqual(new Date('2024-02-29')); // 2024๋
์ ์ค๋
!
});
test('๊ฒฐ์ ์คํจ ์ attempt_count๊ฐ ์ฆ๊ฐํด์ผ ํจ', async () => {
jest.spyOn(pgService, 'charge').mockResolvedValue({
success: false,
error: { code: 'CARD_DECLINED' }
});
await processSubscriptionRenewal(mockSubscription);
const invoice = await getLatestInvoice(1);
expect(invoice.attempt_count).toBe(1);
expect(invoice.next_attempt_at).toBeDefined();
});
});
๐ฏ ๊ตฌํ ๋ก๋๋งต: ์ด๋์๋ถํฐ ์์ํ ๊น?
์, ์ด์ ์ ์ฒด์ ์ธ ๊ทธ๋ฆผ์ด ๊ทธ๋ ค์ก์ง? ใ
ใ
์ฒ์ ๊ตฌ๋
์๋น์ค๋ฅผ ๊ตฌํํ๋ค๋ฉด ์ด ์์๋ก ์งํํ๋ ๊ฑธ ์ถ์ฒํด!
์ด๋ค ์ ํ์ ๊ตฌ๋ ์ธ์ง, ํ๋์ ๋ช ๊ฐ์ธ์ง, ๊ฐ๊ฒฉ ์ ์ฑ ์ ์ด๋ป๊ฒ ํ ์ง ๋จผ์ ํ์ ํด. ์ด๊ฒ DB ์ค๊ณ์ ์ง์ ์ํฅ์ ์ค!
plans, subscriptions, invoices, payment_methods ํ ์ด๋ธ ์ค๊ณ. ์ฒ์์ ์ ์ง์ผ ๋์ค์ ์ ๊ณ ์ํด!
๊ตญ๋ด ์๋น์ค๋ฉด ํ ์คํ์ด๋จผ์ธ ๋ ํฌํธ์, ๊ธ๋ก๋ฒ์ด๋ฉด Stripe. ๋น๋งํค ๋ฐ๊ธ๋ถํฐ ๊ตฌํ!
๋ฌด๋ฃ ์ฒดํ ํฌํจ/๋ฏธํฌํจ ๊ตฌ๋ ์์ฑ ๋ก์ง ๊ตฌํ. ์ฆ์ ๊ฒฐ์ ๋๋ ์ฒดํ ์์.
Cron Job์ผ๋ก ๋งค์ผ ๊ฒฐ์ ๋์ ์กฐํ ๋ฐ ์๋ ๊ฒฐ์ ์คํ. ์คํจ ์ฒ๋ฆฌ ๋ก์ง ํฌํจ!
PG์ฌ ์ด๋ฒคํธ ์์ ๋ฐ ์ฒ๋ฆฌ. ์๋ช ๊ฒ์ฆ ํ์!
ํ๋ ๋ณ๊ฒฝ, ๊ฒฐ์ ์๋จ ๋ณ๊ฒฝ, ๊ตฌ๋ ์ทจ์/์ผ์์ ์ง ๊ธฐ๋ฅ.
MRR, Churn Rate, ๊ตฌ๋ ์ ํํฉ ๋ฑ ํต์ฌ ์งํ ์๊ฐํ.
๋ชจ๋ ์๋๋ฆฌ์ค ํ ์คํธ. ํนํ ์ฃ์ง ์ผ์ด์ค์ ๊ฒฐ์ ์คํจ ์ผ์ด์ค ์ง์ค ํ ์คํธ!
๊ฒฐ์ ์คํจ์จ, ์ดํ๋ฅ ๋ชจ๋ํฐ๋ง. ์ด์ ์งํ ๋ฐ์ ์ Slack ์๋ฆผ ๋ฑ ์ค์ .
โ ํ๋ ๋ณ๊ฒฝ + ์ผ์์ ์ง + ๋์๋ณด๋: +2์ฃผ
โ ์ดํ ๋ฐฉ์ง + ๊ณ ๊ธ ๋ถ์: +2~4์ฃผ
โ ์ ์ฒด ์์ฑ: ์ฝ 6~9์ฃผ
โจ ๋ง๋ฌด๋ฆฌ: ๊ตฌ๋ ์๋น์ค ๊ฐ๋ฐ์ ํต์ฌ ์ ๋ฆฌ
์, ์ฌ๊ธฐ๊น์ง ๋ฐ๋ผ์๋ค๋ฉด ์ง์ง ๋๋จํ ๊ฑฐ์ผ ใ
ใ
ใ
๐
์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ ํ ๋ฒ์ ์ ๋ฆฌํด๋ณผ๊ฒ:
2๏ธโฃ ๋น๋งํค๊ฐ ์๋๊ฒฐ์ ์ ์ด์ - ์นด๋ ๋ฒํธ ์ ์ฅ ๊ธ์ง, ๋น๋งํค๋ง ์ ์ฅ
3๏ธโฃ ์ค์ผ์ค๋ฌ + ์นํ ์ด์ค ๊ตฌ์กฐ - ์ค์ผ์ค๋ฌ๋ก ๊ฒฐ์ ์คํ, ์นํ ์ผ๋ก ๊ฒฐ๊ณผ ์์
4๏ธโฃ ๊ฒฐ์ ์คํจ ์ฒ๋ฆฌ๊ฐ ์ง์ง ์ค์ - ์ฌ์๋ ๋ก์ง, ๊ณ ๊ฐ ์๋ฆผ, ๊ตฌ๋ ์ ์ง ์ฒ๋ฆฌ
5๏ธโฃ ๊ณ ๊ฐ ๊ฒฝํ์ด ์ดํ๋ฅ ์ ๊ฒฐ์ - ์ทจ์ ํ๋ก์ฐ, ์ผ์์ ์ง, ๋ช ํํ ์๋ด
6๏ธโฃ ๋ณด์๊ณผ ๋ฒ์ ์๊ฑด ํ์ - PCI DSS, ๊ฐ์ธ์ ๋ณด๋ณดํธ๋ฒ, ์ ์์๊ฑฐ๋๋ฒ
7๏ธโฃ ํ ์คํธ๋ ๋ชจ๋ ์๋๋ฆฌ์ค๋ฅผ - ํนํ ์ฃ์ง ์ผ์ด์ค์ ์คํจ ์ผ์ด์ค ์ง์ค
๊ตฌ๋
์๋น์ค ๊ฐ๋ฐ์ ๋จ์ํ "๋งค๋ฌ ๊ฒฐ์ ํ๋ ๊ธฐ๋ฅ"์ด ์๋์ผ.
๊ณ ๊ฐ์ ์ ๋ขฐ๋ฅผ ๋ค๋ฃจ๋ ์์คํ
์ด๊ณ , ๋น์ฆ๋์ค์ ์๋ช
์ค์ด์ผ.
๊ทธ๋งํผ ๊ผผ๊ผผํ๊ฒ, ๊ทธ๋ฆฌ๊ณ ๊ณ ๊ฐ ์
์ฅ์์ ์๊ฐํ๋ฉด์ ๊ฐ๋ฐํด์ผ ํด ๐ช
์ด๋ฐ ๋ณต์กํ ๊ฐ๋ฐ ์ง์์ด ํ์ํ ๋, ์ฌ๋ฅ๋ท์์ ๊ตฌ๋
์๋น์ค ๊ฐ๋ฐ ๊ฒฝํ์ด ์๋ ์ ๋ฌธ ๊ฐ๋ฐ์๋ฅผ ์ฐพ์๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ!
ํผ์ ๋ค ํ๊ธฐ ํ๋ค ๋๋ ๋์์ ๋ฐ๋ ๊ฒ๋ ํ๋ช
ํ ์ ํ์ด๊ฑฐ๋ ๐
์, ์ด์ ์ง์ง ๊ตฌ๋
์๋น์ค ๋ง๋ค๋ฌ ๊ฐ๋ณด์๊ณ ! ํ์ดํ
! ๐๐ฅ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.