U-NIT ME

Planning your uni degree is broken. U-NIT ME fixes it! semester plans, prerequisite-aware scheduling, and real student reviews. Your path to graduation, sorted. For every Aussie student.

Comment 4

Inspiration

We've all been there. first week of uni, staring at a course map that looks more like a circuit diagram than a study guide. As Monash students ourselves, we felt the frustration firsthand: which units do I take first? What are the prerequisites? Which semester does this even run? And when we turned to our friends, they were just as lost.

Tools like MonPlan existed, but felt outdated and unmaintained, leaving students to figure it out alone, armed with a PDF handbook and a visit to the admin office. We knew there had to be a better way. So we built it.

What it does

U-NIT ME is a course planner for university students. You sign in, enter your degree details, university, course, specialisation, major or minor, and our scheduling algorithm instantly generates a personalised, semester-by-semester unit plan tailored to you.

Each plan is fully prerequisite-aware, respects credit point limits, and accounts for semester availability. Click on any unit card to unlock two layers of insight: an official unit overview pulled directly from the Monash Handbook API synopsis, credit points, and prerequisites, displayed inline without ever leaving the app, plus real student reviews from Reddit (r/Monash) so you get both the official picture and the honest one. Save your plan, revisit it anytime, and update it as your goals evolve.

How we built it

We built U-NIT ME end-to-end in 48 hours using a modern full-stack setup:

  • Frontend: Next.js 16 (App Router) with TypeScript and Tailwind CSS
  • Auth: Clerk for seamless sign-in and user management
  • Database: Supabase to store user profiles and saved plans
  • Scheduling algorithm: A Python-based DAG (Directed Acyclic Graph) important-path engine that models unit dependencies and generates an optimal semester sequence
  • Handbook integration: A dynamic build ID extractor that reverse-engineers Monash's Next.js-powered handbook to surface official unit details inline
  • Unit reviews: Live Reddit API integration pulling discussions from r/Monash, cached per unit
  • Data: Scraped and cleaned Monash course, AOS, and unit data stored as structured JSON -elastic.ai: uses elastic as data analysis platform

The Next.js frontend communicates with the Python algorithm via a server action, passing degree parameters and receiving a complete schedule back as structured JSON.

Challenges we ran into

Nearly every layer of the stack threw us a curveball:

  • Data scraping and cleaning was by far the most gruelling part of the entire build. The Monash Handbook is, to put it kindly, a structural nightmare. Unit data was scattered across inconsistent formats, fields were missing or mislabelled, prerequisite rules were written in a dozen different ways with no clear pattern, and course structures had edge cases that seemed to contradict each other. Some units had requirement groups that mixed completely unrelated fields, others had credit point values that didn't add up, and elective placeholders were buried inconsistently throughout. Every time we thought we had clean data, the algorithm would surface a new unit that broke all our assumptions. We spent more time wrestling with the handbook's own inconsistencies than we did building almost any other part of the app, and that says a lot, given everything else we built in 48 hours. In the end, we had to write a custom data scraper to manually correct entries that the handbook itself couldn't get right.
  • Building the DAG scheduler was one of the most technically exciting challenges of the hackathon. At its core, U-NIT ME's scheduling engine models every unit in a degree as a node in a Directed Acyclic Graph, with prerequisite relationships as directed edges, and runs a important-path algorithm to determine the optimal semester-by-semester ordering. But the theory is the easy part. We had to simultaneously enforce year-level restrictions (no level 3 units for first-years), credit point caps per semester, semester availability (some units only run in S1, others only S2), AOS specialisation groupings, and optional major and minor pathways, all in a single unified pass. Getting the topological sort to respect every constraint at once, produce a schedule that actually makes sense for a real student, and do it in seconds? That was genuinely hard. When we finally saw it generate a clean, valid four-year degree plan from scratch correctly sequenced, properly constrained, and ready to display! the whole team lost it! That was the moment we knew we had something real.
  • Prerequisite logic had many edge cases: units with multiple valid pathways, elective placeholders, and mixed requirement groups that needed careful handling.
  • Working around the broken Monash Handbook API, the handbook has no public API. Guided by a community blog post that had previously investigated the handbook's internals, we learned it's powered by Next.js and that unit data lives behind a /_next/data/ endpoint requiring a buildId that changes on every deployment. Building on that foundation, we implemented a live scraper that fetches the current buildId from the homepage HTML and dynamically constructs the correct request, so unit overviews are up to date inside U-NIT ME.
  • Full-stack integration, wiring Next.js, a Python subprocess, and Supabase together cleanly under time pressure was a real challenge, especially handling the Python command fallback across Windows and Unix environments.
  • And of course we were coding through the night, multiple nights in a row.... some of us didn't sleep at all this last day... 3 energy drink cans a day saved us....

Accomplishments that we're proud of

We built a fully functional, end-to-end degree planning app in 48 hours and it mostly works. Not a mockup. Not a demo with hardcoded data. A real product: sign in, enter your degree, and within seconds receive a personalised, constraint-aware, semester-by-semester unit plan generated from scratch. Are there still bugs? Yes, and almost every single one of them traces back to the Monash Handbook's own inconsistent data. When your foundation has cracks, some of them show up in the building. We patched as many as we could; we're not done yet.

But the individual pieces are what we're really proud of:

The DAG scheduling algorithm is the heart of U-NIT ME, and watching it correctly sequence a full four-year degree while respecting prerequisites, credit point caps, semester availability, year levels, and AOS specialisations all at once, on the very first real run, was one of those moments where the whole team just stopped and stared at the screen.

Cracking the Monash Handbook integration felt like solving a puzzle nobody was supposed to solve. Building on community research into the handbook's internals, we implemented a dynamic buildId extractor that constructs live API calls on the fly, meaning our handbook integration survives every Monash redeployment automatically. Official unit details, always fresh, always inline.

The Reddit review panel was a late addition that ended up being one of our favourite features. There is something deeply satisfying about clicking a unit card and instantly seeing real students telling you whether it is genuinely interesting or an absolute trap. No handbook can give you that.

And honestly? We are proud of each other. Six people, a mountain of messy data, multiple all-nighters, a scheduling algorithm built from scratch, and a full-stack app wired together across Next.js, Python, and Supabase. We shipped it. Bugs and all. That is the accomplishment we are most proud of.

JUST INN VERY LAST MINUTE AI INTEGRATION WORKSSS WOOO!!! we upload our dataset of handbooks to elastic.ai so that the ai can search and query relevant data

What we learned

We learned that data is everything. It does not matter how elegant your algorithm is, how clean your UI looks, or how clever your API workaround is. If the underlying data is inconsistent, your whole product feels it. The Monash Handbook humbled us in ways we did not expect, and we came out of this hackathon with a deep appreciation for data quality that no lecture has ever managed to teach us.

We learned that reverse engineering is a legitimate and valuable skill. No documentation? No problem. You dig through HTML, inspect network requests, read community research, and figure it out.

We learned how to make hard calls under pressure. At 2am with hours left on the clock, you cannot build everything. You have to decide what the product cannot live without, cut everything else without regret, and ship what you have.

We learned that a DAG is a surprisingly good mental model for a lot of real-world problems. Degree planning is just one of them.

And we learned that six people who trust each other, communicate well, and refuse to give up can build something genuinely impressive in 48 hours. Even on no sleep. Even with a handbook that seems actively designed to make your life harder.

What's next for U-NIT ME

U-NIT ME was built for Monash, but the problem is not a Monash problem. Every university student in Australia sits down at some point and tries to make sense of a course map that was not designed to be understood. We want to fix that for all of them.

Smarter recommendations are where we want to take the algorithm. Right now, U-NIT ME tells you what you can take and when. The next version will tell you what you should take based on your interests, your goals, and what students like you have found valuable. Rule-based scheduling is the foundation, personalised AI recommendations. (just in ai works but intellegence can still be improved greatly)

July intake support Half of all students start in second semester and right now U-NIT ME does not serve them properly. That changes.

A proper admin portal so universities can keep their unit data accurate and up to date, rather than relying on us scraping a handbook that, respectfully, could use some work.

The version we built this weekend is the beginning. The version we are imagining is the one every Australian student has bookmarked before their first day of uni.

Built With

+ 29 more
Share this project:

Updates