TraceWay: Lessons in Working as a Team

What building a full-stack AR project as a group taught me — about scope, collective technical decisions, and the parts of software development that happen between the code.


What TraceWay was

TraceWay was a full-stack AR navigation platform built as a group project at Howest Brugge. The core idea: augmented reality navigation for pedestrians and cyclists, with a crowdsourced layer that let users flag hazards and risk zones along routes. Hardware sensors on a connected device could trigger push notifications when approaching a flagged area.

The technical scope was broad: a Vue.js frontend with Vite, a Java backend using Vert.x and SQLite, an OpenAPI specification, CI/CD with SonarQube for code quality, and Vitest for frontend testing.

The scope creep problem

TraceWay's feature list grew through the first month. Each team member had good ideas, the stakeholders had good ideas, and none of them were obviously wrong. The result was a backlog that was significantly larger than what we could realistically ship in the available time.

Cutting scope is uncomfortable. It means putting a feature aside — at least for this iteration. The earlier you do it, the less work gets thrown away. We learned this the hard way: the hardware sensor integration was cut late, which meant some backend work done for that feature was never used.

The right process is to be explicit about scope at the start of each sprint, not at the end. Define what "done" means before writing a line of code.

Making technical decisions together

Two architectural choices caused the most discussion in the team. First: Vert.x as the backend framework. It's reactive and performant but has a steeper learning curve than alternatives the team was more familiar with. The decision to use it was driven by course requirements and the real-time notification use case. In practice, the learning curve cost time early on that we didn't fully recover.

Second: SQLite as the database. Reasonable for a prototype; would not scale. The team knew this going in and explicitly scoped it as a trade-off to keep the infrastructure simple — the right call for a semester project, but worth being transparent about.

Business analysis work: UCD and ERD

The project required formal business analysis deliverables: a User-Centred Design (UCD) document covering personas, user journeys, and design rationale, plus an Entity-Relationship Diagram (ERD) for the data model. These felt like overhead at the time.

They weren't. The UCD forced early conversations about who the app was actually for and what their flow through the product looked like — conversations that surfaced requirement gaps before we'd built anything. The ERD caught a modelling error in the hazard data structure that would have been expensive to fix later. Process artefacts pay for themselves when you actually use them.

What working in a team actually teaches you

Courses teach you to build things. They don't fully prepare you for the coordination around building things — aligning on an approach when people have different opinions, keeping momentum across different schedules and working styles, or giving honest feedback on code that works but is hard to maintain.

The experience made me more aware of software development as a collective activity. The technical output is only part of the result; how a team works through ambiguity and disagreement shapes the quality of what they build just as much.