Split View: 개인 재무 관리 완전 가이드: 예산 수립부터 자산 형성까지

Monthly after-tax income: USD 5,000

Needs (50%) = USD 2,500
  Rent/mortgage:          USD 1,400
  Groceries:              USD 350
  Utilities + internet:   USD 150
  Transportation:         USD 350
  Minimum debt payments:  USD 250

Wants (30%) = USD 1,500
  Dining out:             USD 300
  Entertainment:          USD 200
  Shopping:               USD 400
  Subscriptions:          USD 100
  Travel fund:            USD 300
  Personal care:          USD 200

Savings/Debt/Investing (20%) = USD 1,000
  Emergency fund:         USD 200
  401k contribution:      USD 400
  Roth IRA:               USD 250
  Extra debt payment:     USD 150

Monthly income: USD 5,000

Expense allocations:
  Rent:              USD 1,400
  Groceries:         USD 350
  Utilities:         USD 150
  Transportation:    USD 350
  Dining out:        USD 250
  Entertainment:     USD 150
  Shopping:          USD 200
  Subscriptions:     USD 80
  Personal care:     USD 120
  Miscellaneous:     USD 100
  Total expenses:    USD 3,150

Savings/investing allocations:
  Emergency fund:    USD 300
  401k:              USD 600
  Roth IRA:          USD 500
  Brokerage account: USD 300
  Vacation fund:     USD 150
  Total saved:       USD 1,850

Remaining: USD 5,000 - USD 3,150 - USD 1,850 = USD 0

Monthly essential expenses:
  Rent/mortgage:   USD 1,400
  Groceries:       USD 350
  Utilities:       USD 150
  Transportation:  USD 350
  Insurance:       USD 200
  Minimum debt:    USD 250
  Total essential: USD 2,700

3-month target: USD 8,100
6-month target: USD 16,200

Recommended starting goal: USD 10,000

Debt list (Snowball order):

Priority  Debt             Balance    APR    Min Payment
1         Medical bill     USD 400    0%     USD 20
2         Store card       USD 800    22%    USD 25
3         Personal loan    USD 3,200  14%    USD 80
4         Car loan         USD 12,000 6%     USD 240
5         Student loan     USD 28,000 5.5%   USD 300

Monthly extra payment available: USD 300

Action: Pay minimums on items 2-5, apply USD 300 extra to item 1
Result: Item 1 paid off in 2 months
Then: USD 320 (USD 20 + USD 300) now attacks item 2

Debt list (Avalanche order):

Priority  Debt             Balance    APR    Min Payment
1         Store card       USD 800    22%    USD 25
2         Personal loan    USD 3,200  14%    USD 80
3         Car loan         USD 12,000 6%     USD 240
4         Student loan     USD 28,000 5.5%   USD 300
5         Medical bill     USD 400    0%     USD 20

Monthly extra payment available: USD 300

Action: Pay minimums on items 2-5, apply USD 300 extra to item 1
Result: Item 1 (store card) paid off in ~3 months
Then: USD 325 now attacks personal loan at 14%

Always contribute enough to capture the full employer match.
This is an immediate 50-100% return on your contribution.

Example:
  Your salary: USD 70,000
  Your contribution: USD 3,500 (5%)
  Employer match: USD 3,500 (5% match)
  Total invested: USD 7,000
  Immediate return: 100%

Conservative (Age 50+):
  US Total Market ETF:        40%
  International ETF:          20%
  US Bond ETF:                40%

Moderate (Age 35-50):
  US Total Market ETF:        50%
  International ETF:          30%
  US Bond ETF:                20%

Aggressive (Age 20-35):
  US Total Market ETF:        60%
  International ETF:          30%
  US Bond ETF:                10%

Stock allocation (%) = 110 - Your Age

Examples:
  Age 25: 85% stocks, 15% bonds
  Age 40: 70% stocks, 30% bonds
  Age 55: 55% stocks, 45% bonds

Student loan interest:     Up to USD 2,500
IRA contribution:          Up to USD 7,000
HSA contribution:          Up to USD 4,300 (individual)
Self-employed health ins.: 100% of premiums
Teacher classroom exp.:    Up to USD 300

Child Tax Credit:              Up to USD 2,000 per child
Earned Income Tax Credit:      Up to USD 7,800 (varies by income)
Saver's Credit:                Up to USD 1,000 (USD 2,000 MFJ)
Lifetime Learning Credit:      Up to USD 2,000
American Opportunity Credit:   Up to USD 2,500 (first 4 years college)

Tax-deferred accounts (Traditional 401k, IRA):
  - Bonds and bond ETFs (high ordinary income)
  - REITs (high dividend income)
  - High-turnover active funds

Roth accounts (Roth IRA, Roth 401k):
  - High-growth assets (small-cap, international)
  - Assets expected to appreciate most

Taxable brokerage:
  - Tax-efficient index ETFs (low turnover)
  - Municipal bonds (if in high tax bracket)
  - I Bonds (tax-deferred interest)

2026 Roth IRA income limits:
  - Phase-out starts: USD 150,000 (single), USD 236,000 (MFJ)
  - Phase-out ends: USD 165,000 (single), USD 246,000 (MFJ)

Backdoor Roth steps:
  1. Contribute USD 7,000 to a Traditional IRA (non-deductible)
  2. Convert the Traditional IRA to a Roth IRA
  3. Result: Roth IRA contribution with no income limit

Note: The "pro-rata rule" applies if you have other pre-tax IRA funds.
Consult a tax professional before executing.

def compound_interest_calculator(
    principal: float,
    annual_rate: float,
    years: int,
    monthly_contribution: float = 0,
    compounds_per_year: int = 12
) -> dict:
    """
    Compound interest calculator with optional monthly contributions.

    Args:
        principal: Initial investment amount (USD)
        annual_rate: Annual return rate (e.g., 0.07 for 7%)
        years: Investment horizon in years
        monthly_contribution: Additional monthly investment (USD)
        compounds_per_year: How many times interest compounds per year

    Returns:
        Dictionary with final value, total invested, and total earnings
    """
    r = annual_rate / compounds_per_year
    n = compounds_per_year * years

    # Future value of initial principal
    fv_principal = principal * (1 + r) ** n

    # Future value of monthly contributions (annuity formula)
    if r > 0:
        fv_contributions = monthly_contribution * (
            ((1 + r) ** n - 1) / r
        )
    else:
        fv_contributions = monthly_contribution * n

    total_future_value = fv_principal + fv_contributions
    total_invested = principal + (monthly_contribution * n)
    total_earnings = total_future_value - total_invested

    return {
        "final_value": round(total_future_value, 2),
        "total_invested": round(total_invested, 2),
        "total_earnings": round(total_earnings, 2),
        "return_pct": round((total_earnings / total_invested) * 100, 2)
    }


# Example: Investing USD 10,000 plus USD 500/month for 30 years at 7%
result = compound_interest_calculator(
    principal=10_000,
    annual_rate=0.07,
    years=30,
    monthly_contribution=500
)

print("=== Compound Interest Calculator ===")
print(f"Final Value:     ${result['final_value']:>12,.2f}")
print(f"Total Invested:  ${result['total_invested']:>12,.2f}")
print(f"Total Earnings:  ${result['total_earnings']:>12,.2f}")
print(f"Return:          {result['return_pct']:>11.2f}%")

def fire_simulation(
    current_age: int,
    current_portfolio: float,
    annual_expenses: float,
    annual_income: float,
    savings_rate: float,
    investment_return: float = 0.07,
    safe_withdrawal_rate: float = 0.04,
    inflation_rate: float = 0.03
) -> dict:
    """
    FIRE (Financial Independence, Retire Early) simulation.

    Args:
        current_age: Your current age
        current_portfolio: Current invested assets (USD)
        annual_expenses: Current annual living expenses (USD)
        annual_income: Annual after-tax income (USD)
        savings_rate: Fraction of income saved (e.g., 0.30 = 30%)
        investment_return: Expected annual portfolio return
        safe_withdrawal_rate: Annual withdrawal rate in retirement (4% rule)
        inflation_rate: Expected annual inflation rate

    Returns:
        FIRE number, projected age at retirement, years to FIRE
    """
    # FIRE number: the portfolio needed to sustain expenses indefinitely
    fire_number = annual_expenses / safe_withdrawal_rate

    # Real (inflation-adjusted) return
    real_return = (1 + investment_return) / (1 + inflation_rate) - 1

    annual_savings = annual_income * savings_rate
    portfolio = current_portfolio
    years = 0

    while portfolio < fire_number:
        portfolio = portfolio * (1 + real_return) + annual_savings
        years += 1
        if years > 100:
            return {
                "error": "FIRE is not achievable within 100 years at current savings rate. "
                         "Consider increasing income, reducing expenses, or both."
            }

    fire_age = current_age + years

    return {
        "fire_number": round(fire_number, 2),
        "fire_age": fire_age,
        "years_to_fire": years,
        "current_portfolio": round(current_portfolio, 2),
        "annual_savings": round(annual_savings, 2),
        "monthly_savings": round(annual_savings / 12, 2),
        "savings_rate_pct": savings_rate * 100
    }


# Example: 30-year-old, USD 50k portfolio, USD 60k expenses, USD 100k income, 30% savings rate
result = fire_simulation(
    current_age=30,
    current_portfolio=50_000,
    annual_expenses=60_000,
    annual_income=100_000,
    savings_rate=0.30,
    investment_return=0.07,
    safe_withdrawal_rate=0.04
)

print("\n=== FIRE Simulation Results ===")
for key, value in result.items():
    if isinstance(value, float) and value > 1000:
        print(f"{key:25s}: ${value:>12,.2f}")
    else:
        print(f"{key:25s}: {value}")

def goal_savings_calculator(
    target_amount: float,
    current_savings: float,
    monthly_contribution: float,
    annual_return: float
) -> dict:
    """
    Calculate time needed to reach a financial goal.

    Args:
        target_amount: Target savings goal (USD)
        current_savings: Current amount saved (USD)
        monthly_contribution: Monthly contribution amount (USD)
        annual_return: Expected annual return rate

    Returns:
        Months needed, years and months breakdown, projected final amount
    """
    monthly_return = annual_return / 12
    months = 0
    portfolio = current_savings

    while portfolio < target_amount:
        portfolio = portfolio * (1 + monthly_return) + monthly_contribution
        months += 1
        if months > 600:
            break

    years = months // 12
    remaining_months = months % 12

    return {
        "target_amount": round(target_amount, 2),
        "months_needed": months,
        "time_to_goal": f"{years} years, {remaining_months} months",
        "projected_balance": round(portfolio, 2)
    }


# Example 1: House down payment
down_payment_goal = goal_savings_calculator(
    target_amount=60_000,
    current_savings=10_000,
    monthly_contribution=1_200,
    annual_return=0.05
)

print("\n=== Down Payment Goal ===")
print(f"Target:           ${down_payment_goal['target_amount']:>10,.2f}")
print(f"Time needed:      {down_payment_goal['time_to_goal']}")
print(f"Projected balance:${down_payment_goal['projected_balance']:>10,.2f}")

# Example 2: USD 1 million retirement milestone
million_goal = goal_savings_calculator(
    target_amount=1_000_000,
    current_savings=50_000,
    monthly_contribution=1_500,
    annual_return=0.07
)

print("\n=== USD 1 Million Milestone ===")
print(f"Target:           ${million_goal['target_amount']:>10,.2f}")
print(f"Time needed:      {million_goal['time_to_goal']}")
print(f"Projected balance:${million_goal['projected_balance']:>10,.2f}")

def compare_debt_payoff_methods(
    debts: list,
    extra_monthly_payment: float
) -> dict:
    """
    Compare Snowball and Avalanche debt payoff methods.

    Args:
        debts: List of dicts with keys: name, balance, apr, min_payment
        extra_monthly_payment: Extra money available beyond minimums

    Returns:
        Comparison of total interest paid and months for each method
    """
    import copy

    def simulate_payoff(debt_list, method):
        debts_copy = copy.deepcopy(debt_list)
        total_interest = 0
        months = 0

        while any(d["balance"] > 0 for d in debts_copy):
            months += 1
            monthly_rate_list = [d["apr"] / 12 for d in debts_copy]

            # Sort based on method
            active = [d for d in debts_copy if d["balance"] > 0]
            if method == "snowball":
                active.sort(key=lambda x: x["balance"])
            else:  # avalanche
                active.sort(key=lambda x: -x["apr"])

            # Apply interest and minimum payments
            for i, debt in enumerate(debts_copy):
                if debt["balance"] > 0:
                    interest = debt["balance"] * (debt["apr"] / 12)
                    total_interest += interest
                    debt["balance"] += interest
                    payment = min(debt["min_payment"], debt["balance"])
                    debt["balance"] -= payment
                    debt["balance"] = max(0, debt["balance"])

            # Apply extra payment to priority debt
            remaining_extra = extra_monthly_payment
            for debt in active:
                match = next((d for d in debts_copy if d["name"] == debt["name"]), None)
                if match and match["balance"] > 0:
                    applied = min(remaining_extra, match["balance"])
                    match["balance"] -= applied
                    remaining_extra -= applied
                if remaining_extra <= 0:
                    break

            if months > 600:
                break

        return {"months": months, "total_interest": round(total_interest, 2)}

    snowball_result = simulate_payoff(debts, "snowball")
    avalanche_result = simulate_payoff(debts, "avalanche")

    return {
        "snowball": snowball_result,
        "avalanche": avalanche_result,
        "interest_saved_with_avalanche": round(
            snowball_result["total_interest"] - avalanche_result["total_interest"], 2
        )
    }


# Example debts
my_debts = [
    {"name": "Credit Card A", "balance": 3_500, "apr": 0.22, "min_payment": 75},
    {"name": "Medical Bill",  "balance": 800,   "apr": 0.00, "min_payment": 30},
    {"name": "Personal Loan", "balance": 8_000, "apr": 0.14, "min_payment": 180},
    {"name": "Car Loan",      "balance": 15_000, "apr": 0.06, "min_payment": 280},
]

comparison = compare_debt_payoff_methods(my_debts, extra_monthly_payment=400)

print("\n=== Debt Payoff Method Comparison ===")
print(f"Snowball:  {comparison['snowball']['months']} months, "
      f"${comparison['snowball']['total_interest']:,.2f} total interest")
print(f"Avalanche: {comparison['avalanche']['months']} months, "
      f"${comparison['avalanche']['total_interest']:,.2f} total interest")
print(f"Interest saved with Avalanche: ${comparison['interest_saved_with_avalanche']:,.2f}")