Full-Stack Developer & Product DesignerPersonal Project2024 – PresentIn Development
The Problem I Wanted to Solve
Anyone who’s tried to track their fitness progress with photos knows the frustration – you take a picture today, compare it to one from last month, and you can’t tell if you’re actually making progress because the angles are completely different, the lighting has changed, or you’re standing in a slightly different position. Most fitness apps just let you upload photos in a gallery format, but they don’t help you take consistent, comparable pictures.
I wanted to create something that would give people the honest visual feedback they need to stay motivated and celebrate their real achievements through every stage of their transformation.
Building Something New
The Core Innovation – Photo Alignment
The heart of Trackin’Fit is its unique overlay feature that lets you perfectly align new photos with previous ones. When you’re taking a new progress photo, you can see your previous photo with an opacity layer, allowing you to align the new picture almost perfectly onto the previous one. This ensures consistent positioning for truly accurate progress tracking.
But I didn’t stop there – the app also generates dynamic timelapses that visually animate your transformation over time, and includes intuitive side-by-side and slider comparison tools so you can really see your progress.
Starting Fresh with Modern Architecture
This project was built on top of an old project I had made that was so old it still used UIKit. I decided I’d do a total refactoring of it onto SwiftUI and that I would finally leverage the navigation flow with SwiftUI instead of UIKit – this is something that’s pretty rare in big companies, so I figured why not do that in my own project?
The navigation is done with NavigationStack which takes in a NavigationPath. I implemented a coordinator for this, passed on as an EnvironmentObject. The path contains an enum and handles different screens with a navigationDestination modifier. It was really satisfying to build something using the most modern iOS patterns available.
Building for the Future – Full-Stack Architecture
For this project, I wanted users to not lose their information between devices and to build for the future so they could use and connect to their account from web and Android if they wanted to, as well as from another iOS device. So I created a backend hosted on a server made with Node.js using the NestJS framework, with a PostgreSQL database using TypeORM.
Despite needing internet access for first-time use (so users can log in and everything), I wanted people to be able to use the application offline with no issues. The application uses CoreData for local storage, and all of its data syncs with the backend when a connection is made.
Solving Complex Sync Challenges
I had to devise a system for auto-logging users in despite not always having internet access. This was done by verifying if the user’s refresh token exists and is still valid based on expiration date. If so, they log in and see everything that’s already been saved to CoreData, and they can interact with the application, take pictures, delete, update – whatever they need.
The data sync logic works by ensuring every operation the user performs is first saved into the local database with a createdAt/updatedAt date, and that date gets compared with the server version. If something exists on the server but not locally, it gets added locally. If something exists locally but not on the server, the server checks if that entry was deleted at some point, and if so, the local entry gets deleted. Otherwise, it’s treated as a new entry.
What Makes This Special
Solving a Real Problem
Addresses the fundamental issue of inconsistent progress photos that plague most fitness tracking approaches.
Technical Innovation
Combines modern SwiftUI navigation patterns with sophisticated photo overlay technology and offline-first architecture.
Full-Stack Mastery
Demonstrates end-to-end product development from UI/UX design through iOS development to backend architecture and data synchronization.
Cross-Platform Vision
Built with extensibility in mind, ready for future web and Android implementations.
Why This Project Matters to Me
Trackin’Fit represents everything I love about software development – identifying a real problem that affects people’s daily lives and building an elegant technical solution for it. The photo alignment feature isn’t just a cool technical trick; it’s solving a genuine frustration that anyone who’s tried to track fitness progress has experienced.
Working on this project has also been a great way to explore modern iOS development patterns that I don’t always get to use in enterprise environments. Getting to implement pure SwiftUI navigation and experiment with the latest Apple frameworks has been really rewarding.
But what I’m most excited about is the offline-first approach. I believe apps should work regardless of your internet connection, and building the synchronization logic to make that seamless has been one of my favorite technical challenges recently. It’s the kind of problem that requires thinking about edge cases, data consistency, and user experience all at the same time.
Technologies & Innovations
iOS Development
- SwiftUI (complete rewrite from UIKit)
- NavigationStack with NavigationPath
- Coordinator Pattern with EnvironmentObject
- CoreData for local storage
- Custom camera integration
Backend & Database
- Node.js with NestJS framework
- PostgreSQL database
- TypeORM for data modeling
- JWT authentication with refresh tokens
- RESTful API design
Innovation Features
- Photo overlay alignment system
- Dynamic timelapse generation
- Offline-first architecture
- Bidirectional data synchronization
- Cross-platform data portability