Loading...
Ovlotracker
Privacy first Period Tracking and Journaling app
may 27
|
ZYNTH DIGITAL
|
2025
OvloTracker is a privacy-first period tracking and journaling application for women, built to support health awareness, self-reflection, and cycle understanding. Developed using Flutter, OvloTracker is deployed on both the Apple App Store and Google Play Store. The app can be used fully anonymously, while optional authentication unlocks advanced features such as themes, language preferences, and data export. OvloTracker combines menstrual tracking, ovulation prediction, rich journaling, and AI-powered support into a secure and customizable experience.
Core Principles
OvloTracker is designed around three core principles: privacy, inclusivity, and empowerment. Users can track sensitive health data without mandatory accounts, ensuring anonymity and trust. With support for 190 languages and extensive customization options, the app is accessible to a global audience. Its features encourage users to better understand their bodies, emotions, and cycles through data-driven insights and reflective journaling.
Cycle, Period & Ovulation Tracking
OvloTracker provides detailed monthly and yearly calendars for tracking periods and ovulation windows. Predictions are visually displayed and easy to interpret, helping users plan and understand their cycles over time. All calendar data is fully exportable, allowing users to share or archive their health history in formats such as PDF, markup, or JSON.
Flutter(Dart)
1 Map<String, List<Map<String, dynamic>>> getPredictions({int months = 1}) {
2 final DateFormat format = DateFormat('yyyy-MM-dd');
3
4 // Group past periods
5 final List<Map<String, dynamic>> pastPeriods = periodStartDates.map((start) {
6 final end = start.add(Duration(days: periodLength - 1));
7 final periodWindow = List<DateTime>.generate(
8 end.difference(start).inDays + 1,
9 (i) => start.add(Duration(days: i)),
10 );
11 return {
12 'start': format.format(start),
13 'end': format.format(end),
14 'periodWindow': periodWindow.map(format.format).toList(),
15 };
16 }).toList();
17
18 final DateTime today = DateTime.now();
19
20 final List<Map<String, DateTime>> predictedPeriods = [];
21 DateTime lastPeriodStart = periodStartDates.last;
22
23 while (predictedPeriods.length < months) {
24 final nextStart = lastPeriodStart.add(Duration(days: averageCycleLength));
25 final nextEnd = nextStart.add(Duration(days: periodLength - 1));
26
27 if (nextStart.isAfter(today.subtract(const Duration(days: 1)))) {
28 predictedPeriods.add({'start': nextStart, 'end': nextEnd});
29 }
30
31 lastPeriodStart = nextStart;
32 }
33
34 final List<Map<String, dynamic>> futurePredictions = [];
35
36 for (int i = 0; i < predictedPeriods.length; i++) {
37 final start = predictedPeriods[i]['start']!;
38 final end = predictedPeriods[i]['end']!;
39 final ovulation = predictOvulation(start);
40 final fertileWindow = getFertileWindow(ovulation);
41 final pmsWindow = getPmsWindow(start);
42
43 final periodWindow = List<DateTime>.generate(
44 end.difference(start).inDays + 1,
45 (i) => start.add(Duration(days: i)),
46 );
47
48 schedulePeriodNotifications(
49 periodWindow: periodWindow,
50 pmsWindow: pmsWindow
51 );
52
53 futurePredictions.add({
54 'cycleNumber': ((start.difference(periodStartDates.first).inDays) ~/ averageCycleLength),
55 'month': 'Month {i + 1}',
56 'periodWindow': periodWindow.map(format.format).toList(),
57 'ovulation': format.format(ovulation),
58 'fertileWindow': fertileWindow.map(format.format).toList(),
59 'pmsWindow': pmsWindow.map(format.format).toList(),
60 });
61 }
62
63 return {
64 'pastPeriods': pastPeriods,
65 'predictions': futurePredictions,
66 };
67 }Users can log daily physical symptoms, emotional states, and moods to build a comprehensive picture of their health patterns. Over time, OvloTracker correlates these logs with cycle phases, enabling users to recognize trends such as recurring symptoms or mood shifts around specific points in their cycle.
OvloTracker includes a powerful journaling system that supports rich text entries, emotional tagging, and timeline-based organization. Journals can be used for daily reflections, cycle-related notes, or mental health check-ins. Entries are fully exportable, giving users complete ownership of their personal data.
AI Chatbot Assistance
OvloTracker features an AI-powered chatbot designed to provide cycle-related insights, journaling prompts, and general health guidance. Powered by Python-based microservices, the chatbot adapts to user context while respecting privacy boundaries, offering supportive and informative interactions without replacing professional medical advice.
To encourage consistency and positive habits, OvloTracker includes a system of health-focused badges and achievements. Users earn rewards for activities such as regular logging, journaling streaks, or long-term cycle tracking. Badge logic is handled by dedicated Python microservices, ensuring flexibility and scalability as new achievements are introduced.
Smart Notifications & Reminders
OvloTracker sends timely notifications to alert users before upcoming periods or ovulation phases. These reminders can be customized or disabled entirely, ensuring that notifications remain helpful rather than intrusive. The system is optimized to respect user preferences and local device settings.
Security & Privacy Features
Security is a cornerstone of OvloTracker. The app supports app-level locks using device authentication methods to protect sensitive data. Anonymous usage ensures no personally identifiable information is required, while authenticated features are securely managed. All data handling follows privacy-first practices to ensure user trust.
Home Screen Widgets & Native Integrations
OvloTracker includes multiple home screen widgets for both iOS and Android, allowing users to quickly view cycle status, upcoming periods, or reminders without opening the app. Extensive native code integrations ensure deep platform support, smooth performance, and access to device-specific features on both operating systems.
Swift UI
1import SwiftUI
2
3struct LargeWidgetView: View {
4 let entry: SimpleEntry
5 @Environment(\.widgetFamily) private var family
6
7 var body: some View {
8 let calendar = Calendar.gregorianSundayFirst
9
10 ZStack {
11 IconBackgroundLarge()
12 VStack(spacing: 8) {
13
14 // HEADER
15 HStack(alignment: .center) {
16 VStack(alignment: .leading, spacing: 4) {
17 Text("OVLO Tracker")
18 .font(.system(size: 14, weight: .semibold))
19 .foregroundStyle(.pink)
20 Text(entry.date.monthYear)
21 .font(.system(size: 10))
22 .foregroundStyle(.secondary)
23 }
24 Spacer()
25 ProgressRingMini(progress: inferredProgress(from: entry.data.infoTiles[0].title))
26 .frame(width: 40, height: 40)
27 .accessibilityLabel("Cycle progress")
28 }
29 .padding(.horizontal, 12)
30 .padding(.top, 18)
31
32 // QUICK CARDS ROW
33 HStack(spacing: 8) {
34 StatChip(
35 icon: "calendar",
36 title: entry.data.infoTiles[0].subtitle,
37 value: nextPeriodText(from: entry.data.infoTiles[0].title),
38 tint: .pink
39 )
40 StatChip(
41 icon: "leaf",
42 title: entry.data.infoTiles[2].subtitle,
43 value: entry.data.infoTiles[2].title,
44 tint: .green
45 )
46 StatChip(
47 icon: "drop",
48 title: entry.data.infoTiles[1].subtitle,
49 value: entry.data.infoTiles[1].title,
50 tint: .blue
51 )
52 }
53 .padding(.horizontal, 12)
54
55 // MONTH GRID
56 MonthHeatmapCalendar(
57 date: entry.date,
58 calendar: calendar,
59 dayPhases: entry.data.dayPhaseTiles,
60 )
61 .padding(.horizontal, 12)
62 .padding(.top, 2)
63
64 // LEGEND
65 HStack(spacing: 6) {
66 Spacer()
67 LegendDot(color: primaryColors(for: DayPhase.period), label: "Period")
68 LegendDot(color: primaryColors(for: DayPhase.fertile), label: "Fertile")
69 LegendDot(color: primaryColors(for: DayPhase.ovulation), label: "Ovulation", showRing: true)
70 LegendDot(color: primaryColors(for: DayPhase.pms), label: "PMS")
71 Spacer()
72 }
73 .padding(.horizontal, 12)
74 .padding(.bottom, 2)
75
76 // FOOTER
77 HStack(spacing: 6) {
78 Image(systemName: "hand.tap.fill")
79 .font(.system(size: 10, weight: .semibold))
80 .foregroundStyle(.secondary)
81 Text("Open app for details & logs")
82 .font(.system(size: 10))
83 .foregroundStyle(.secondary)
84 Spacer()
85 Text(entry.date, style: .time)
86 .font(.system(size: 10))
87 .foregroundStyle(.secondary)
88 }
89 .padding(.horizontal, 3)
90 .padding(.bottom, 8)
91 }
92 }
93 }
94}
95Deployment & CI/CD
LoopyFeed follows a modern, production-grade CI/CD strategy that prioritizes stability, speed, and scalability. Every code change passes through automated testing pipelines that validate functionality across Flutter mobile builds, the Next.js web dashboard, and Python-based backend services. Successful builds are automatically prepared for release, significantly reducing manual overhead and deployment risk. Mobile applications are versioned and distributed via the Apple App Store and Google Play Store, ensuring compliance with platform guidelines and smooth user updates. The creator dashboard benefits from continuous deployment on cloud infrastructure, enabling rapid UI iterations and instant rollbacks. Backend microservices are containerized and deployed independently, allowing critical services such as QR code generation or analytics processing to scale horizontally based on demand without affecting the core user experience.
Backend & Database Architecture
OvloTracker is powered by a carefully designed backend architecture that prioritizes privacy, reliability, and scalability. At its core, the platform uses Supabase as the primary database and authentication layer, enabling secure data storage, real-time synchronization, and fine-grained access control. Supabase allows OvloTracker to support both fully anonymous usage and authenticated experiences without compromising user trust or data safety. Complementing Supabase is a suite of Python-based microservices that handle computationally intensive and feature-specific workloads. These services power the AI chatbot, manage QR code generation for data sharing and exports, calculate badge and achievement logic, and generate exports in multiple formats such as PDF, markup, and JSON. This separation of concerns ensures that sensitive health data remains isolated, services can scale independently, and new capabilities can be added without disrupting the core application. The modular backend design also enables future extensibility, allowing OvloTracker to integrate additional health modules, advanced analytics pipelines, or new AI-driven features while maintaining performance and strong data governance practices.
Python
1TEMPLATE_DIR = os.path.join(os.getcwd(), "app/templates")
2env = Environment(loader=FileSystemLoader(TEMPLATE_DIR))
3template = env.get_template("ovlo_template.html")
4
5async def generate_pdf_from_html(file):
6 html_bytes = await file.read()
7 pdf_io = BytesIO()
8 HTML(string=html_bytes.decode("utf-8")).write_pdf(target=pdf_io)
9 pdf_io.seek(0)
10 return StreamingResponse(pdf_io, media_type="application/pdf", status_code=201)
11
12def generate_pdf_from_json_data(data):
13 options = data.get("options", "111")
14 if len(options) != 3 or not all(c in "01" for c in options):
15 raise ValueError("Invalid options format. Must be a string like '110'.")
16
17 data["show_cycles"] = options[0] == "1"
18 data["show_symptoms"] = options[1] == "1"
19 data["show_mood"] = options[2] == "1"
20
21 rendered_html = template.render(**data)
22 pdf_io = BytesIO()
23 HTML(string=rendered_html).write_pdf(target=pdf_io)
24 pdf_io.seek(0)
25 return StreamingResponse(pdf_io, media_type="application/pdf", status_code=201)Deployment & Distribution
OvloTracker is deployed as a cross-platform mobile application using Flutter, ensuring a consistent and high-quality experience across both iOS and Android devices. The app is officially distributed through the Apple App Store and Google Play Store, adhering to platform-specific guidelines while maintaining feature parity across ecosystems. Behind the scenes, OvloTracker follows a structured deployment strategy where backend services are deployed independently from the mobile client. This approach allows backend improvements, bug fixes, and new features—such as enhancements to the AI chatbot or export system—to be released without requiring immediate app updates. Native platform integrations and custom iOS and Android code ensure optimal performance, reliable notifications, widget support, and secure app locking mechanisms. This deployment model supports rapid iteration, high availability, and a stable user experience, even as the platform evolves and scales to support a growing global user base.
Design, Themes & Customization
OvloTracker’s design system is intentionally crafted to foster emotional safety, clarity, and personal comfort. The app offers multiple carefully designed themes that allow users to tailor the visual experience to their preferences, whether they prefer calming neutral tones or more expressive color palettes. Theme selection is seamlessly integrated into the app experience, reinforcing a sense of ownership and personalization. With support for 190 languages, OvloTracker is built to be deeply inclusive, removing language barriers for users around the world. Typography, spacing, and layout choices are optimized for readability and accessibility, ensuring the app remains usable across different cultures, devices, and accessibility needs. Customization extends beyond visuals into functional preferences, allowing users to control notifications, calendar views, journaling formats, and data exports. This flexible design approach ensures that OvloTracker adapts to the user, rather than forcing users into a rigid workflow.
Flutter(Dart)
1Future<void> changeLanguage(String code) async {
2 final prefs = await SharedPreferences.getInstance();
3 if (code == 'system') {
4 _useSystem = true;
5 _currentLocale = null;
6 await prefs.setString(_prefsKey, 'system');
7 } else {
8 final loc = _parseLocale(code);
9 _useSystem = false;
10 _currentLocale = loc;
11 await prefs.setString(_prefsKey, _toTag(loc));
12 }
13 notifyListeners();
14 }Future Vision
OvloTracker is guided by a long-term vision to grow into a holistic women’s health companion while remaining grounded in its core values of privacy, autonomy, and trust. The platform’s architecture is designed to accommodate future enhancements such as AI-driven cycle predictions, personalized health insights based on long-term patterns, and expanded wellness modules that go beyond period tracking. Planned evolutions include deeper integration of mood and symptom analytics, adaptive recommendations based on individual cycles, and enhanced journaling intelligence powered by AI. The system is also positioned to support future community and educational features, optional integrations with external health services, and more advanced export and sharing tools. Throughout this growth, OvloTracker remains committed to empowering users with full control over their data, ensuring transparency, and building features that respect the deeply personal nature of women’s health.