Sascha´s Thoughts

Sascha Zhang

Hello everyone,
this is one of the projects I worked on as part of a school assignment.

When we first started working on this project, we didn’t begin with a clear technical goal. Instead, we started with a simple idea inspired by Jet Lag: The Game (Hide and Seek): how can we build something interactive where multiple users can participate in a shared experience?

The Idea

We wanted to create an application where users can join a session, interact with each other, and see updates in real time. The concept of rooms became the core of the system—users could join, answer questions, and view shared information such as player lists or live data.

Although the idea seemed simple at first, it quickly became clear that even basic features require careful structure and planning.

Working as a Team

This project was developed as part of a group, which added another layer of complexity. We had to coordinate ideas, split responsibilities, and make sure that different parts of the app worked together consistently.

Working in a team also meant that decisions had to be discussed and aligned, which slowed some parts down but improved the overall structure.

Turning the Idea into an App

We chose .NET MAUI to build a cross-platform application. The app was structured into multiple pages:

• A main page for navigation
• A join session page
• A room page to display participants
• A questions page for interaction
• A shared view for live data

To keep the system organized, we used a structured approach with ViewModels, separating logic from the UI.

Challenges

One of the biggest challenges was managing how data flows between different pages.

We had to deal with:

• keeping the UI in sync
• managing navigation
• sharing state between components

These problems made us realize how important good architecture is, even for smaller applications.

What Didn’t Work

Due to time constraints and the scope of the project, we were not able to fully complete the application.

While the core structure was in place, some features remained unfinished or only partially implemented. However, this also showed us how quickly complexity grows and how important it is to prioritize and plan realistically.

What I Learned

Even though the app wasn’t fully completed, the project was still valuable.

I learned:

• how to structure a multi-page application
• how to work in a team on a shared codebase
• how important planning and communication are

More importantly, I understood that building a system is not just about writing code—it’s about managing complexity.

Reflection

If I were to approach this project again, I would focus more on planning the architecture early on and defining clearer priorities.

Despite not finishing everything, the project helped me better understand how real applications are built—and how challenges appear along the way.