• 

• 

• 

• 

FOMO — Make Deadlines. Don't Miss Moments.

Because what's the point of making a living if we forget to live?

Inspiration

Why do we only rethink how we spend our time after we've missed something we can never get back?

A relationship we were too busy to nurture. A child's special moment we couldn't attend. A friend we kept promising to meet.

We spend years planning our careers, yet somehow leave the people and experiences we're working so hard for to whatever time remains.

As university students in Edinburgh, this felt personal. Between assignments, deadlines, and lectures, we missed opportunities to witness the Northern Lights, celebrate Navratri, or make mooncakes with friends during the Mid-Autumn Festival.

Some experiences we were too busy for. Others we didn't even know were happening.

And it wasn't just the experiences around us. It was the promises we kept making to ourselves: to get healthier, exercise consistently, learn a new dance, pursue a passion, or simply take better care of ourselves.

Somehow, those promises were always the easiest to break.

And we wondered:

Why does our calendar remind us of every deadline, but not the life we're missing along the way?

We have LinkedIn for professional growth, Outlook for meetings, and countless productivity tools to help us work more efficiently.

But isn't the whole point of working hard to build a better life?

That's when we decided to flip something everyone takes for granted: the calendar itself.

Instead of fitting life around work, what if we fitted work around life?

That's how FOMO was born.

We crossed out Fear of Missing Out because we wanted to build something that helps eliminate it.

Not by doing more. By making room for what matters.

What it does

Traditional calendars ask, "When can life fit around work?"

FOMO asks, "How can work fit around the life you want to live?"

FOMO reimagines weekly planning through three connected experiences.

1. Life-first prioritisation

We make commitments to everyone else: our employers, professors, colleagues, and clients.

But how often do we honour the commitments we make to ourselves?

That promise to get healthier. To finally exercise consistently. To learn a new dance, pick up an instrument, read more, or pursue a hobby we've been postponing for months.

With FOMO, these aspirations aren't treated as optional extras.

Users begin by choosing what matters to them, whether that's spending time with family, reconnecting with friends, prioritising physical and mental well-being, learning a new skill, or simply making time to rest.

FOMO helps turn those intentions into protected time, rebuilding the week so personal growth and meaningful experiences aren't always the first things sacrificed when work gets busy.

Because the commitments we make to ourselves deserve a place on our calendars, too.

2. Intelligent schedule rebuilding

Our constraint-aware scheduling engine reconstructs the week around those priorities.

It preserves fixed commitments, reorganises flexible work, and accounts for deadlines, task durations, and available time.

When everything cannot fit, the system identifies unresolved conflicts instead of producing an impossible schedule.

The result is a calendar that helps users stay responsible without automatically sacrificing their personal lives.

3. Opportunity discovery

Because sometimes the biggest missed opportunities are the ones we never knew existed.

FOMO introduces experience discovery, connecting available time with activities that reflect users' interests and schedules.

An empty Friday evening could become a cultural celebration, a dance workshop, a new hobby, or a chance to make memories with friends.

It's not about filling every empty slot.

It's about making sure life doesn't become the thing we keep postponing.

How we built it

We built FOMO as a full-stack, AI-assisted hackathon project, combining modern web technologies, a custom scheduling engine, and AI-supported development.

Our biggest technical decision was to make the inversion part of the scheduling architecture itself, rather than simply redesigning a traditional calendar interface.

Frontend — React, TypeScript and Vite

We used React 19, TypeScript, and Vite 8 to create a responsive, interactive calendar experience.

React hooks and context manage application state, while custom CSS preserves the visual identity of our original HTML prototype.

The interface lets users explore weekly commitments, establish personal priorities, and compare their existing schedule with a rebuilt alternative.

Browser-based local storage remembers preferences, making the experience more continuous and personal.

Backend — Python and Flask

Our backend uses Python 3.13, Flask 3.1, and Flask-RESTX, exposing structured REST APIs with request validation and Swagger documentation.

At its core is a custom, deterministic, constraint-aware scheduling engine.

It classifies commitments into three categories:

• Fixed commitments: Events that cannot be moved.
• Protected personal time: Time reserved for relationships, well-being, personal growth, and experiences.
• Flexible tasks: Work that can be reorganised while respecting deadlines and durations.

The engine determines feasible placements while respecting scheduling constraints.

We deliberately separated the scheduling engine from the frontend so its decisions could be tested and explained.

AI-assisted development — Claude

We used Claude as our AI development assistant throughout the hackathon, supporting implementation, code refinement, debugging, and iteration.

AI-assisted development helped us move rapidly from our initial concept and HTML prototype to an integrated React and Flask application.

For scheduling decisions themselves, we used explicit, deterministic constraint logic rather than relying on a generative AI model to produce potentially inconsistent schedules.

This provides a transparent foundation for future AI-powered personalisation and experience recommendations.

Integration and testing

We defined our frontend-backend contract using OpenAPI 3.1, with typed API communication and request validation.

We used JSON-based demo datasets to demonstrate interconnected schedules and opportunities, alongside 10 Python unit tests and browser-level end-to-end testing with Playwright and Chromium.

The production build serves the React frontend and Flask API together, creating a unified application experience.

Challenges we ran into

The hardest challenge was discovering that putting life first doesn't make responsibilities disappear.

Meetings still happen. Deadlines still matter. And sometimes there simply aren't enough hours.

We needed scheduling logic that respected personal priorities without sacrificing realism.

Another challenge was translating our original HTML design into a full-stack application while preserving the intuitive before-and-after experience that communicated our idea.

We also had to make a critical architectural decision: should scheduling itself rely on generative AI?

We chose deterministic constraint handling for the core scheduling decisions because an attractive timetable means nothing if it violates deadlines or overlaps commitments.

Finally, we had to balance the ambition of personalised opportunity discovery with the time available during the hackathon.

Our solution was to establish a working scheduling foundation and demonstrate the experience-discovery concept using curated data.

Accomplishments that we're proud of

We're proud that we didn't just build another productivity app. We challenged what productivity should mean.

We turned an everyday frustration into a full-stack prototype that reverses the assumptions behind traditional calendar planning.

We built a scheduling engine that treats personal time as something worth protecting, integrated it with an interactive calendar, and created a foundation for connecting free time with meaningful experiences.

We also established a documented API, automated backend tests, and a modular architecture that can support future integrations.

But our biggest accomplishment is the idea itself:

A successful week shouldn't only be measured by how much work you completed, but also by how much life you experienced.

What we learned

We came into this hackathon thinking about how to reverse a familiar system.

We left questioning why that system worked the way it did in the first place.

A calendar isn't just a collection of events. It's a reflection of our priorities.

Technically, we learned the value of clear API contracts, modular architecture, AI-assisted development, and transparent scheduling logic.

But our biggest lesson was more human.

We can reschedule meetings. We can postpone tasks. We can move flexible work.

But we can't always recreate moments.

And maybe that's what time management should help us remember.

What's next for FOMO

We envision FOMO becoming an intelligent personal-life planning companion.

Our roadmap includes deeper integration with existing calendars, adaptive scheduling, and AI-powered recommendations that understand users' interests, preferences, and available time.

We also want to connect live local events, cultural celebrations, student activities, and other experiences with people's schedules.

Imagine discovering that the Northern Lights might be visible tonight, finding a cultural festival nearby, or realising there's finally time for that dance class you've been postponing.

Imagine being able to keep the promise you made to yourself to exercise regularly, learn something new, or spend more time with the people you love.

Not another notification telling you to work harder.

A reminder that there's more to life than your to-do list.

We spend so much of our lives working towards a better tomorrow. We shouldn't have to miss every today to get there.

That's why we built FOMO.

Because life is not what happens in between meetings.

Built With

• chromium
• claude
• css3
• flask
• flask-restx
• html5
• javascript
• json
• node.js
• openapi
• playwright
• python
• react
• swagger
• typescript
• vite