SQL for Finance: Essential Skills and Queries Every Financial Professional Needs (2026)

Quick Navigation

• Why Financial Professionals Need SQL
• SQL vs Excel for Finance
• 5 Essential SQL Skills for Finance
• Real-World Finance SQL Queries
• SQL for Financial Reporting
• SQL Interview Questions for Finance Roles
• Your 6-Week SQL Learning Roadmap
• FAQ

Example: 10 Minutes in Excel vs 3 Lines of SQL

Find the average transaction amount by customer type for Q4 2024:

SELECT 
  customer_type,
  AVG(transaction_amount) AS avg_transaction
FROM transactions
WHERE transaction_date >= '2024-10-01' 
  AND transaction_date < '2025-01-01'
GROUP BY customer_type;

In Excel, you'd need to filter dates manually, create helper columns, use AVERAGEIF functions, and build a pivot table. In SQL? Three seconds.

Example: High-Value Transactions in December

SELECT 
  transaction_id,
  customer_id,
  transaction_amount,
  transaction_date
FROM transactions
WHERE transaction_amount > 50000
  AND transaction_date >= '2024-12-01'
  AND transaction_date < '2025-01-01'
  AND status = 'completed'
ORDER BY transaction_amount DESC;

Find all completed transactions over $50K in December. Sorted largest to smallest. Takes milliseconds, even on millions of records.

Example: Monthly Revenue by Department

SELECT 
  department,
  DATE_TRUNC('month', sale_date) AS month,
  SUM(revenue) AS total_revenue,
  COUNT(*) AS num_transactions,
  AVG(revenue) AS avg_transaction_size
FROM sales
WHERE sale_date >= '2024-01-01'
GROUP BY department, DATE_TRUNC('month', sale_date)
ORDER BY month, total_revenue DESC;

One query gives you monthly revenue totals, transaction counts, and average deal size by department. This would take 20 minutes in Excel.

Example: Customer Revenue with Account Details

SELECT 
  c.customer_name,
  c.customer_type,
  a.account_number,
  SUM(t.transaction_amount) AS total_spent
FROM customers c
JOIN accounts a ON c.customer_id = a.customer_id
JOIN transactions t ON a.account_id = t.account_id
WHERE t.transaction_date >= '2024-01-01'
GROUP BY c.customer_name, c.customer_type, a.account_number
HAVING SUM(t.transaction_amount) > 100000
ORDER BY total_spent DESC;

Combine customer info, account details, and transaction data across three tables. Show only customers who spent over $100K this year.

Example: Year-over-Year Revenue Comparison

SELECT 
  product_name,
  EXTRACT(YEAR FROM sale_date) AS year,
  SUM(revenue) AS annual_revenue,
  LAG(SUM(revenue)) OVER (
    PARTITION BY product_name 
    ORDER BY EXTRACT(YEAR FROM sale_date)
  ) AS previous_year_revenue,
  ROUND(
    (SUM(revenue) - LAG(SUM(revenue)) OVER (
      PARTITION BY product_name 
      ORDER BY EXTRACT(YEAR FROM sale_date)
    )) / LAG(SUM(revenue)) OVER (
      PARTITION BY product_name 
      ORDER BY EXTRACT(YEAR FROM sale_date)
    ) * 100, 
    2
  ) AS yoy_growth_pct
FROM sales
GROUP BY product_name, EXTRACT(YEAR FROM sale_date)
ORDER BY product_name, year;

Calculate year-over-year growth for each product. LAG() pulls the previous year's revenue for comparison. Try doing that in Excel without helper columns.

Example: Quarterly Revenue (Fiscal Year Starting April)

SELECT 
  CASE 
    WHEN EXTRACT(MONTH FROM sale_date) IN (4,5,6) THEN 'Q1'
    WHEN EXTRACT(MONTH FROM sale_date) IN (7,8,9) THEN 'Q2'
    WHEN EXTRACT(MONTH FROM sale_date) IN (10,11,12) THEN 'Q3'
    ELSE 'Q4'
  END AS fiscal_quarter,
  SUM(revenue) AS quarterly_revenue
FROM sales
WHERE sale_date >= '2024-04-01' 
  AND sale_date < '2025-04-01'
GROUP BY fiscal_quarter
ORDER BY fiscal_quarter;

Custom fiscal quarters with CASE statements. Works for any fiscal year start date.

SELECT 
  DATE_TRUNC('month', sale_date) AS month,
  SUM(revenue) AS current_month_revenue,
  LAG(SUM(revenue)) OVER (ORDER BY DATE_TRUNC('month', sale_date)) AS previous_month_revenue,
  SUM(revenue) - LAG(SUM(revenue)) OVER (ORDER BY DATE_TRUNC('month', sale_date)) AS mom_change,
  ROUND(
    (SUM(revenue) - LAG(SUM(revenue)) OVER (ORDER BY DATE_TRUNC('month', sale_date))) / 
    LAG(SUM(revenue)) OVER (ORDER BY DATE_TRUNC('month', sale_date)) * 100,
    2
  ) AS mom_change_pct
FROM sales
GROUP BY DATE_TRUNC('month', sale_date)
ORDER BY month DESC;

Instant month-over-month comparison with absolute and percentage change. Perfect for monthly board reports.

SELECT 
  transaction_date,
  transaction_amount,
  transaction_type,
  SUM(
    CASE 
      WHEN transaction_type = 'credit' THEN transaction_amount
      ELSE -transaction_amount
    END
  ) OVER (ORDER BY transaction_date, transaction_id) AS running_balance
FROM account_transactions
WHERE account_id = 'ACC-12345'
ORDER BY transaction_date, transaction_id;

Running account balance that updates with every transaction. The SUM() OVER() window function keeps a cumulative total.

SELECT 
  customer_id,
  total_spent,
  CASE 
    WHEN total_spent >= 500000 THEN 'Platinum'
    WHEN total_spent >= 100000 THEN 'Gold'
    WHEN total_spent >= 25000 THEN 'Silver'
    ELSE 'Bronze'
  END AS customer_tier,
  NTILE(10) OVER (ORDER BY total_spent DESC) AS decile
FROM (
  SELECT 
    customer_id,
    SUM(transaction_amount) AS total_spent
  FROM transactions
  WHERE transaction_date >= '2024-01-01'
  GROUP BY customer_id
) customer_totals
ORDER BY total_spent DESC;

Segment customers into tiers based on spending. NTILE(10) also gives you decile rankings. Use this for targeted marketing or account management prioritization.

SELECT 
  region,
  account_name,
  total_revenue,
  revenue_rank
FROM (
  SELECT 
    r.region_name AS region,
    a.account_name,
    SUM(t.transaction_amount) AS total_revenue,
    ROW_NUMBER() OVER (PARTITION BY r.region_name ORDER BY SUM(t.transaction_amount) DESC) AS revenue_rank
  FROM accounts a
  JOIN regions r ON a.region_id = r.region_id
  JOIN transactions t ON a.account_id = t.account_id
  WHERE t.transaction_date >= '2024-01-01'
  GROUP BY r.region_name, a.account_name
) ranked_accounts
WHERE revenue_rank <= 3
ORDER BY region, revenue_rank;

Top 3 revenue-generating accounts per region. ROW_NUMBER() partitioned by region ranks accounts within each region separately.

SELECT 
  d.department_name,
  b.budget_amount,
  COALESCE(a.actual_amount, 0) AS actual_amount,
  b.budget_amount - COALESCE(a.actual_amount, 0) AS variance,
  ROUND(
    (b.budget_amount - COALESCE(a.actual_amount, 0)) / b.budget_amount * 100,
    2
  ) AS variance_pct,
  CASE 
    WHEN COALESCE(a.actual_amount, 0) > b.budget_amount THEN 'Over Budget'
    WHEN COALESCE(a.actual_amount, 0) < b.budget_amount * 0.9 THEN 'Significantly Under'
    ELSE 'On Track'
  END AS status
FROM departments d
JOIN budgets b ON d.department_id = b.department_id
LEFT JOIN (
  SELECT 
    department_id,
    SUM(expense_amount) AS actual_amount
  FROM expenses
  WHERE expense_date >= '2024-01-01' 
    AND expense_date < '2025-01-01'
  GROUP BY department_id
) a ON d.department_id = a.department_id
WHERE b.fiscal_year = 2024
ORDER BY variance DESC;

Complete budget variance report with status flags. Left join ensures departments with no expenses still appear. COALESCE handles nulls gracefully.

SELECT 
  transaction_id,
  customer_id,
  transaction_amount,
  transaction_date
FROM transactions
WHERE transaction_amount > 10000
  AND transaction_date >= '2024-10-01'
  AND transaction_date < '2025-01-01'
ORDER BY transaction_amount DESC;

Tests basic filtering and date range logic. Q4 = October, November, December.

SELECT 
  product_id,
  month,
  monthly_revenue,
  previous_month_revenue,
  ROUND(
    (monthly_revenue - previous_month_revenue) / previous_month_revenue * 100,
    2
  ) AS mom_growth_pct
FROM (
  SELECT 
    product_id,
    DATE_TRUNC('month', sale_date) AS month,
    SUM(revenue) AS monthly_revenue,
    LAG(SUM(revenue)) OVER (
      PARTITION BY product_id 
      ORDER BY DATE_TRUNC('month', sale_date)
    ) AS previous_month_revenue
  FROM sales
  GROUP BY product_id, DATE_TRUNC('month', sale_date)
) monthly_data
WHERE previous_month_revenue IS NOT NULL
ORDER BY product_id, month;

Tests window functions. LAG() partitioned by product ensures you're comparing each product to its own previous month, not mixing products.

SELECT 
  customer_id,
  current_year_spend,
  previous_year_spend,
  ROUND(
    (current_year_spend - previous_year_spend) / previous_year_spend * 100,
    2
  ) AS spend_change_pct
FROM (
  SELECT 
    customer_id,
    SUM(CASE WHEN EXTRACT(YEAR FROM transaction_date) = 2024 THEN transaction_amount ELSE 0 END) AS current_year_spend,
    SUM(CASE WHEN EXTRACT(YEAR FROM transaction_date) = 2023 THEN transaction_amount ELSE 0 END) AS previous_year_spend
  FROM transactions
  WHERE EXTRACT(YEAR FROM transaction_date) IN (2023, 2024)
  GROUP BY customer_id
) yearly_spend
WHERE previous_year_spend > 0
  AND (current_year_spend - previous_year_spend) / previous_year_spend < -0.20
ORDER BY spend_change_pct;

Tests conditional aggregation with CASE statements. Identifies at-risk customers for retention campaigns.

SELECT 
  region,
  account_id,
  total_revenue,
  regional_rank
FROM (
  SELECT 
    a.region,
    a.account_id,
    SUM(t.transaction_amount) AS total_revenue,
    ROW_NUMBER() OVER (PARTITION BY a.region ORDER BY SUM(t.transaction_amount) DESC) AS regional_rank
  FROM accounts a
  JOIN transactions t ON a.account_id = t.account_id
  GROUP BY a.region, a.account_id
) ranked
WHERE regional_rank <= 3
ORDER BY region, regional_rank;

Tests ROW_NUMBER() with PARTITION BY. Common pattern for "top N per category" problems.

SELECT 
  trade_date,
  daily_volume,
  AVG(daily_volume) OVER (
    ORDER BY trade_date
    ROWS BETWEEN 89 PRECEDING AND CURRENT ROW
  ) AS moving_avg_90_day
FROM (
  SELECT 
    trade_date,
    SUM(volume) AS daily_volume
  FROM trades
  GROUP BY trade_date
) daily_totals
ORDER BY trade_date DESC;

Tests window frames. "ROWS BETWEEN 89 PRECEDING AND CURRENT ROW" gives you a 90-day (roughly 3-month) moving average.