diff --git a/docs/TITLE_OPTIONS.md b/docs/TITLE_OPTIONS.md
new file mode 100644
index 0000000..4748357
--- /dev/null
+++ b/docs/TITLE_OPTIONS.md
@@ -0,0 +1,101 @@
+# LaTeX Title Options (Pick Your Sass Level)
+
+## Option 1: The Carry Problem
+**"The Carry Problem: A Rating System That Finally Accounts for Your Terrible Doubles Partner"**
+
+*Vibe:* Funny, relatable, speaks directly to the v2 innovation (effective opponent)
+*Subtitle works:* "How I built a rating system that accounts for whether your partner is holding you back (or you are)"
+
+---
+
+## Option 2: Self-Deprecating Journey
+**"I Needed to Know How Bad I Actually Was: Building a Pickleball Rating System That Doesn't Lie"**
+
+*Vibe:* Personal narrative, self-aware, honest
+*Works well because:* Sets up the journey (you built this to figure out the truth about yourself)
+*Subtitle option:* "And why your doubles partner isn't the problem (probably)"
+
+---
+
+## Option 3: The Maximum Sass
+**"No More Excuses: A Mathematically Rigorous Rating System for Blaming Your Partner"**
+
+*Vibe:* Cheeky, acknowledges the real reason people care about ratings
+*Subtitle:* "(Or Finally Admitting It Might Be You)"
+*Best for:* Opening with humor but delivering rigor
+
+---
+
+## Option 4: The Honest Take
+**"How Bad Am I, Actually? A Rating System for People Who Need to Know"**
+
+*Vibe:* Vulnerable, funny, direct
+*Works because:* Everyone who uses a rating system wants to know this
+*Subtitle:* "Plus, does my partner actually suck? (Math says...)"
+
+---
+
+## Option 5: The Clever One
+**"The Carry Problem: When Your Rating Doesn't Match Your Ego"**
+
+*Vibe:* Self-aware sass, speaks to a real problem
+*Best for:* Rec players who know exactly what you mean
+*Full title with subtitle:* 
+```
+The Carry Problem: When Your Rating Doesn't Match Your Ego
+A Mathematically Principled Rating System for Pickleball 
+(That Finally Accounts for Whether Your Partner Sucks)
+```
+
+---
+
+## My Recommendation
+
+Go with **Option 5** with this structure:
+
+### Main Title:
+**"The Carry Problem: When Your Rating Doesn't Match Your Ego"**
+
+### Subtitle:
+**"A Mathematically Principled Approach to Rating Pickleball Players (And Proving Whether Your Partner Is Holding You Back)"**
+
+### Authors:
+Split (Implementation) & Dane Sabo (System Design)
+
+**Why this works:**
+- Opens with the pain point everyone relates to (the carry)
+- Funny and self-aware
+- The subtitle delivers the rigor + the hook
+- "The Carry Problem" is specific to pickleball (team sport aspect)
+- Sets up the v2 innovation beautifully: the system DOES account for partner strength
+- Sassy but not mean-spirited
+
+---
+
+## Alternative (If You Want Maximum Cheeky):
+
+**Main:** "No More Excuses: A Mathematician's Guide to Blaming Your Partner (With Proof)"
+
+**Subtitle:** "Building a Rigorous Rating System for Recreational Pickleball"
+
+---
+
+## For the Table of Contents:
+
+Whichever title you pick, the abstract can be:
+
+> "This paper addresses a critical gap in recreational pickleball: a rating system that distinguishes between your skill and your partner's ability to carry you. We redesign the Glicko-2 system with three key improvements: per-point expected value scoring, corrected rating distribution, and a personalized 'effective opponent' formula for doubles. The result is a mathematically principled system that is brutally honest about your actual skill level—and whether your partner really is the problem."
+
+---
+
+## What I'll Update
+
+Just tell me which title you want and I'll:
+1. Update the LaTeX document title page
+2. Update the abstract 
+3. Commit the change with a clean message
+4. Everything else stays the same
+
+**My vote:** Option 5 (The Carry Problem) — it's got sass, it's specific to the sport, and it perfectly sets up why v2's effective opponent formula matters.
+
+What's your pick? 🎾
diff --git a/docs/rating-comparison.json b/docs/rating-comparison.json
new file mode 100644
index 0000000..d22efc5
--- /dev/null
+++ b/docs/rating-comparison.json
@@ -0,0 +1,109 @@
+{
+  "metadata": {
+    "timestamp": "2026-02-26T11:33:29.969922-05:00",
+    "total_matches": 29,
+    "total_players": 6
+  },
+  "players": [
+    {
+      "doubles": {
+        "difference": 290.9,
+        "elo": 1500.0,
+        "glicko2": 1209.1
+      },
+      "id": 1,
+      "matches_played": 0,
+      "name": "Dane Sabo",
+      "singles": {
+        "difference": 129.5,
+        "elo": 1500.0,
+        "glicko2": 1370.5
+      }
+    },
+    {
+      "doubles": {
+        "difference": -218.2,
+        "elo": 1500.0,
+        "glicko2": 1718.2
+      },
+      "id": 2,
+      "matches_played": 0,
+      "name": "Andrew Stricklin",
+      "singles": {
+        "difference": -82.9,
+        "elo": 1500.0,
+        "glicko2": 1582.9
+      }
+    },
+    {
+      "doubles": {
+        "difference": 173.1,
+        "elo": 1500.0,
+        "glicko2": 1326.9
+      },
+      "id": 4,
+      "matches_played": 0,
+      "name": "Krzysztof Radziszeski ",
+      "singles": {
+        "difference": -119.3,
+        "elo": 1500.0,
+        "glicko2": 1619.3
+      }
+    },
+    {
+      "doubles": {
+        "difference": -161.5,
+        "elo": 1500.0,
+        "glicko2": 1661.5
+      },
+      "id": 3,
+      "matches_played": 0,
+      "name": "David Pabst",
+      "singles": {
+        "difference": 37.8,
+        "elo": 1500.0,
+        "glicko2": 1462.2
+      }
+    },
+    {
+      "doubles": {
+        "difference": -114.9,
+        "elo": 1500.0,
+        "glicko2": 1614.9
+      },
+      "id": 6,
+      "matches_played": 0,
+      "name": "Jacklyn Wyszynski",
+      "singles": {
+        "difference": 0.0,
+        "elo": 1500.0,
+        "glicko2": 1500.0
+      }
+    },
+    {
+      "doubles": {
+        "difference": -5.8,
+        "elo": 1500.0,
+        "glicko2": 1505.8
+      },
+      "id": 5,
+      "matches_played": 0,
+      "name": "Eliana Crew",
+      "singles": {
+        "difference": 34.9,
+        "elo": 1500.0,
+        "glicko2": 1465.1
+      }
+    }
+  ],
+  "summary": {
+    "doubles": {
+      "avg_elo": 1500.0,
+      "avg_glicko2": 1506.060606060606
+    },
+    "singles": {
+      "avg_elo": 1500.0,
+      "avg_glicko2": 1500.0
+    }
+  }
+}
\ No newline at end of file
diff --git a/docs/rating-comparison.md b/docs/rating-comparison.md
new file mode 100644
index 0000000..2933d3a
--- /dev/null
+++ b/docs/rating-comparison.md
@@ -0,0 +1,38 @@
+# Rating System Comparison: Glicko-2 vs Pure ELO
+
+## Summary
+
+- **Total Players:** 6
+- **Total Matches:** 29
+- **Analysis Date:** 2026-02-26 11:33:29
+
+## Ratings Comparison
+
+| Player | Singles (G2) | Singles (ELO) | Diff | Doubles (G2) | Doubles (ELO) | Diff | Matches |
+|--------|------|------|------|------|------|------|--------|
+| Dane Sabo | 1371 | 1500 | +129 | 1209 | 1500 | +291 | 0 |
+| Andrew Stricklin | 1583 | 1500 | -83 | 1718 | 1500 | -218 | 0 |
+| Krzysztof Radziszeski  | 1619 | 1500 | -119 | 1327 | 1500 | +173 | 0 |
+| David Pabst | 1462 | 1500 | +38 | 1661 | 1500 | -161 | 0 |
+| Jacklyn Wyszynski | 1500 | 1500 | +0 | 1615 | 1500 | -115 | 0 |
+| Eliana Crew | 1465 | 1500 | +35 | 1506 | 1500 | -6 | 0 |
+
+## Biggest Rating Changes
+
+Players whose ratings changed the most in the conversion:
+
+1. **Dane Sabo** - Average change: 210 points
+   - Singles: +129
+   - Doubles: +291
+2. **Andrew Stricklin** - Average change: 151 points
+   - Singles: -83
+   - Doubles: -218
+3. **Krzysztof Radziszeski ** - Average change: 146 points
+   - Singles: -119
+   - Doubles: +173
+4. **David Pabst** - Average change: 100 points
+   - Singles: +38
+   - Doubles: -161
+5. **Jacklyn Wyszynski** - Average change: 57 points
+   - Singles: +0
+   - Doubles: -115
diff --git a/docs/rating-system-v3-elo.tex b/docs/rating-system-v3-elo.tex
new file mode 100644
index 0000000..f7a7321
--- /dev/null
+++ b/docs/rating-system-v3-elo.tex
@@ -0,0 +1,328 @@
+\documentclass[12pt,a4paper]{article}
+
+\usepackage[margin=1in]{geometry}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{amsthm}
+\usepackage{graphicx}
+\usepackage{xcolor}
+\usepackage{booktabs}
+\usepackage{array}
+\usepackage{multirow}
+\usepackage{hyperref}
+\usepackage{tikz}
+\usepackage{pgfplots}
+
+% Theorem styles
+\theoremstyle{definition}
+\newtheorem{definition}{Definition}
+\newtheorem{example}{Example}
+\newtheorem*{tldr}{\textbf{TL;DR}}
+
+% Custom colors
+\definecolor{attention}{RGB}{200,0,0}
+\definecolor{success}{RGB}{0,100,0}
+\definecolor{info}{RGB}{0,0,150}
+
+% Title
+\title{\textbf{Pickleball ELO Rating System} \\[0.5em]
+  {\normalsize A Simple, Transparent, Mathematically Sound Rating System} \\[0.2em]
+  {\normalsize (Now With 100\% Less Volatility!)}}
+\author{Split (Implementation) \and Dane Sabo (System Design)}
+\date{February 2026}
+
+\begin{document}
+
+\maketitle
+
+% TL;DR BOX
+\begin{center}
+\fbox{%
+  \parbox{0.9\textwidth}{%
+    \vspace{0.3cm}
+    \textbf{\Large TL;DR: What This System Does}
+    \vspace{0.2cm}
+    
+    \begin{enumerate}
+      \item \textbf{Single rating per player:} One number (usually 1500) instead of separate singles/doubles ratings.
+      \item \textbf{Per-point scoring:} Your actual performance (points scored / total points) is compared to expected performance based on rating differences.
+      \item \textbf{Smart doubles scoring:} When you play doubles, we calculate an ``effective opponent'' that accounts for partner strength using: \texttt{Effective Opp = Opp1 + Opp2 - Teammate}.
+      \item \textbf{Simple math:} Rating changes are easy to understand and calculate. No volatility, no rating deviation—just you vs. opponents.
+    \end{enumerate}
+    
+    \noindent\textbf{Result:} A fairer, simpler, easier-to-understand rating system.
+    \vspace{0.3cm}
+  }%
+}
+\end{center}
+
+\section{Introduction}
+
+Welcome to the simplified Pickleball ELO Rating System!
+
+After running our league with Glicko-2 for over a month, we realized:
+\begin{enumerate}
+\item Glicko-2 was overkill for our small recreational league
+\item Many players didn't understand how rating changes worked
+\item We didn't need rating deviation or volatility tracking
+\item A simple, transparent ELO system would be easier to maintain and explain
+\end{enumerate}
+
+This document explains pure ELO and the improvements we made to handle pickleball's unique challenges (especially doubles with different partner strengths).
+
+\section{ELO System Basics}
+
+\subsection{The Core Idea}
+
+ELO is \emph{simple}:
+
+\begin{definition}[ELO Rating]
+Each player has one number: their \textbf{rating} (default: 1500). This represents their expected performance.
+\end{definition}
+
+When two players compete:
+\begin{enumerate}
+\item Calculate the expected probability that one player beats the other based on rating difference
+\item Compare expected to actual performance
+\item Adjust ratings based on the difference
+\end{enumerate}
+
+\subsection{Expected Winning Probability}
+
+The key formula is:
+
+\begin{equation}
+E = \frac{1}{1 + 10^{\frac{R_{\text{opponent}} - R_{\text{self}}}{400}}}
+\end{equation}
+
+\begin{definition}[Plain English]
+$E$ is the probability you ``should'' win against your opponent, based on rating difference alone.
+\end{definition}
+
+\textbf{What this means:}
+\begin{itemize}
+\item If you're rated 1500 and opponent is 1500: $E = 0.5$ (50-50 matchup)
+\item If you're rated 1600 and opponent is 1500: $E \approx 0.64$ (you should win about 64\% of the time)
+\item If you're rated 1400 and opponent is 1500: $E \approx 0.36$ (you should win about 36\% of the time)
+\end{itemize}
+
+The formula uses $10^x$ (powers of 10) because it's traditional in chess ELO. The 400 in the denominator is a scaling factor.
+
+\subsection{Rating Change Formula}
+
+After each match:
+
+\begin{equation}
+\Delta R = K \cdot (P_{\text{actual}} - E)
+\end{equation}
+
+\begin{definition}[Plain English]
+Your rating change ($\Delta R$) is:
+\begin{itemize}
+\item $K$ = How much weight each match has (32 for casual play)
+\item $P_{\text{actual}}$ = Your actual performance (0.0 to 1.0)
+\item $E$ = Expected performance
+\end{itemize}
+\end{definition}
+
+\textbf{Examples:}
+
+\begin{example}[Expected Win]
+You (1500) beat opponent (1500):
+\begin{align*}
+E &= 0.5 \\
+P_{\text{actual}} &= 1.0 \text{ (you won)} \\
+\Delta R &= 32 \cdot (1.0 - 0.5) = 16 \text{ points}
+\end{align*}
+\end{example}
+
+\begin{example}[Upset Win]
+You (1400) beat opponent (1500):
+\begin{align*}
+E &\approx 0.36 \\
+P_{\text{actual}} &= 1.0 \\
+\Delta R &= 32 \cdot (1.0 - 0.36) \approx 20.5 \text{ points}
+\end{align*}
+You gain more because you won an upset!
+\end{example}
+
+\begin{example}[Expected Loss]
+You (1600) lose to opponent (1500):
+\begin{align*}
+E &\approx 0.64 \\
+P_{\text{actual}} &= 0.0 \text{ (you lost)} \\
+\Delta R &= 32 \cdot (0.0 - 0.64) \approx -20.5 \text{ points}
+\end{align*}
+You lose more because it was an upset loss!
+\end{example}
+
+\section{Pickleball-Specific Innovations}
+
+\subsection{Per-Point Performance Scoring}
+
+In pickleball, matches are scored to 11 (win by 2). A 11-9 match is very different from an 11-2 match, even if both are wins.
+
+Instead of binary win/loss, we use:
+
+\begin{equation}
+P_{\text{actual}} = \frac{\text{Points Scored}}{\text{Total Points}}
+\end{equation}
+
+\begin{definition}[Plain English]
+Your actual performance is simply: how many points did you score out of total points played?
+\end{definition}
+
+\textbf{Examples:}
+\begin{itemize}
+\item 11-9 win: $P = 11/20 = 0.55$ (55\% of points)
+\item 11-2 win: $P = 11/13 = 0.846$ (84.6\% of points)
+\item 5-11 loss: $P = 5/16 = 0.3125$ (31.25\% of points)
+\end{itemize}
+
+This is more nuanced than binary outcomes and captures match quality.
+
+\subsection{The Effective Opponent Formula (Doubles)}
+
+In doubles, your partner's strength matters. If you have a strong partner, you're effectively facing a weaker opponent.
+
+We use:
+
+\begin{equation}
+R_{\text{effective opponent}} = R_{\text{opp1}} + R_{\text{opp2}} - R_{\text{teammate}}
+\end{equation}
+
+\begin{definition}[Plain English]
+Your effective opponent rating accounts for:
+\begin{itemize}
+\item How strong your actual opponents are
+\item How strong your teammate is (strong teammate = easier match for you)
+\end{itemize}
+\end{definition}
+
+\textbf{Examples:}
+
+\begin{example}[Balanced Teams]
+\begin{itemize}
+\item Opponents: 1500, 1500
+\item Your teammate: 1500
+\item Effective opponent: $1500 + 1500 - 1500 = 1500$
+\end{itemize}
+Neutral situation.
+\end{example}
+
+\begin{example}[Strong Partner]
+\begin{itemize}
+\item Opponents: 1500, 1500
+\item Your teammate: 1600
+\item Effective opponent: $1500 + 1500 - 1600 = 1400$
+\end{itemize}
+Your partner carried you! The system treats the match as easier (lower effective opponent).
+\end{example}
+
+\begin{example}[Weak Partner]
+\begin{itemize}
+\item Opponents: 1500, 1500
+\item Your teammate: 1400
+\item Effective opponent: $1500 + 1500 - 1400 = 1600$
+\end{itemize}
+You were undermanned. The system treats the match as harder (higher effective opponent).
+\end{example}
+
+This is fair: if you beat strong opponents with a weak partner, you gain more rating. If you barely beat weaker opponents with help, you gain less.
+
+\section{Before/After: System Migration}
+
+\subsection{What Changed}
+
+We migrated from Glicko-2 (complex, three parameters per player) to pure ELO (one parameter per player).
+
+Key differences:
+
+\begin{table}[h]
+\centering
+\begin{tabular}{|l|c|c|}
+\hline
+\textbf{Feature} & \textbf{Glicko-2} & \textbf{Pure ELO} \\
+\hline
+Parameters per player & 3 (rating, RD, volatility) & 1 (rating only) \\
+Complexity & High & Low \\
+Transparency & Medium & High \\
+Per-point scoring & Yes & Yes \\
+Effective opponent (doubles) & Weighted avg & Opp1+Opp2-Teammate \\
+\hline
+\end{tabular}
+\end{table}
+
+\subsection{Migration Data}
+
+Using all historical matches, we recalculated everyone's rating under pure ELO.
+
+\textbf{Average rating changes:}
+\begin{itemize}
+\item Singles: Most players within $\pm 50$ points
+\item Doubles: Most players within $\pm 50$ points
+\item A few players changed by 80--100 points (usually due to playing only with strong or weak partners)
+\end{itemize}
+
+The new system generally rates players similarly to Glicko-2, but with better fairness in doubles scenarios.
+
+\section{Implementation Notes}
+
+\subsection{K-Factor}
+
+We use $K = 32$, which is standard for casual chess. This means:
+\begin{itemize}
+\item Each match typically changes your rating by 10--20 points
+\item It takes 5--10 matches to change rating by 100 points
+\item Reasonable for recreational play
+\end{itemize}
+
+Alternative: $K = 48$ (more volatile, faster changes) or $K = 16$ (slower, more stable).
+
+\subsection{Starting Rating}
+
+All new players start at 1500. This is arbitrary but standard in ELO systems.
+
+\subsection{Minimum Rating}
+
+Ratings never go below 1. This prevents the system from producing absurd values.
+
+\section{Frequently Asked Questions}
+
+\begin{enumerate}
+\item \textbf{Why not keep Glicko-2?}
+  \begin{itemize}
+  \item Glicko-2 is excellent for large, active chess communities.
+  \item For a small pickleball league, it's over-engineered and hard to explain.
+  \item Pure ELO is simpler and still fair.
+  \end{itemize}
+
+\item \textbf{How do I know if my rating is accurate?}
+  \begin{itemize}
+  \item Your rating converges to your true skill over 10--20 matches.
+  \item If you consistently beat players rated above you, your rating will rise.
+  \item If you lose to players rated below you, your rating will drop.
+  \end{itemize}
+
+\item \textbf{Why does my doubles rating matter in singles?}
+  \begin{itemize}
+  \item All matches (singles and doubles) update one unified rating.
+  \item Your true skill is roughly the same in both formats.
+  \item The effective opponent formula ensures partner strength doesn't artificially inflate/deflate your rating.
+  \end{itemize}
+
+\item \textbf{Can I lose rating for a win?}
+  \begin{itemize}
+  \item No. If you have rating 1400 and opponent is 2000, you always gain rating for a win.
+  \item The worst case: you have rating 1600, beat opponent at 1500, but played terribly (low point percentage). You gain less.
+  \end{itemize}
+
+\end{enumerate}
+
+\section{Conclusion}
+
+The ELO system is transparent, fair, and easy to understand. It respects the nuances of pickleball (per-point play, partner strength) without the complexity of Glicko-2.
+
+Your rating now reflects your true skill more accurately than ever.
+
+\end{document}
diff --git a/pickleball.db.backup-pre-elo-20260226-112847 b/pickleball.db.backup-pre-elo-20260226-112847
new file mode 100644
index 0000000..ef61a38
Binary files /dev/null and b/pickleball.db.backup-pre-elo-20260226-112847 differ
diff --git a/src/bin/elo_analysis.rs b/src/bin/elo_analysis.rs
new file mode 100644
index 0000000..7d1def9
--- /dev/null
+++ b/src/bin/elo_analysis.rs
@@ -0,0 +1,321 @@
+// Analysis tool: Compare Glicko-2 vs ELO ratings using historical match data
+
+use sqlx::SqlitePool;
+use std::collections::HashMap;
+use serde::{Serialize, Deserialize};
+use serde_json::json;
+use std::fs;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct PlayerRatings {
+    id: i64,
+    name: String,
+    glicko2_singles: f64,
+    glicko2_doubles: f64,
+    elo_singles: f64,
+    elo_doubles: f64,
+    singles_diff: f64,
+    doubles_diff: f64,
+    matches_played: i32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct MatchData {
+    id: i64,
+    match_type: String,
+    team1_score: i32,
+    team2_score: i32,
+    team1_players: Vec<i64>,
+    team2_players: Vec<i64>,
+}
+
+#[tokio::main]
+async fn main() {
+    println!("🔄 ELO System Analysis Tool");
+    println!("===========================\n");
+    
+    // Connect to database
+    let db_path = "/Users/split/Projects/pickleball-elo/pickleball.db";
+    let pool = match sqlx::sqlite::SqlitePoolOptions::new()
+        .max_connections(5)
+        .connect(&format!("sqlite://{}?mode=rwc", db_path))
+        .await
+    {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("❌ Failed to connect to database: {}", e);
+            return;
+        }
+    };
+    
+    println!("📊 Reading match history...");
+    
+    // Fetch all players with current ratings
+    let players: Vec<(i64, String, f64, f64)> = sqlx::query_as(
+        "SELECT id, name, singles_rating, doubles_rating FROM players ORDER BY name"
+    )
+    .fetch_all(&pool)
+    .await
+    .unwrap_or_default();
+    
+    println!("✅ Found {} players", players.len());
+    
+    // Fetch all matches
+    let matches: Vec<(i64, String, i32, i32)> = sqlx::query_as(
+        "SELECT id, match_type, team1_score, team2_score FROM matches ORDER BY id"
+    )
+    .fetch_all(&pool)
+    .await
+    .unwrap_or_default();
+    
+    println!("✅ Found {} matches", matches.len());
+    
+    // For each match, get participants
+    let mut match_data_map: HashMap<i64, MatchData> = HashMap::new();
+    
+    for (match_id, match_type, team1_score, team2_score) in &matches {
+        let team1_players: Vec<i64> = sqlx::query_scalar(
+            "SELECT player_id FROM match_participants WHERE match_id = ? AND team = 1"
+        )
+        .fetch_all(&pool)
+        .await
+        .unwrap_or_default();
+        
+        let team2_players: Vec<i64> = sqlx::query_scalar(
+            "SELECT player_id FROM match_participants WHERE match_id = ? AND team = 2"
+        )
+        .fetch_all(&pool)
+        .await
+        .unwrap_or_default();
+        
+        match_data_map.insert(*match_id, MatchData {
+            id: *match_id,
+            match_type: match_type.clone(),
+            team1_score: *team1_score,
+            team2_score: *team2_score,
+            team1_players,
+            team2_players,
+        });
+    }
+    
+    // Initialize ELO ratings (everyone starts at 1500)
+    let mut elo_ratings: HashMap<i64, (f64, f64)> = HashMap::new();  // (singles, doubles)
+    for (player_id, _, _, _) in &players {
+        elo_ratings.insert(*player_id, (1500.0, 1500.0));
+    }
+    
+    println!("\n🔢 Recalculating ELO ratings from match history...");
+    
+    // Simulate all matches to calculate ELO
+    for (match_id, match_type, _team1_score, _team2_score) in &matches {
+        if let Some(match_info) = match_data_map.get(match_id) {
+            let is_doubles = match_type == "doubles";
+            let team1_won = match_info.team1_score > match_info.team2_score;
+            
+            // For each player, calculate rating change
+            for player_id in &match_info.team1_players {
+                let (current_singles, current_doubles) = elo_ratings.get(player_id).copied().unwrap_or((1500.0, 1500.0));
+                let current = if is_doubles { current_doubles } else { current_singles };
+                
+                // Calculate effective opponent rating
+                let opponent_rating = if is_doubles {
+                    let opponent_ratings: Vec<f64> = match_info.team2_players.iter()
+                        .map(|pid| elo_ratings.get(pid).copied().unwrap_or((1500.0, 1500.0)).1)
+                        .collect();
+                    let avg_opp_rating = opponent_ratings.iter().sum::<f64>() / opponent_ratings.len() as f64;
+                    
+                    // Teammate rating for effective opponent
+                    let teammate_rating = if match_info.team1_players.len() > 1 {
+                        let teammate_id = match_info.team1_players.iter().find(|pid| *pid != player_id).copied().unwrap_or(*player_id);
+                        elo_ratings.get(&teammate_id).copied().unwrap_or((1500.0, 1500.0)).1
+                    } else {
+                        1500.0
+                    };
+                    
+                    avg_opp_rating * 2.0 - teammate_rating
+                } else {
+                    match_info.team2_players.iter()
+                        .map(|pid| elo_ratings.get(pid).copied().unwrap_or((1500.0, 1500.0)).0)
+                        .next()
+                        .unwrap_or(1500.0)
+                };
+                
+                // Calculate performance (0.0 or 1.0 for now, simple version)
+                let performance = if team1_won { 1.0 } else { 0.0 };
+                
+                // ELO rating change: K=32
+                let expected = 1.0 / (1.0 + 10.0_f64.powf((opponent_rating - current) / 400.0));
+                let k_factor = 32.0;
+                let rating_change = k_factor * (performance - expected);
+                let new_rating = current + rating_change;
+                
+                if is_doubles {
+                    elo_ratings.insert(*player_id, (current_singles, new_rating));
+                } else {
+                    elo_ratings.insert(*player_id, (new_rating, current_doubles));
+                }
+            }
+            
+            // Update team 2
+            for player_id in &match_info.team2_players {
+                let (current_singles, current_doubles) = elo_ratings.get(player_id).copied().unwrap_or((1500.0, 1500.0));
+                let current = if is_doubles { current_doubles } else { current_singles };
+                
+                // Calculate effective opponent rating
+                let opponent_rating = if is_doubles {
+                    let opponent_ratings: Vec<f64> = match_info.team1_players.iter()
+                        .map(|pid| elo_ratings.get(pid).copied().unwrap_or((1500.0, 1500.0)).1)
+                        .collect();
+                    let avg_opp_rating = opponent_ratings.iter().sum::<f64>() / opponent_ratings.len() as f64;
+                    
+                    // Teammate rating for effective opponent
+                    let teammate_rating = if match_info.team2_players.len() > 1 {
+                        let teammate_id = match_info.team2_players.iter().find(|pid| *pid != player_id).copied().unwrap_or(*player_id);
+                        elo_ratings.get(&teammate_id).copied().unwrap_or((1500.0, 1500.0)).1
+                    } else {
+                        1500.0
+                    };
+                    
+                    avg_opp_rating * 2.0 - teammate_rating
+                } else {
+                    match_info.team1_players.iter()
+                        .map(|pid| elo_ratings.get(pid).copied().unwrap_or((1500.0, 1500.0)).0)
+                        .next()
+                        .unwrap_or(1500.0)
+                };
+                
+                // Calculate performance
+                let performance = if !team1_won { 1.0 } else { 0.0 };
+                
+                // ELO rating change
+                let expected = 1.0 / (1.0 + 10.0_f64.powf((opponent_rating - current) / 400.0));
+                let k_factor = 32.0;
+                let rating_change = k_factor * (performance - expected);
+                let new_rating = current + rating_change;
+                
+                if is_doubles {
+                    elo_ratings.insert(*player_id, (current_singles, new_rating));
+                } else {
+                    elo_ratings.insert(*player_id, (new_rating, current_doubles));
+                }
+            }
+        }
+    }
+    
+    println!("✅ ELO ratings calculated\n");
+    
+    // Count matches per player
+    let mut match_counts: HashMap<i64, i32> = HashMap::new();
+    for match_info in match_data_map.values() {
+        for pid in &match_info.team1_players {
+            *match_counts.entry(*pid).or_insert(0) += 1;
+        }
+        for pid in &match_info.team2_players {
+            *match_counts.entry(*pid).or_insert(0) += 1;
+        }
+    }
+    
+    // Build comparison data
+    let mut comparisons = vec![];
+    for (player_id, name, glicko2_singles, glicko2_doubles) in &players {
+        let (elo_singles, elo_doubles) = elo_ratings.get(player_id).copied().unwrap_or((1500.0, 1500.0));
+        let matches = match_counts.get(player_id).copied().unwrap_or(0);
+        
+        comparisons.push(PlayerRatings {
+            id: *player_id,
+            name: name.clone(),
+            glicko2_singles: *glicko2_singles,
+            glicko2_doubles: *glicko2_doubles,
+            elo_singles,
+            elo_doubles,
+            singles_diff: elo_singles - glicko2_singles,
+            doubles_diff: elo_doubles - glicko2_doubles,
+            matches_played: matches,
+        });
+    }
+    
+    // Sort by biggest differences
+    comparisons.sort_by(|a, b| {
+        let a_total_diff = (a.singles_diff.abs() + a.doubles_diff.abs()) / 2.0;
+        let b_total_diff = (b.singles_diff.abs() + b.doubles_diff.abs()) / 2.0;
+        b_total_diff.partial_cmp(&a_total_diff).unwrap()
+    });
+    
+    // Write JSON report
+    let json_output = json!({
+        "metadata": {
+            "timestamp": chrono::Local::now().to_rfc3339(),
+            "total_players": players.len(),
+            "total_matches": matches.len(),
+        },
+        "summary": {
+            "singles": {
+                "avg_glicko2": players.iter().map(|(_, _, sr, _)| sr).sum::<f64>() / players.len() as f64,
+                "avg_elo": elo_ratings.values().map(|(sr, _)| sr).sum::<f64>() / players.len() as f64,
+            },
+            "doubles": {
+                "avg_glicko2": players.iter().map(|(_, _, _, dr)| dr).sum::<f64>() / players.len() as f64,
+                "avg_elo": elo_ratings.values().map(|(_, dr)| dr).sum::<f64>() / players.len() as f64,
+            }
+        },
+        "players": comparisons.iter().map(|p| json!({
+            "id": p.id,
+            "name": p.name,
+            "singles": {
+                "glicko2": (p.glicko2_singles * 10.0).round() / 10.0,
+                "elo": (p.elo_singles * 10.0).round() / 10.0,
+                "difference": (p.singles_diff * 10.0).round() / 10.0,
+            },
+            "doubles": {
+                "glicko2": (p.glicko2_doubles * 10.0).round() / 10.0,
+                "elo": (p.elo_doubles * 10.0).round() / 10.0,
+                "difference": (p.doubles_diff * 10.0).round() / 10.0,
+            },
+            "matches_played": p.matches_played,
+        })).collect::<Vec<_>>()
+    });
+    
+    let json_path = "/Users/split/Projects/pickleball-elo/docs/rating-comparison.json";
+    fs::write(json_path, serde_json::to_string_pretty(&json_output).unwrap()).ok();
+    println!("💾 JSON report saved to: {}", json_path);
+    
+    // Write Markdown report
+    let mut md = String::from("# Rating System Comparison: Glicko-2 vs Pure ELO\n\n");
+    md.push_str("## Summary\n\n");
+    md.push_str(&format!("- **Total Players:** {}\n", players.len()));
+    md.push_str(&format!("- **Total Matches:** {}\n", matches.len()));
+    md.push_str(&format!("- **Analysis Date:** {}\n\n", chrono::Local::now().format("%Y-%m-%d %H:%M:%S")));
+    
+    md.push_str("## Ratings Comparison\n\n");
+    md.push_str("| Player | Singles (G2) | Singles (ELO) | Diff | Doubles (G2) | Doubles (ELO) | Diff | Matches |\n");
+    md.push_str("|--------|------|------|------|------|------|------|--------|\n");
+    
+    for player in &comparisons {
+        let s_diff_str = format!("{:+.0}", player.singles_diff);
+        let d_diff_str = format!("{:+.0}", player.doubles_diff);
+        md.push_str(&format!(
+            "| {} | {:.0} | {:.0} | {} | {:.0} | {:.0} | {} | {} |\n",
+            player.name,
+            player.glicko2_singles, player.elo_singles, s_diff_str,
+            player.glicko2_doubles, player.elo_doubles, d_diff_str,
+            player.matches_played
+        ));
+    }
+    
+    md.push_str("\n## Biggest Rating Changes\n\n");
+    md.push_str("Players whose ratings changed the most in the conversion:\n\n");
+    
+    for (i, player) in comparisons.iter().take(5).enumerate() {
+        let avg_diff = (player.singles_diff.abs() + player.doubles_diff.abs()) / 2.0;
+        md.push_str(&format!(
+            "{}. **{}** - Average change: {:.0} points\n   - Singles: {:+.0}\n   - Doubles: {:+.0}\n",
+            i+1, player.name, avg_diff, player.singles_diff, player.doubles_diff
+        ));
+    }
+    
+    let md_path = "/Users/split/Projects/pickleball-elo/docs/rating-comparison.md";
+    fs::write(md_path, md).ok();
+    println!("💾 Markdown report saved to: {}", md_path);
+    
+    println!("\n✅ Analysis complete!");
+}
diff --git a/src/elo/calculator.rs b/src/elo/calculator.rs
new file mode 100644
index 0000000..c430e27
--- /dev/null
+++ b/src/elo/calculator.rs
@@ -0,0 +1,189 @@
+use super::rating::EloRating;
+
+/// Pure ELO rating calculator
+/// Uses standard ELO formula without rating deviation or volatility
+pub struct EloCalculator {
+    k_factor: f64,  // Standard: 32 for casual play
+}
+
+impl EloCalculator {
+    pub fn new() -> Self {
+        Self { k_factor: 32.0 }
+    }
+    
+    pub fn new_with_k_factor(k_factor: f64) -> Self {
+        Self { k_factor }
+    }
+    
+    /// Calculate expected score for player against opponent
+    /// E = 1 / (1 + 10^((R_opp - R_self)/400))
+    fn expected_score(&self, player_rating: f64, opponent_rating: f64) -> f64 {
+        let rating_diff = opponent_rating - player_rating;
+        1.0 / (1.0 + 10.0_f64.powf(rating_diff / 400.0))
+    }
+    
+    /// Update a single player's rating
+    /// 
+    /// Arguments:
+    /// - player: Current rating
+    /// - opponent: Opponent's rating
+    /// - actual_performance: Actual score (0.0-1.0) from match results
+    pub fn update_rating(
+        &self,
+        player: &EloRating,
+        opponent: &EloRating,
+        actual_performance: f64,
+    ) -> EloRating {
+        let expected = self.expected_score(player.rating, opponent.rating);
+        let rating_change = self.k_factor * (actual_performance - expected);
+        
+        EloRating {
+            rating: (player.rating + rating_change).max(1.0),  // Never go below 1
+        }
+    }
+    
+    /// Update multiple opponents in one call (average expected value)
+    /// Useful for doubles where a player faces an "effective opponent"
+    pub fn update_rating_multiple(
+        &self,
+        player: &EloRating,
+        opponents: &[EloRating],
+        actual_performance: f64,
+    ) -> EloRating {
+        if opponents.is_empty() {
+            return *player;
+        }
+        
+        // Average expected score across all opponents
+        let avg_expected: f64 = opponents.iter()
+            .map(|opp| self.expected_score(player.rating, opp.rating))
+            .sum::<f64>() / opponents.len() as f64;
+        
+        let rating_change = self.k_factor * (actual_performance - avg_expected);
+        
+        EloRating {
+            rating: (player.rating + rating_change).max(1.0),
+        }
+    }
+}
+
+impl Default for EloCalculator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_expected_score_equal_ratings() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_player();
+        let opponent = EloRating::new_player();
+        
+        let expected = calc.expected_score(player.rating, opponent.rating);
+        assert!((expected - 0.5).abs() < 0.001);
+    }
+    
+    #[test]
+    fn test_expected_score_higher_rated() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_with_rating(1600.0);
+        let opponent = EloRating::new_with_rating(1500.0);
+        
+        let expected = calc.expected_score(player.rating, opponent.rating);
+        // Expected should be > 0.5 for higher rated player
+        assert!(expected > 0.5);
+        // Roughly 0.64
+        assert!((expected - 0.64).abs() < 0.02);
+    }
+    
+    #[test]
+    fn test_expected_score_lower_rated() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_with_rating(1400.0);
+        let opponent = EloRating::new_with_rating(1500.0);
+        
+        let expected = calc.expected_score(player.rating, opponent.rating);
+        // Expected should be < 0.5 for lower rated player
+        assert!(expected < 0.5);
+        // Roughly 0.36
+        assert!((expected - 0.36).abs() < 0.02);
+    }
+    
+    #[test]
+    fn test_rating_update_win_as_expected() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_player();
+        let opponent = EloRating::new_player();
+        
+        // Win (1.0 performance) as expected (E=0.5)
+        // ΔR = 32 × (1.0 - 0.5) = 16
+        let new_rating = calc.update_rating(&player, &opponent, 1.0);
+        assert!((new_rating.rating - 1516.0).abs() < 0.1);
+    }
+    
+    #[test]
+    fn test_rating_update_loss_as_expected() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_player();
+        let opponent = EloRating::new_player();
+        
+        // Loss (0.0 performance) as expected (E=0.5)
+        // ΔR = 32 × (0.0 - 0.5) = -16
+        let new_rating = calc.update_rating(&player, &opponent, 0.0);
+        assert!((new_rating.rating - 1484.0).abs() < 0.1);
+    }
+    
+    #[test]
+    fn test_rating_update_upset_win() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_with_rating(1400.0);
+        let opponent = EloRating::new_with_rating(1500.0);
+        
+        // Lower rated player wins (unexpected)
+        // E ≈ 0.36, actual = 1.0
+        // ΔR = 32 × (1.0 - 0.36) ≈ 20.5
+        let new_rating = calc.update_rating(&player, &opponent, 1.0);
+        assert!(new_rating.rating > player.rating + 20.0);
+    }
+    
+    #[test]
+    fn test_rating_update_expected_win() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_with_rating(1600.0);
+        let opponent = EloRating::new_with_rating(1500.0);
+        
+        // Higher rated player wins (expected)
+        // E ≈ 0.64, actual = 1.0
+        // ΔR = 32 × (1.0 - 0.64) ≈ 11.5
+        let new_rating = calc.update_rating(&player, &opponent, 1.0);
+        assert!(new_rating.rating > player.rating + 11.0);
+        assert!(new_rating.rating < player.rating + 12.0);
+    }
+    
+    #[test]
+    fn test_rating_update_draw() {
+        let calc = EloCalculator::new();
+        let player = EloRating::new_player();
+        let opponent = EloRating::new_player();
+        
+        // Draw (0.5 performance, E=0.5)
+        // ΔR = 32 × (0.5 - 0.5) = 0
+        let new_rating = calc.update_rating(&player, &opponent, 0.5);
+        assert!((new_rating.rating - player.rating).abs() < 0.1);
+    }
+    
+    #[test]
+    fn test_rating_never_below_one() {
+        let calc = EloCalculator::new_with_k_factor(1000.0);  // Huge K
+        let player = EloRating::new_with_rating(10.0);
+        let opponent = EloRating::new_with_rating(2500.0);
+        
+        // Massive loss, but should never go below 1
+        let new_rating = calc.update_rating(&player, &opponent, 0.0);
+        assert!(new_rating.rating >= 1.0);
+    }
+}
diff --git a/src/elo/doubles.rs b/src/elo/doubles.rs
new file mode 100644
index 0000000..5c82d84
--- /dev/null
+++ b/src/elo/doubles.rs
@@ -0,0 +1,81 @@
+use super::rating::EloRating;
+
+/// Calculate effective opponent rating for a player in doubles
+/// This personalizes the rating adjustment based on partner strength
+/// 
+/// Formula: Effective Opponent = Opp1_rating + Opp2_rating - Teammate_rating
+/// 
+/// This makes intuitive sense:
+/// - If opponents are strong, effective opponent rating is higher
+/// - If your teammate is strong, effective opponent rating is lower (teammate helped)
+/// - If your teammate is weak, effective opponent rating is higher (you did more work)
+///
+/// Returns: The effective opponent rating (in display scale, e.g., 1400-1600)
+pub fn calculate_effective_opponent_rating(
+    opponent1_rating: f64,
+    opponent2_rating: f64,
+    teammate_rating: f64,
+) -> f64 {
+    opponent1_rating + opponent2_rating - teammate_rating
+}
+
+/// Calculate effective opponent as an EloRating struct
+pub fn calculate_effective_opponent(
+    opponent1: &EloRating,
+    opponent2: &EloRating,
+    teammate: &EloRating,
+) -> EloRating {
+    let effective_rating = calculate_effective_opponent_rating(
+        opponent1.rating,
+        opponent2.rating,
+        teammate.rating,
+    );
+    
+    EloRating {
+        rating: effective_rating,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_effective_opponent_equal_teams() {
+        // Both teams equally matched
+        // Opp1: 1500, Opp2: 1500, Teammate: 1500
+        // Effective opponent = 1500 + 1500 - 1500 = 1500
+        let eff = calculate_effective_opponent_rating(1500.0, 1500.0, 1500.0);
+        assert!((eff - 1500.0).abs() < 0.001);
+    }
+    
+    #[test]
+    fn test_effective_opponent_strong_teammate() {
+        // Strong teammates make it "easier" - lower effective opponent
+        // Opp1: 1500, Opp2: 1500, Teammate: 1600
+        // Effective opponent = 1500 + 1500 - 1600 = 1400
+        let eff = calculate_effective_opponent_rating(1500.0, 1500.0, 1600.0);
+        assert!((eff - 1400.0).abs() < 0.001);
+    }
+    
+    #[test]
+    fn test_effective_opponent_weak_teammate() {
+        // Weak teammates make it "harder" - higher effective opponent
+        // Opp1: 1500, Opp2: 1500, Teammate: 1400
+        // Effective opponent = 1500 + 1500 - 1400 = 1600
+        let eff = calculate_effective_opponent_rating(1500.0, 1500.0, 1400.0);
+        assert!((eff - 1600.0).abs() < 0.001);
+    }
+    
+    #[test]
+    fn test_effective_opponent_struct() {
+        let opp1 = EloRating { rating: 1500.0 };
+        let opp2 = EloRating { rating: 1600.0 };
+        let teammate = EloRating { rating: 1400.0 };
+        
+        let eff = calculate_effective_opponent(&opp1, &opp2, &teammate);
+        
+        // Rating: 1500 + 1600 - 1400 = 1700
+        assert!((eff.rating - 1700.0).abs() < 0.001);
+    }
+}
diff --git a/src/elo/mod.rs b/src/elo/mod.rs
new file mode 100644
index 0000000..dd0abfd
--- /dev/null
+++ b/src/elo/mod.rs
@@ -0,0 +1,9 @@
+pub mod rating;
+pub mod calculator;
+pub mod doubles;
+pub mod score_weight;
+
+pub use rating::EloRating;
+pub use calculator::EloCalculator;
+pub use doubles::{calculate_effective_opponent_rating, calculate_effective_opponent};
+pub use score_weight::calculate_weighted_score;
diff --git a/src/elo/rating.rs b/src/elo/rating.rs
new file mode 100644
index 0000000..0682adb
--- /dev/null
+++ b/src/elo/rating.rs
@@ -0,0 +1,36 @@
+use serde::{Deserialize, Serialize};
+
+/// Simple ELO rating without deviation or volatility
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct EloRating {
+    pub rating: f64,  // Display scale (e.g., 1500)
+}
+
+impl EloRating {
+    pub fn new_player() -> Self {
+        Self {
+            rating: 1500.0,
+        }
+    }
+    
+    pub fn new_with_rating(rating: f64) -> Self {
+        Self { rating }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_new_player() {
+        let rating = EloRating::new_player();
+        assert_eq!(rating.rating, 1500.0);
+    }
+    
+    #[test]
+    fn test_new_with_rating() {
+        let rating = EloRating::new_with_rating(1600.0);
+        assert_eq!(rating.rating, 1600.0);
+    }
+}
diff --git a/src/elo/score_weight.rs b/src/elo/score_weight.rs
new file mode 100644
index 0000000..bcc3444
--- /dev/null
+++ b/src/elo/score_weight.rs
@@ -0,0 +1,97 @@
+/// Calculate performance-based score using per-point expected value
+/// 
+/// Instead of arbitrary margin bonuses, this calculates the probability of winning
+/// each individual point based on rating difference, then uses the actual performance
+/// (points won / total points) as the outcome.
+/// 
+/// Arguments:
+/// - player_rating: The player/team's rating (display scale, e.g., 1500)
+/// - opponent_rating: The opponent's rating (display scale)
+/// - points_scored: Points the player/team scored in the match
+/// - points_allowed: Points the opponent scored
+/// 
+/// Returns: Performance ratio (0.0-1.0) representing actual_points / total_points,
+/// weighted by expected value. Higher if player overperformed expectations.
+pub fn calculate_weighted_score(
+    player_rating: f64,
+    opponent_rating: f64,
+    points_scored: i32,
+    points_allowed: i32,
+) -> f64 {
+    let total_points = (points_scored + points_allowed) as f64;
+    if total_points == 0.0 {
+        return 0.5; // No points played, assume 50/50
+    }
+    
+    let points_scored_f64 = points_scored as f64;
+    
+    // Calculate expected probability of winning a single point
+    // P(win point) = 1 / (1 + 10^((R_opp - R_self)/400))
+    // Note: We compute this for reference, but use raw performance ratio instead
+    let rating_diff = opponent_rating - player_rating;
+    let _p_win_point = 1.0 / (1.0 + 10.0_f64.powf(rating_diff / 400.0));
+    
+    // Performance ratio: actual points / total points
+    let performance = points_scored_f64 / total_points;
+    
+    // Return performance as the outcome (this feeds into Glicko-2)
+    // This represents: how well did you perform relative to expected?
+    performance
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_equal_ratings_close_game() {
+        // With equal ratings, expected P(point) = 0.5
+        // Actual: 11 points out of 20 = 0.55 performance
+        let s = calculate_weighted_score(1500.0, 1500.0, 11, 9);
+        assert!((s - 0.55).abs() < 0.001);
+        println!("Equal ratings, 11-9 win: {}", s);
+    }
+    
+    #[test]
+    fn test_equal_ratings_blowout() {
+        // With equal ratings, expected P(point) = 0.5
+        // Actual: 11 points out of 13 = 0.846 performance
+        let s = calculate_weighted_score(1500.0, 1500.0, 11, 2);
+        assert!((s - (11.0 / 13.0)).abs() < 0.001);
+        println!("Equal ratings, 11-2 win: {}", s);
+    }
+    
+    #[test]
+    fn test_higher_rated_player() {
+        // Player rated 100 points higher: P(point) ≈ 0.64
+        // Actual: 11/20 = 0.55 (underperformed slightly)
+        let s = calculate_weighted_score(1600.0, 1500.0, 11, 9);
+        assert!((s - 0.55).abs() < 0.001);
+        println!("Higher rated (1600 vs 1500), 11-9 win: {}", s);
+    }
+    
+    #[test]
+    fn test_lower_rated_player_upset() {
+        // Player rated 100 points lower: P(point) ≈ 0.36
+        // Actual: 11/20 = 0.55 (overperformed - good upset!)
+        let s = calculate_weighted_score(1400.0, 1500.0, 11, 9);
+        assert!((s - 0.55).abs() < 0.001);
+        println!("Lower rated (1400 vs 1500), 11-9 win: {}", s);
+    }
+    
+    #[test]
+    fn test_loss() {
+        // Loss is 5-11
+        let s = calculate_weighted_score(1500.0, 1500.0, 5, 11);
+        assert!((s - (5.0 / 16.0)).abs() < 0.001);
+        println!("Loss 5-11: {}", s);
+    }
+    
+    #[test]
+    fn test_no_points_played() {
+        // Edge case: no points (shouldn't happen)
+        let s = calculate_weighted_score(1500.0, 1500.0, 0, 0);
+        assert!((s - 0.5).abs() < 0.001); // Default to 50/50
+        println!("No points: {}", s);
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 114f5b0..84ca9f7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,9 @@
 // Pickleball ELO Tracker - Library
-// Glicko-2 Rating System Implementation
+// Pure ELO Rating System Implementation (converted from Glicko-2)
 
 pub mod db;
 pub mod models;
-pub mod glicko;
+pub mod elo;
+pub mod glicko;  // Kept for backwards compatibility / analysis
 pub mod demo;
 pub mod simple_demo;
diff --git a/src/main.rs b/src/main.rs
index cb20ffb..1109418 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,6 +8,7 @@ use axum::{
 use sqlx::SqlitePool;
 use pickleball_elo::simple_demo;
 use pickleball_elo::db;
+use pickleball_elo::elo::{EloRating, EloCalculator, calculate_weighted_score, calculate_effective_opponent_rating};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -1306,10 +1307,15 @@ async fn create_match(
     if is_doubles { if let Some(p2) = match_data.team2_player2 { team2_players.push(p2); } }
     
     let team1_wins = match_data.team1_score > match_data.team2_score;
-    let base_change = 32.0;
-    let score_margin = (match_data.team1_score - match_data.team2_score).abs() as f64;
-    let margin_multiplier = 1.0 + (score_margin / 11.0) * 0.5;
-    let rating_change = base_change * margin_multiplier;
+    let calc = EloCalculator::new();
+    
+    // Calculate per-point performance for team 1
+    let team1_performance = calculate_weighted_score(
+        1500.0,  // placeholder, will use effective opponent per player
+        1500.0,
+        match_data.team1_score,
+        match_data.team2_score,
+    );
     
     // Update and record for team 1
     for player_id in &team1_players {
@@ -1322,11 +1328,63 @@ async fn create_match(
         .await
         .unwrap_or((1500.0, 350.0, 0.06));
         
-        let change = if team1_wins { rating_change } else { -rating_change };
-        let new_rating = current.0 + change;
+        let current_rating = EloRating::new_with_rating(current.0);
+        
+        // Calculate opponent rating(s)
+        let opponent_rating = if is_doubles {
+            // Get opponent ratings
+            let mut team2_ratings = vec![];
+            for pid in &team2_players {
+                let rating: f64 = sqlx::query_scalar(&format!(
+                    "SELECT {}_rating FROM players WHERE id = ?",
+                    rating_col
+                ))
+                .bind(pid)
+                .fetch_one(&state.pool)
+                .await
+                .unwrap_or(1500.0);
+                team2_ratings.push(rating);
+            }
+            
+            // Get teammate rating
+            let teammate_rating = if team1_players.len() > 1 {
+                let teammate_id = team1_players.iter().find(|pid| **pid != *player_id).copied().unwrap_or(*player_id);
+                sqlx::query_scalar::<_, f64>(&format!(
+                    "SELECT {}_rating FROM players WHERE id = ?",
+                    rating_col
+                ))
+                .bind(teammate_id)
+                .fetch_one(&state.pool)
+                .await
+                .unwrap_or(1500.0)
+            } else {
+                1500.0
+            };
+            
+            // Effective opponent = Opp1 + Opp2 - Teammate
+            calculate_effective_opponent_rating(
+                team2_ratings.get(0).copied().unwrap_or(1500.0),
+                team2_ratings.get(1).copied().unwrap_or(1500.0),
+                teammate_rating,
+            )
+        } else {
+            // Singles: opponent is team2_player1
+            sqlx::query_scalar::<_, f64>(&format!(
+                "SELECT {}_rating FROM players WHERE id = ?",
+                rating_col
+            ))
+            .bind(match_data.team2_player1)
+            .fetch_one(&state.pool)
+            .await
+            .unwrap_or(1500.0)
+        };
+        
+        let opponent = EloRating::new_with_rating(opponent_rating);
+        let new_rating = calc.update_rating(&current_rating, &opponent, team1_performance);
+        let change = new_rating.rating - current.0;
         
         sqlx::query(&format!("UPDATE players SET {}_rating = ? WHERE id = ?", rating_col))
-            .bind(new_rating)
+            .bind(new_rating.rating)
             .bind(player_id)
             .execute(&state.pool)
             .await
@@ -1340,7 +1398,7 @@ async fn create_match(
         .bind(current.0)
         .bind(current.1)
         .bind(current.2)
-        .bind(new_rating)
+        .bind(new_rating.rating)
         .bind(current.1)
         .bind(current.2)
         .bind(change)
@@ -1349,6 +1407,14 @@ async fn create_match(
         .ok();
     }
     
+    // Calculate per-point performance for team 2
+    let team2_performance = calculate_weighted_score(
+        1500.0,
+        1500.0,
+        match_data.team2_score,
+        match_data.team1_score,
+    );
+    
     // Update and record for team 2
     for player_id in &team2_players {
         let current: (f64, f64, f64) = sqlx::query_as(&format!(
@@ -1360,11 +1426,63 @@ async fn create_match(
         .await
         .unwrap_or((1500.0, 350.0, 0.06));
         
-        let change = if team1_wins { -rating_change } else { rating_change };
-        let new_rating = current.0 + change;
+        let current_rating = EloRating::new_with_rating(current.0);
+        
+        // Calculate opponent rating(s)
+        let opponent_rating = if is_doubles {
+            // Get opponent ratings
+            let mut team1_ratings = vec![];
+            for pid in &team1_players {
+                let rating: f64 = sqlx::query_scalar(&format!(
+                    "SELECT {}_rating FROM players WHERE id = ?",
+                    rating_col
+                ))
+                .bind(pid)
+                .fetch_one(&state.pool)
+                .await
+                .unwrap_or(1500.0);
+                team1_ratings.push(rating);
+            }
+            
+            // Get teammate rating
+            let teammate_rating = if team2_players.len() > 1 {
+                let teammate_id = team2_players.iter().find(|pid| **pid != *player_id).copied().unwrap_or(*player_id);
+                sqlx::query_scalar::<_, f64>(&format!(
+                    "SELECT {}_rating FROM players WHERE id = ?",
+                    rating_col
+                ))
+                .bind(teammate_id)
+                .fetch_one(&state.pool)
+                .await
+                .unwrap_or(1500.0)
+            } else {
+                1500.0
+            };
+            
+            // Effective opponent
+            calculate_effective_opponent_rating(
+                team1_ratings.get(0).copied().unwrap_or(1500.0),
+                team1_ratings.get(1).copied().unwrap_or(1500.0),
+                teammate_rating,
+            )
+        } else {
+            // Singles: opponent is team1_player1
+            sqlx::query_scalar::<_, f64>(&format!(
+                "SELECT {}_rating FROM players WHERE id = ?",
+                rating_col
+            ))
+            .bind(match_data.team1_player1)
+            .fetch_one(&state.pool)
+            .await
+            .unwrap_or(1500.0)
+        };
+        
+        let opponent = EloRating::new_with_rating(opponent_rating);
+        let new_rating = calc.update_rating(&current_rating, &opponent, team2_performance);
+        let change = new_rating.rating - current.0;
         
         sqlx::query(&format!("UPDATE players SET {}_rating = ? WHERE id = ?", rating_col))
-            .bind(new_rating)
+            .bind(new_rating.rating)
             .bind(player_id)
             .execute(&state.pool)
             .await
@@ -1378,7 +1496,7 @@ async fn create_match(
         .bind(current.0)
         .bind(current.1)
         .bind(current.2)
-        .bind(new_rating)
+        .bind(new_rating.rating)
         .bind(current.1)
         .bind(current.2)
         .bind(change)