Back home
RIDGELINE SKI RECOMMENDER / CASE STUDY
Building a Ski Run Recommendations App with Replit
Building a Ski Run Recommendations App with Replit


01 / Overview
Exit Rules addressed a core platform gap for logic configuration in automated subscriber journeys.
MY ROLE
Led full 0->1 development of Ridgeline, spanning product strategy, design, and prompting.
COLLABORATORS
My fellow ski bums in the shop!
02 / The challenge
I was working weekends at a ski rental shop in Big Sky, MT, and customers would often ask for run recommendations. Big Sky is huge, and the right run depends on many factors: a skier’s ability, current snow conditions, and preferences for terrain.
Having spent the past few years designing ML-powered products at Attentive, I wondered if a ski recommendation app existed. While there are plenty of trail maps and guides, I couldn’t find a tool that generated run recommendations based on a skier’s inputs.
Replit was the perfect AI tool to bring this idea to life. It allowed me to quickly prototype the concept and build a simple system that could translate skier preferences into personalized run recommendations. As a product designer (and skier), I got to work.
03 / Research & key decisions
I started with competitive research to understand the current landscape. Most existing apps (Slopes, AllTrails, Ski Tracks) focus on maps, conditions, or performance tracking, rather than recommending runs based on skier preferences.
Next, I identified where the product gaps were, and what users still needed to choose the right run.
Product gaps
1. No personalized run recommendations
Most ski apps provide maps or performance tracking, but none recommend specific runs based on a skier’s ability level, preferences, or goals.
2. Static trail maps are hard to interpret
Ski maps are often difficult to interpret, especially for beginners or skiers unfamiliar with a resort.
3. Run choice depends on conditions and local knowledge
Snow conditions, grooming, crowds, and time of day all affect which runs are best, so skiers often rely on instructors or friends for recommendations.
4. Resorts are too large to navigate easily
At large resorts with hundreds of runs, skiers often repeat the same terrain, miss out on runs that would be great for their level, or accidentally end up on terrain beyond their ability.
04 / Product execution
I built an MVP (minimum viable product) to test if skier preferences could translate into useful run recommendations. The goal was to quickly validate the core idea, gather feedback, and lay the groundwork for future development.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
Designing the app
I created wireframes and defined colors and UI patterns, which helped when prompting Replit to implement the visual experience.
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Early wireframe of Ridgeline app, featuring resort finder and user ski details


Early wireframe of Ridgeline app, featuring resort finder and user ski details
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
By default, Ridegeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Prompting Ridgeline UI build with Replit
By default, Ridgeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.



Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
We're live!
While I’m currently working to load in more resort data, engage with the app below with recs for Big Sky, MT and Bridger Bowl, MT. You can check it out live at ridgeline-ski.com.
Ridgeline Ski Recommender live app
Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
The trade-offs behind the design
Every project has scope changes and technical hurdles, but I believe navigating these is where a product designer shines. These are the moments we advocate for the user, while helping our product partners arrive at a solution.
01 / Data sourcing
Challenge: Most ski runs were stored on maps, which Codex struggled to read and store. With limited time, I had to find other sources or upload screenshots, limiting recommendations to two resorts.
How I approached it: I prioritized working, quality recommendations over quantity, vetting the data to ensure the recs worked as they should.
02 / Getting user feedback
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.As the lead for UX, I pushed for trust building first — this meant incremental releases that proved the feature's value, giving us time to develop quality over quantity.
How I approached it: I’m excited to continue iterating and launch with users during the upcoming ski season. ⛷️
05 / Outcomes & reflection
This results section is a little different – I would love to hear any feedback you have after checking out Ridgeline. That can be bugs you caught, gaps, or ideas that would make this product more useful. As I always say in design crit, rip it to shreds!
Next project
Back home
RIDGELINE SKI RECOMMENDER / CASE STUDY
Building a Ski Run Recommendations App with Replit
Building a Ski Run Recommendations App with Replit


01 / Overview
Exit Rules addressed a core platform gap for logic configuration in automated subscriber journeys.
MY ROLE
Led full 0->1 development of Ridgeline, spanning product strategy, design, and prompting.
COLLABORATORS
My fellow ski bums in the shop!
02 / The challenge
I was working weekends at a ski rental shop in Big Sky, MT, and customers would often ask for run recommendations. Big Sky is huge, and the right run depends on many factors: a skier’s ability, current snow conditions, and preferences for terrain.
Having spent the past few years designing ML-powered products at Attentive, I wondered if a ski recommendation app existed. While there are plenty of trail maps and guides, I couldn’t find a tool that generated run recommendations based on a skier’s inputs.
Replit was the perfect AI tool to bring this idea to life. It allowed me to quickly prototype the concept and build a simple system that could translate skier preferences into personalized run recommendations. As a product designer (and skier), I got to work.
03 / Research & key decisions
I started with competitive research to understand the current landscape. Most existing apps (Slopes, AllTrails, Ski Tracks) focus on maps, conditions, or performance tracking, rather than recommending runs based on skier preferences.
Next, I identified where the product gaps were, and what users still needed to choose the right run.
Product gaps
1. No personalized run recommendations
Most ski apps provide maps or performance tracking, but none recommend specific runs based on a skier’s ability level, preferences, or goals.
2. Static trail maps are hard to interpret
Ski maps are often difficult to interpret, especially for beginners or skiers unfamiliar with a resort.
3. Run choice depends on conditions and local knowledge
Snow conditions, grooming, crowds, and time of day all affect which runs are best, so skiers often rely on instructors or friends for recommendations.
4. Resorts are too large to navigate easily
At large resorts with hundreds of runs, skiers often repeat the same terrain, miss out on runs that would be great for their level, or accidentally end up on terrain beyond their ability.
04 / Product execution
I built an MVP (minimum viable product) to test if skier preferences could translate into useful run recommendations. The goal was to quickly validate the core idea, gather feedback, and lay the groundwork for future development.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
Designing the app
I created wireframes and defined colors and UI patterns, which helped when prompting Replit to implement the visual experience.
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Early wireframe of Ridgeline app, featuring resort finder and user ski details


Early wireframe of Ridgeline app, featuring resort finder and user ski details
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
By default, Ridegeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Prompting Ridgeline UI build with Replit
By default, Ridgeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.



Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
We're live!
While I’m currently working to load in more resort data, engage with the app below with recs for Big Sky, MT and Bridger Bowl, MT. You can check it out live at ridgeline-ski.com.
Ridgeline Ski Recommender live app
Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
The trade-offs behind the design
Every project has scope changes and technical hurdles, but I believe navigating these is where a product designer shines. These are the moments we advocate for the user, while helping our product partners arrive at a solution.
01 / Data sourcing
Challenge: Most ski runs were stored on maps, which Codex struggled to read and store. With limited time, I had to find other sources or upload screenshots, limiting recommendations to two resorts.
How I approached it: I prioritized working, quality recommendations over quantity, vetting the data to ensure the recs worked as they should.
02 / Getting user feedback
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.As the lead for UX, I pushed for trust building first — this meant incremental releases that proved the feature's value, giving us time to develop quality over quantity.
How I approached it: I’m excited to continue iterating and launch with users during the upcoming ski season. ⛷️
05 / Outcomes & reflection
This results section is a little different – I would love to hear any feedback you have after checking out Ridgeline. That can be bugs you caught, gaps, or ideas that would make this product more useful. As I always say in design crit, rip it to shreds!
Next project
Back home
RIDGELINE SKI RECOMMENDER / CASE STUDY
Building a Ski Run Recommendations App with Replit
Building a Ski Run Recommendations App with Replit


01 / Overview
Exit Rules addressed a core platform gap for logic configuration in automated subscriber journeys.
MY ROLE
Led full 0->1 development of Ridgeline, spanning product strategy, design, and prompting.
COLLABORATORS
My fellow ski bums in the shop!
02 / The challenge
I was working weekends at a ski rental shop in Big Sky, MT, and customers would often ask for run recommendations. Big Sky is huge, and the right run depends on many factors: a skier’s ability, current snow conditions, and preferences for terrain.
Having spent the past few years designing ML-powered products at Attentive, I wondered if a ski recommendation app existed. While there are plenty of trail maps and guides, I couldn’t find a tool that generated run recommendations based on a skier’s inputs.
Replit was the perfect AI tool to bring this idea to life. It allowed me to quickly prototype the concept and build a simple system that could translate skier preferences into personalized run recommendations. As a product designer (and skier), I got to work.
03 / Research & key decisions
I started with competitive research to understand the current landscape. Most existing apps (Slopes, AllTrails, Ski Tracks) focus on maps, conditions, or performance tracking, rather than recommending runs based on skier preferences.
Next, I identified where the product gaps were, and what users still needed to choose the right run.
Product gaps
1. No personalized run recommendations
Most ski apps provide maps or performance tracking, but none recommend specific runs based on a skier’s ability level, preferences, or goals.
2. Static trail maps are hard to interpret
Ski maps are often difficult to interpret, especially for beginners or skiers unfamiliar with a resort.
3. Run choice depends on conditions and local knowledge
Snow conditions, grooming, crowds, and time of day all affect which runs are best, so skiers often rely on instructors or friends for recommendations.
4. Resorts are too large to navigate easily
At large resorts with hundreds of runs, skiers often repeat the same terrain, miss out on runs that would be great for their level, or accidentally end up on terrain beyond their ability.
04 / Product execution
I built an MVP (minimum viable product) to test if skier preferences could translate into useful run recommendations. The goal was to quickly validate the core idea, gather feedback, and lay the groundwork for future development.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
# Product Requirements Document (PRD) ## Product Name (Working) Ridgeline ## Overview Ridgeline is a SaaS application that provides personalized ski run recommendations based on a skier’s skill level, preferences, location, and trip plans. Unlike traditional green/blue/black classifications, Ridgeline evaluates runs using richer, more nuanced data (terrain, pitch, grooming, exposure, crowding, conditions) to help beginners, intermediate, and advanced skiers choose runs they can confidently prepare for and enjoy. The app supports both real-time discovery at a resort (via location sharing) and global search for trip planning. ## Problem Statement Skiers often struggle to pick runs that match their true ability: - Trail color alone is too coarse and inconsistent across resorts - Beginners accidentally end up on intimidating terrain - Intermediate skiers plateau because they don’t know which runs push them safely - Advanced skiers want specifics (steepness, exposure, moguls, trees, groomed vs ungroomed) Existing ski apps focus on maps or tracking, not intelligent, skill-aware recommendations. ## Goals & Success Metrics ### Goals - Help skiers choose runs they can ski safely and confidently - Enable skill progression through informed recommendations - Make trip planning easier and more personalized ### Success Metrics - % of users who follow recommended runs - User-reported satisfaction with recommendations - Retention across multiple ski days or trips - Reduction in “wrong run” feedback (too hard / too easy) ## Target Users ### Primary Personas 1. Beginner Skier - New to skiing or early-stage - Wants confidence and safety - Needs reassurance beyond trail color 2. Intermediate Skier - Comfortable on blues, some blacks - Wants to progress without fear - Needs help understanding what makes a run harder 3. Advanced Skier - Seeks specific terrain types - Cares about pitch, exposure, moguls, trees, grooming - Wants efficient discovery at new resorts ## Key Use Cases 1. **On-Mountain Discovery** - User allows location access - App detects current resort - Shows nearby recommended runs ranked by fit 2. **Trip Planning** - User searches a resort anywhere in the world - Filters runs by skill level, terrain preferences, conditions - Saves runs to a trip plan 3. **Skill Progression** - User indicates goals (e.g. “get comfortable with steeper blues”) - App recommends stepping-stone runs ## Core Features ### 1. User Profile & Skill Modeling - Self-assessed skill level (Beginner / Intermediate / Advanced) - Optional onboarding quiz: - Comfort with steepness - Experience with moguls, trees, ice, powder - Speed preference - Skill model updates over time (optional future enhancement) ### 2. Location & Search - Location-based resort detection (opt-in) - Global resort and run search - Map and list views ### 3. Run Recommendation Engine Runs are evaluated beyond color using multiple attributes: - **Average & max pitch (steepness)** - **Run length** - **Width** - **Grooming frequency** - **Terrain type** (groomed, moguls, trees, bowls) - **Exposure** (cliffs, narrow sections) - **Typical crowd level** - **Icy / variable condition likelihood** Each run receives a **Difficulty Profile** and a **Skill Fit Score** per user. In addition, the engine supports **dynamic and history-based recommendations**: - Users can mark runs as completed - The system learns which difficulty attributes the user succeeds on and enjoys - Completed runs are clustered by terrain profile - The app recommends **similar runs**: - At the same resort (next-step progression) - At different resorts (trip planning) Example: “You handled long, moderately steep groomed blues well → try these runs with similar pitch but more variable snow.” ### 4. Run Detail Pages Each run includes: - Trail map highlight - Difficulty breakdown (why it’s challenging) - “Why this run is / isn’t right for you” - Prep tips (e.g. technique, mindset, conditions to avoid) ### 5. Filters & Preferences - Terrain preferences - Avoidances (e.g. moguls, narrow runs) - Desired challenge level (comfort vs stretch) ### 6. Dynamic Learning & Personalization - Run history stored per user - Explicit feedback options (Loved it / Too hard / Too easy) - Progressive adjustment of Skill Fit Scores - Cross-resort similarity matching based on terrain profiles - Ability to reset or lock skill level manually ### 7. Safety & Transparency - Clear disclaimers - Highlight conditions where a run becomes harder - Confidence indicators instead of guarantees ## Non-Goals (V1) - Real-time snow condition prediction - Live crowd tracking - Ski tracking or performance analytics - Social features ## Technical Considerations (Replit-Friendly) ### Architecture - Frontend: React or Next.js - Backend: Node.js / Python API - Database: Postgres or Supabase - Third-party data: - Resort & run data providers - Elevation and terrain APIs ### Recommendation Logic (V1) - Rule-based scoring system - Weighted attributes per skill level - Configurable via admin dashboard ### Future Enhancements - Machine learning personalization - Integration with weather and snow reports - User feedback loop (“too hard / too easy”) ## Risks & Mitigations - **Inconsistent trail ratings across resorts** → Normalize using objective metrics - **Liability concerns** → Clear disclaimers and conservative recommendations - **Data gaps** → Start with major resorts, expand gradually ## Open Questions - Which resort data provider to use? - How much personalization in onboarding vs friction? - Monetization model (subscription, trip packs, B2B partnerships?) --- This PRD defines the foundation for building Ridgeline as a smart, confidence-first ski run recommendation platform. ```
Designing the app
I created wireframes and defined colors and UI patterns, which helped when prompting Replit to implement the visual experience.
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Early wireframe of Ridgeline app, featuring resort finder and user ski details


Early wireframe of Ridgeline app, featuring resort finder and user ski details
When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
By default, Ridegeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.

When iterating, I would address one functionality at a time. I would give Replit expectations for the output, and how the sections should appear aesthetically.
Prompting Ridgeline UI build with Replit
By default, Ridgeline strategically uses a dark mode UI so that the app is readable during "bluebird" ski days that are bright and sunny. Users can switch to light mode if that's more readable for them.
Building the framework
I prompted ChatGPT to generate a PRD (product requirements document) outlining the app’s goals, features, and design requirements. I then uploaded this document into Replit to guide the development process.



Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
We're live!
While I’m currently working to load in more resort data, engage with the app below with recs for Big Sky, MT and Bridger Bowl, MT. You can check it out live at ridgeline-ski.com.
Ridgeline Ski Recommender live app
Loading in data
I downloaded and converted lists of ski runs for Big Sky and Bridger Bowl, since I could validate the data quality based on my own experience.
ChatGPT helped me match runs to the correct ski lift, and then score the runs based on difficulty. This score combined the official trail map rating with terrain characteristics such as steepness or terrain type. The runs were then stored in a structured JSON format so they could be filtered and recommended programmatically based on a skier’s skill level.
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
{ "name": "Liberty Bowl", "difficulty": "advanced", "lift": "Powder Seeker", "terrain": ["bowl"], "exposure": "high" }
An inference script was then written to recommend runs based on the skier’s ability level by filtering the dataset for runs at or below the user’s skill level.
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
function recommendRuns(userLevel) { return runs.filter(run => { if (userLevel === "expert") return true if (userLevel === "advanced") return run.difficulty !== "expert" if (userLevel === "intermediate") return run.difficulty === "intermediate" return run.difficulty === "beginner" }) }
This allowed the model to dynamically recommend appropriate ski runs while filtering out terrain that would be unsafe or too difficult for the user.
The trade-offs behind the design
Every project has scope changes and technical hurdles, but I believe navigating these is where a product designer shines. These are the moments we advocate for the user, while helping our product partners arrive at a solution.
01 / Data sourcing
Challenge: Most ski runs were stored on maps, which Codex struggled to read and store. With limited time, I had to find other sources or upload screenshots, limiting recommendations to two resorts.
How I approached it: I prioritized working, quality recommendations over quantity, vetting the data to ensure the recs worked as they should.
02 / Getting user feedback
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.
Challenge: Main development took place in April 2026, when ski season was coming to a close, making it difficult to develop a user base.As the lead for UX, I pushed for trust building first — this meant incremental releases that proved the feature's value, giving us time to develop quality over quantity.
How I approached it: I’m excited to continue iterating and launch with users during the upcoming ski season. ⛷️
05 / Outcomes & reflection
This results section is a little different – I would love to hear any feedback you have after checking out Ridgeline. That can be bugs you caught, gaps, or ideas that would make this product more useful. As I always say in design crit, rip it to shreds!
Next project