Nashlytics

Your League year, wrapped by AI. Relive your highlights, patterns, and playstyle.

Comment

Inspiration

I've always loved year-end "Wrapped" experiences. There's something special about looking back at your journey and having it feel meaningful. League had something similar years ago, and sharing it with friends was genuinely fun.

But those recaps were just stats—no personality, no story. With AI now being accessible, I wanted to bring that magic back in a way that actually feels personal.

That's why I built Nashlytics—to turn your entire 2025 League season into an AI-powered recap that's nostalgic, fun, and insightful.

What it does

Nashlytics turns your League season into an AI-powered story.

Enter your Riot ID and region, then pick your game mode (Ranked, Normal, or ARAM). Each mode gets analyzed separately since mixing them would mess up the insights.

After pulling all your matches from the year, you get:

  • Games played, win rate, champion pool
  • Main role and longest streaks
  • Best and worst performances
  • AI-generated playstyle analysis
  • Hidden patterns in how you actually play
  • Real strengths and specific ways to improve
  • Champion recommendations based on your style

The AI doesn't just say "improve your vision." It tells you "Your 1.2 vision score is below Gold average. Try warding at 3:00 and 8:00 for dragon fights."

Every recap gets a shareable link at nashlytics.burakarslan.tech

How I built it

Backend (Python + AWS Lambda + API Gateway)

  • Flask API running on Lambda, deployed with AWS SAM
  • Async processing: frontend gets immediate response, Lambda works in background, frontend polls for updates
  • Two-week chunking to fetch match history (Riot API caps at 100 matches per call)
  • 1-1.5s delays between requests to stay under rate limits
  • DynamoDB caching for everything: player profiles, matches, AI insights, league averages
  • Smart TTLs make repeat recaps instant

AI

  • Amazon Bedrock with Claude 3.5 Haiku (cost-effective)
  • Started with OpenSearch Serverless for RAG, but match data alone was enough
  • Switched to pure inference with a heavily engineered prompt
  • Cut costs 70% and improved accuracy

Frontend

  • Next.js 14 + TypeScript
  • Framer Motion for 13 animated sections
  • Real-time progress updates
  • Hosted on AWS Amplify

Challenges I ran into

Rate limits – Development API keys are strict. Even with 1-1.5s delays between requests, fetching 300+ games takes time. I chunked requests into two-week periods and added retry logic for 429 responses. Still waiting on production key approval for higher limits.

Scale – Some players have 400+ games in a single mode. Early versions tried to process everything synchronously and hit Lambda's timeout. Had to architect the entire flow around chunking and progress tracking.

API Gateway timeout – Gateway kills requests after 29 seconds. My initial synchronous approach always failed for anyone with more than ~50 games. Switched to async processing where the frontend gets an immediate 202 response and polls for updates while Lambda works in the background.

Lambda cold starts – In-memory caching seemed smart at first but kept failing. Every cold start lost the cache, and with Lambda's stateless nature, data disappeared constantly. Moving to DynamoDB not only fixed it but made cached data available across all invocations.

Special characters – Champions like Kha'Zix, Kai'Sa, and Cho'Gath have apostrophes that break Data Dragon image URLs. Built a sanitization layer to handle these edge cases.

Generic AI – Early prompts were too open-ended. Everyone got labeled "Tactical Genius" or "Aggressive Carry" regardless of actual playstyle. Added 500+ lines of constraints: explicit anti-patterns, role-specific benchmarks, mode context, and strict JSON schemas. This made insights actually feel personal.

Accomplishments that I'm proud of

  • Turned match data into something that feels like Spotify Wrapped for League
  • Found that ?-ping usage predicts tilt—high ?-ping players show measurable performance drops afterward. I use this to adjust coaching tone.
  • Built a duo synergy algorithm that finds your real partner (not just who you played with most)
  • Caching strategy cuts AWS costs 90% and makes repeat recaps instant
  • Two-week chunking handles 300+ games without breaking
  • 500+ line system prompt that avoids generic AI responses
  • Built everything solo during the hackathon

What I learned

Building this forced me to really understand both AWS and the Riot API. Rate limiting, batching, working within quotas—all the stuff that separates "works on my machine" from "works at scale."

Lambda, DynamoDB, Bedrock, API Gateway, Amplify—I'd used these before, but never all together in one system. Dealing with timeouts, cold starts, async processing, and caching taught me how serverless actually works in practice.

Lambda being stateless changed how I think about data. Nothing sticks around, so I had to architect proper caching and state management.

For AI, I learned prompts need constraints more than creativity. Early versions were too open and gave generic outputs. Treating the prompt like a spec—with anti-patterns, benchmarks, and strict formats—made the difference.

The hardest part wasn't the AI or the frontend. It was building a reliable data pipeline that handles API limits, missing data, and Lambda timeouts while keeping the user experience smooth.

What's next for Nashlytics

Soon:

  • Shareable images/videos for social media
  • Season comparisons (2024 vs 2025)
  • Region leaderboards

Later:

  • Team recaps for friend groups
  • Playstyle leaderboards
  • Weekly micro-recaps
  • Champion deep dives

Eventually:

  • Stream overlays
  • ML rank predictions
  • Full coaching plans

Goal: Make this every League player's end-of-season tradition.

Built With

Share this project:

Updates