Case Study: The TutorMatchup Chronicles

Or: How a Final Year Project Nearly Broke Me (and How a Junior Saved My Degree)

Project: TutorMatchup-App

Developer: Khanida

Tech Stack: Flutter, Firebase

Status: Survived

Chapter 1: The April That Never Was

It started in April. Not with a beautiful idea, but with a beautiful lie.

The lie was simple: "How hard can Firebase be?"

Khanida opened her IDE in April, ready to build the future. The first repository was created with hope. The first `flutter run` was executed with confidence. And then... Firebase happened.

The app didn't just crash. It *refused to exist*. Authentication errors. Initialization failures. `google-services.json` files placed in the wrong directory, then the right directory, then deleted entirely out of spite. The console logs became a horror novel written in red text.

So she did what any reasonable developer would do: she deleted the repository and started over.

Repository #2. This time would be different. This time, she understood Firebase.

She did not understand Firebase.

Repository #3. Maybe the issue was the Flutter version. She downgraded. She upgraded. She uninstalled and reinstalled Flutter entirely at 3 AM on a Tuesday.

Repository #4. Maybe it was the folder structure. She reorganized everything. She renamed files. She renamed folders. She renamed the project. She renamed herself (metaphorically).

Repository #5. The breaking point. The repository where hope went to die.

Each repository was a fresh start, and each fresh start ended the same way: a runtime crash, a Firebase error, and the quiet, devastating sound of a developer closing their laptop and staring at the ceiling, questioning her existance.

April became May. May became June. June became July.

The project was not progressing. It was regressing. Khanida wasn't building an app; she was building and demolishing the same house over and over again, convinced that this time, the foundation would hold.

It never did.

Chapter 2: The Hammadk Protocol

August. A new semester. A new chance. And a new name in the group chat: Hammad.

Hammadk was a junior. Hammadk was also, apparently, a wizard.

He didn't ask about the five deleted repositories. He didn't ask why the Firebase configuration was a disaster zone. He simply looked at the wreckage, nodded, and said: "Okay. Let's start fresh. One repository. The real one."

And so, on August 2024, the actual TutorMatchup-App was born. The commit message was simple: "initial commit."

But it wasn't just an initial commit. It was a declaration of war against the chaos that had consumed the previous four months. Hammad set up Firebase correctly. He configured the `google-services.json` properly. He created a folder structure that didn't collapse under its own weight.

The `lib` folder, once a graveyard, became a workspace. The `android` folder, once a nightmare, became functional. The app... ran.

Khanida could finally focus on building features instead of fighting the framework. The login screen was designed. The form fields were updated. Dropdowns were added. A forgot password screen appeared.

And every time something cracked—because it always cracked—Hammad was there.

The routine was always the same. Khanida, after three hours of staring at a red console error, would send a message: "Hammadk. It cracked. I don't know why. The login button is now a bomb."

Hammadk would appear, like a debugging wizard summoned by sheer desperation. He'd look at the code, nod sagely, and say something like, "You forgot to initialize Firebase before using it, again."

He was the backbone of the operation. The `android` folder, with its "updated form fields and dropdowns," was a testament to his quiet, efficient fixes. The `assets` folder, finally populated with "subjects to be taught in tutor's form" in October, was a monument to his persistence.

Chapter 3: The Thesis Presentation Massacre

The day of the final thesis presentation. The big one. The one that determines your graduation.

Khanida had rehearsed. The slides were perfect. The demo was set. The app was... behaving.

Until 10 minutes before the presentation.

It cracked. Not just a little crack. A catastrophic, multi-layered, "why-do-I-even-exist" crack. The kind that makes you see your entire academic career flash before your eyes.

The judges were already in the room. The projector was on. The panic was real and rising.

In a moment of pure, unadulterated desperation, Khanida sent a message to Hammadk: "IT'S CRACKED. 10 MINUTES. PLEASE."

What happened next is the stuff of university legend.

Hammadk didn't just reply. He left his class. He gathered his developer friends—his fellas—and set up an impromptu war room. They remote-accessed the project and got to work.

And Khanida? Khanida yapped. Khanida cried. Khanida spiraled into a full existential meltdown about her miserable life, her prime minister's scheme (scam) laptop, SE students trying to scam her with fake promises to "fix her app," and a professor who seemed determined to ruin her entire persona.

It was chaos. Beautiful, messy, unfiltered chaos.

But on the other side of the screen, Hammad and his team were calm. They identified the issue: a Firebase initialization conflict that only appeared on the specific build used for the presentation. They pushed a fix. They cleaned up bugs. They did what Hammad had been doing all along: they saved the project.

The app loaded. The demo worked. The judges, who moments before were sharpening their critique forks, saw a functioning product.

The heat from the judges was intense. They questioned the stability, the architecture, the "learning curve." But the project worked. Because of Hammadk. Because of his fellas. Because sometimes, the only way to survive a disaster is to have people who show up when you're at your worst.

The Aftermath: The `README.md` We Never Wrote

The `README.md` on GitHub is the default Flutter one. It says nothing about the sleepless nights, the deleted repositories, the dependency struggles, the 11th-hour saves. It doesn't mention Hammadk. It doesn't mention his fellas. It doesn't mention the crying, the yapping, or the scams.

But the commit history tells the story. The "initial commit" from August, the real initial commit, the one that mattered. The "designed login screen" from the same day, a small victory. The "updated form fields" in October, a sign of progress. Each commit is a battle scar.

The Final Commit: "added subjects to be taught in tutor's form" (Oct, 2024).

A simple feature. But it was the final one. The project wasn't just a grade anymore; it was a testament to resilience, and to the fact that sometimes, the real final year project is the junior you meet along the way who stops your code from spontaneously combusting—and brings backup.

Khanida passed. Hammad is a hero. Hammad's fellas are legends. And the TutorMatchup-App? It's still on GitHub, a monument to the fact that even the most cracked of projects can be held together by good code and great people.

Epilogue: The five deleted repositories are gone. But they are not forgotten. They are the ghosts that haunt every `flutter run` that works on the first try. They are the reason Khanida flinches every time she sees a Firebase error. They are the proof that sometimes, you have to fail five times before you find the person who can help you succeed.

And to the laptop scammers and the professor who tried to ruin everything: the app works. She graduated. Stay mad.