Designed, Developed, and Deployed a Full-stack Web Application for Junior Golfers

Summary

This project transformed a complex golf performance-tracking spreadsheet into a powerful, user-friendly web application for junior golfers and their families. Collaborating closely with the client, I led the project from initial discussions to a successful launch, managing a technical team and coordinating across development, testing, and documentation phases. By identifying the client’s needs, we crafted a secure, fast, and scalable solution that included features like user authentication, payment processing, advanced performance tracking, and an intuitive admin panel. The result was a professional-grade application that received exceptional feedback for its efficiency, reliability, and ease of use, showcasing my commitment to technical excellence, team coordination, and problem-solving from concept to delivery.

Project Overview

The Client

James Eickhoff, a dedicated parent of an elite junior golfer, found himself navigating the competitive landscape of junior golf rankings, where national standings are critical for tournament entry and college recruitment. While helping his son optimize performance, James reverse-engineered the differential formula—a crucial metric in junior golf rankings—and developed a feature-rich spreadsheet for performance tracking and statistical insights. Recognizing the potential value for other parents, he aimed to transform his spreadsheet into a more sophisticated, user-friendly tool. This led him to collaborate with Carter Stroup to bring the project to life.

The Challenge

James quickly realized that sharing his spreadsheet directly was neither scalable nor practical. Instead, he envisioned a streamlined, professional-grade application. Carter conducted several discussions with James to clarify the technical requirements, outlining the following key components:

  • User Authentication: Secure account creation, email verification, login/logout, and password recovery.
  • Payment Processing: Robust handling of subscriptions, including credit card payments, renewals, cancellations, updates, and promotional codes.
  • User Profiles: Ability to store user-specific data (age, graduation year, handicap) critical for tracking individual performance.
  • Data Tracking and Analytics: Algorithmic calculation for differentials, ranked rounds, and predictive insights, along with tools for viewing, filtering, and managing statistics.
  • Event Scheduling: Automatic scheduling for events and rounds, allowing users to pre-load and update information as event dates approach.
  • Admin Interface: A non-technical admin panel for stakeholders to manage users, track rounds, monitor retention, and oversee revenue.

These requirements needed to be implemented in a secure, responsive environment optimized for desktop and mobile use, complete with a promotional landing page for visibility and ease of access.

The Solution

Given the application’s complexity, low-code and no-code options were deemed insufficient. The project called for a robust, custom-built solution tailored to handle the unique demands of junior golf performance tracking.

Marketing and Launch

The application’s launch included a promotional landing page, designed to educate prospective users on its features and benefits, with a clear call to action for new registrations.

Results

The final product received enthusiastic feedback from stakeholders. The application achieved an average response time of 100ms, demonstrating impressive efficiency and speed. During beta testing, user satisfaction was high, with no significant bugs reported. The Differential Junior Golf app has become a valuable tool for parents and junior golfers, combining ease of use with the precision and depth needed to track and improve competitive performance.

Promotional Application Demo

User Guide Video

Video of Landing Page Design

Product Images

Technology Stack and External Tools

To ensure scalability, speed, and security, we selected the following technologies:

  • Django Framework: An all-in-one, developer-friendly framework that enabled rapid development while providing a solid backend infrastructure.
  • Tailwind CSS: A utility-first CSS framework chosen for efficient and adaptable front-end design.
  • Redis: Implemented for caching to improve application speed and performance.
  • Cloudflare: Provided SSL, firewall, and DDoS protection to secure the application.
  • Docker / Docker Compose: Ensured consistency across development and production environments by containerizing dependencies.
  • Stripe: Used for secure, versatile payment processing and subscription management.
  • SMTP Service: An external SMTP partner handled email functionalities, simplifying communications with users.
  • GitHub: Hosted version control, project documentation, and continuous integration (CI) workflows.
  • Sentry: Configured for monitoring errors and performance over time.
  • Celery: Managed background tasks, such as sending emails, to keep the app responsive and improve user experience.

Application Architecture

Frontend

The frontend, compiled using Django templates and static files, was designed to keep things streamlined. Avoiding separation between frontend and backend reduced complexity, ensuring faster load times and minimal resource use.

Backend

The Django backend structure consists of models for database abstraction, views to handle application logic and API calls, and template rendering for dynamic content delivery.

Database

PostgreSQL was selected as the database solution, configured separately from the Docker environment to facilitate independent hosting and connectivity.

Redis Cache System

To accommodate repeated queries, Redis was employed to cache frequently accessed data. A unique key structure was devised to ensure cache invalidation when data, such as rounds, was updated or deleted. Each key tracked the latest round count and timestamp, which automatically cleared upon updates, maintaining up-to-date data.

Testing and Quality Assurance

Quality was a priority, and all components were rigorously tested using a comprehensive test suite:

  • Python Unit Tests: Used to cover all functions, validating responses to typical, atypical, and edge-case inputs.
  • Coverage.py: Confirmed 100% code coverage for reliability.
  • Integration Testing: Ensured seamless operation across components, using Django’s TestCase for comprehensive checks.
  • JavaScript Testing: Any essential JavaScript functions were tested with Jest, achieving full coverage.
  • CI/CD Pipeline: GitHub Actions automated tests on pull requests and merges, ensuring code integrity with each deployment.

Project Documentation

  • Developer Documentation: Comprehensive docstrings, comments, and GitHub wikis facilitated future maintenance and scalability, with detailed explanations of non-intuitive functions or structures.
  • User Documentation: In-app guidance and supplementary external documentation provided users with clear instructions, helping them make the most of the application.