30 Essential Finance, Economics, and Business Concepts for Developers

def compound_interest(principal, rate, years):
    """Compound interest -- money that grows recursively"""
    return principal * (1 + rate) ** years

# 1 million KRW/month, 7% annual return, 20 years
monthly = 1_000_000
annual_rate = 0.07
years = 20

# Simple interest: 1M x 12 x 20 = 240M KRW
simple = monthly * 12 * years

# Compound interest: ~520M KRW (more than double!)
compound = sum(
    monthly * (1 + annual_rate/12) ** (years*12 - i)
    for i in range(years * 12)
)
print(f"Simple: {simple:,.0f} KRW")      # 240,000,000 KRW
print(f"Compound: {compound:,.0f} KRW")  # ~520,000,000 KRW

def roi(gain, cost):
    """ROI = (Gain - Cost) / Cost x 100%"""
    return (gain - cost) / cost * 100

# GPU server investment
server_cost = 5_000_000       # RTX 5090 server 5M KRW
annual_revenue = 2_000_000    # AI API service annual revenue 2M KRW

print(f"1-year ROI: {roi(annual_revenue, server_cost):.1f}%")  # -60%
print(f"3-year ROI: {roi(annual_revenue * 3, server_cost):.1f}%")  # 20%

Option A: Stay at current company (60M KRW salary, stable)
Option B: Switch jobs (80M KRW salary, risky)

Opportunity cost: Choosing A means giving up the extra 20M KRW from B
                  Choosing B means giving up the stability of A

-> Developer analogy: Same structure as CPU vs Memory trade-offs

def real_value(nominal, inflation_rate, years):
    """Real value considering inflation"""
    return nominal / (1 + inflation_rate) ** years

salary_2026 = 60_000_000
inflation = 0.03  # 3% annually

# Real value of 60M KRW in 10 years
real = real_value(salary_2026, inflation, 10)
print(f"Real value of 60M KRW in 2036: {real:,.0f} KRW")
# -> ~44.65M KRW (25% value loss!)

Time for an investment to double:
72 / Rate(%) = Years required

Example: 7% annual return -> 72 / 7 = ~10.3 years
Example: 3% annual inflation -> 72 / 3 = 24 years (money loses half its value)

def per(stock_price, earnings_per_share):
    """Price-to-Earnings Ratio -- lower means undervalued"""
    return stock_price / earnings_per_share

# Samsung Electronics
samsung_per = per(70_000, 5_000)  # PER = 14
# NVIDIA
nvidia_per = per(130, 3.5)  # PER = 37

# PER 14: It takes 14 years to recoup investment at current earnings
# PER 37: The market values NVIDIA's future growth highly

market_cap = stock_price * total_shares

# Apple: $3.5T = "Entire K8s cluster"
# Startup: $10M = "Single Pod"

ETF (e.g., S&P 500):
  -> Like a framework such as Next.js -- diversified, stable, market-average returns
  -> Average annual return: ~10%

Individual stocks:
  -> Like building with vanilla JS -- high returns possible but high risk
  -> NVIDIA 2023-2025: +800%, but individual stocks can also go -90%

Government bonds: Safe, low returns (3-4%)
Corporate bonds: Medium risk, medium returns (5-8%)
High yield: High risk, high returns (10%+)

-> Developer analogy:
  Government bonds = Well-tested libraries
  Corporate bonds = Popular open source projects
  High yield = GitHub repos with 1 star

Leveraged investing: Investing with borrowed money
-> 2x leverage: Gains 2x, losses 2x
-> Forced liquidation when asset value drops below a threshold

Margin Call = OOM Killer
  When memory (capital) runs low, the kernel (brokerage) force-kills the process (position)

revenue = 100_000_000       # Revenue 100M KRW
cogs = 40_000_000           # Cost of goods sold 40M KRW
gross_profit = revenue - cogs  # Gross profit 60M KRW

operating_expenses = 30_000_000  # Operating expenses 30M KRW
operating_profit = gross_profit - operating_expenses  # Operating profit 30M KRW

# Operating margin = 30% -> Healthy software company
margin = operating_profit / revenue * 100

A company can go bankrupt with 10 billion KRW in revenue if it has no cash.

Revenue is not equal to Cash
  -> Revenue recognition: At contract signing (future money)
  -> Cash inflow: At actual deposit (present money)

Developer analogy: Promised API response vs actually received data

def break_even_point(fixed_costs, price_per_unit, variable_cost_per_unit):
    """BEP = Fixed Costs / (Price - Variable Cost)"""
    return fixed_costs / (price_per_unit - variable_cost_per_unit)

# SaaS service
fixed = 50_000_000    # Server + labor costs 50M KRW/month
price = 50_000        # Subscription 50K KRW/month
variable = 5_000      # Server cost per user 5K KRW

bep = break_even_point(fixed, price, variable)
print(f"Break-even: {bep:.0f} users")  # 1,111 users

def dcf(cash_flows, discount_rate):
    """Present value of future cash flows"""
    return sum(
        cf / (1 + discount_rate) ** (i + 1)
        for i, cf in enumerate(cash_flows)
    )

# Startup valuation
future_cash = [0, 0, 10_000_000, 50_000_000, 100_000_000]  # 5 years
discount = 0.15  # 15% discount rate (reflecting risk)

value = dcf(future_cash, discount)
print(f"Company value: {value:,.0f} KRW")  # ~88M KRW

Stock Options:
  -> The right to buy shares at a set price in the future
  -> Exercise price 10,000 KRW, current price 50,000 KRW -> profit of 40,000 KRW/share
  -> 4-year vesting with 1-year cliff is standard

RSU (Restricted Stock Unit):
  -> Shares granted for free after a set period
  -> "Stock options with exercise price of 0"
  -> Mainly used by large companies (Google, Meta, etc.)

Developer decision criteria:
  1. What is the likelihood of the company going public or being acquired?
  2. What is the exercise price relative to the current valuation?
  3. Are you willing to stay at the company for 4 years?
  4. What is the expected return compared to cash compensation?

[ ] Secure 6 months of emergency funds
[ ] Get tax deductions through pension savings/IRP (up to ~1.15M KRW/year)
[ ] Auto-invest 20%+ of salary (ETF contributions)
[ ] Research the market before salary negotiations
[ ] Carefully review stock option/RSU terms
[ ] Compare mid-career severance settlement vs end-of-employment payout
[ ] Calculate health insurance and national pension contributions