AUFI.run

In Brief

• Type: Flutter Web App
• Period: 2024 – present
• Monetization: Free

Links

The Problem

As an enthusiastic runner, you eventually start thinking about structuring your training by yourself. Every body is different, which is why ready-made training plans provide a reference point but not an ideal solution.

Anyone who dives deeper into the world of trail and ultra running quickly recognizes that general training plans no longer meet the specific requirements of these running disciplines.

Sooner or later, many runners end up with a self-built Excel sheet where they plan their individual training.

Of course, platforms already exist for creating training plans. However, these are often designed for roadrunners. For them, training volume is usually specified in kilometers.

Due to the often hilly terrain of trail runs, training guidance based on hours is more appropriate. Additionally, the elevation gain covered plays an important role.

The requirements mentioned above are therefore only partially fulfilled by existing solutions.

The Solution

AUFI.run is a platform that eliminates exactly these shortcomings. Specifically designed for training for trail and ultra runs, it perfectly targets the non-road-runner audience.

A primary feature is long-term training planning. This allows runners to plan their training volumes over months and structure their training into macro cycles. AUFI thus specifically supports the monitoring of training volumes and alerts users to volumes that are too high or too low.

In short-term planning, users can also break down their planned training volume in detail into workouts. Through a connection to the Garmin API, planned and actual training can be directly compared.

AUFI.run is currently in the building phase. This means the focus is on building a regular user base.

In the future, monetization opportunities are also planned. Possibilities include selling training templates or paid accounts for coaches, allowing them to conduct training planning for other users.

Technical Details

AUFI.run is structured as a microservice architecture. In the backend, three services are responsible for different tasks.

Each service is available as a Docker container. This allows them to be started and stopped individually. This simplifies both development and later deployment.

Identity and Access Management (IAM)

Keycloak serves as the Identity and Access Management (IAM) service for managing users and their authentication with the system.

It handles user registration and the option for social login with Google. It is also responsible for login and the creation of JSON Web Tokens (JWT), which users use to authenticate for service usage.

Activity Service

This service is responsible for managing user-created activities, as well as synchronizing activities from external services like Garmin Connect.

Thanks to the push approach of the Garmin API, endpoints are available here to receive data from Garmin.

The received data is harmonized for better use and made available to the user.

Plan Service

The Plan Service manages the created plans by the user. This includes both long-term and short-term planning by the user.

The data is provided via a REST API and persisted in a PostgreSQL database.

Web App

The web app provides the user interface of the system and was implemented with Flutter. Using a cross-platform solution allows for future apps for Android and iOS to be made available.

Through an API gateway, the web app’s access to the various services is orchestrated. Depending on the purpose, requests are forwarded to the responsible service.

Landing Page

AUFI.run is rounded out by a landing page. This serves as the initial point of contact for potential users. It provides an overview of the most important features and invites the visitor to try out the web app.

What I Learned

As with the development of Trexpense, I have gotten to know all aspects of development through independently executing the project. This allowed me to further deepen my knowledge, particularly in backend system architecture.

Below, I elaborate on the various focus areas that I learned during the project.

Microservice Architecture

Originally planned as a monolith, it quickly became clear that dividing into different services would be the better option.

Just using Keycloak as an IAM service led to the separation of authentication logic and user management.

Due to the special requirements of connecting to the Garmin API, I also decided to outsource the management and synchronization of activity data to a separate service.

The implementation of communication between the different parts via a reverse proxy, implemented with nginx, was also exciting for me.

Containerization with Docker

With the division of the app into different services, using Docker containers was a logical step for me. This made it possible to work on individual components while running others as containers to directly test the integration.

By using Docker Compose, I could test the structure and dependencies of the services in the development environment, which greatly facilitated deployment.

Backend Development with Go

Before starting implementation, I researched the various possibilities for backend implementation. Previously, I had already worked with Java and Kotlin using the Spring Framework.

Thanks to helpful libraries that facilitated connection to the Garmin-API, I decided to implement the backend in Go.

Working with Go expanded my technology portfolio with a powerful language for backend services, which I can now use for future projects as well.

Flutter Web

Using Flutter Web allowed me to implement the user interface for AUFI.run with familiar quality.

Through quick feedback from Flutter, I could iteratively improve the appearance of the app without having to make lengthy changes. This also helped to quickly try out new ideas.

Flutter is perfect for developing web applications that don’t rely on Search Engine Optimization (SEO). Additionally, I can offer a mobile version of the app in the future and build on existing code.

The Three Most Important Insights for Future Projects

1. Openness to Technology Selection Instead of Habit

An open attitude toward technology selection enables tailored implementation according to requirements. The use of Go led to a high-performance implementation of the backend.

2. Independent Identity Management with Keycloak

If you’re willing to take on the configuration and maintenance of Keycloak, it offers a great way to self-host identity management.

3. Rapid Development and Deployment with Containers

Using containers accelerated my development through consistent development environments and allowed me reliable deployments to the production environment.