A friend at another university commissioned me to build an application for his group’s final project in a security course. They had chosen ECDSA + laboratory attendance as their academic concept. My role was to turn that requirement into a working system and collaborate with the group on what they needed. At first, success meant implementing the concept correctly, building the attendance flow, and giving them something they could demonstrate.
Later, their professor saw potential beyond the assignment and asked the group to continue developing the system toward something the university could potentially use. I continued as the developer for that next version. The possibility of real use changed the question: a demo could show the idea, but a system people might rely on had to handle situations the demo had never needed to consider. That shift is what I remember most from working on UA LabSign.
Building for the requirement
The application changed shape several times as I worked with the group to understand what their final project needed. We experimented with Django, then a MERN implementation, and eventually settled on Next.js. Each version clarified part of the scope, but we did not begin with a complete picture. We were still working out how attendance should flow and how the security concept should fit into it.
I also had to understand enough about ECDSA to apply signing and verification meaningfully. It was not enough to add a cryptographic term to the project description. I worked with the group to understand what was being signed and how the signature fit into the attendance flow. That changed the work from demonstrating a topic to building an application around it.
Even so, the assignment gave us a fairly clear target. We could implement the expected flow, test the cases we knew about, and show that the core idea worked. That was a reasonable way to approach their course project. It did not answer what would happen if someone outside the group tried to use the application.
When the project became real
After the course project, their professor contacted the group because the application had potential beyond the assignment. The group was asked to continue developing it toward a system the university could potentially use, and I continued as its developer. We did not yet know how far that would go, but actual use had become a possibility, and that changed how I evaluated the work.
For the assignment, the group and I mostly asked whether a feature worked, whether they could demonstrate it, and whether it met the requirement. Now I had to think about how it would behave in less controlled conditions. What if a phone handled permissions differently? What if location data was unavailable or unreliable? Could the web and Android flows behave consistently? If something failed, would an administrator have enough information to understand what happened? Could a user recover from an unexpected state?
Those questions were not necessarily in the original assignment. They surfaced when we imagined the system being used by people who had not helped build it. A demo follows the path its creators expect. Real use finds the assumptions hidden around that path.
Real users change technical decisions
One concrete change was supporting Android as well as the web. React Native with Expo was practical because I already knew React, but a mobile app has constraints that a browser prototype does not. Permissions, app state, device settings, and location services all affect what the user can do. The same screen and logic can behave differently when the operating system is part of the flow.
Security also had to work as part of the system, rather than as a requirement demonstrated in isolation. Authentication, device-bound signing, and session behavior needed to make sense together across the web and mobile experiences. A signature can help verify that data has not been changed, but it does not by itself establish every fact about the person or device submitting it. Those boundaries mattered more once we considered the full attendance flow.
Location was another assumption that needed a more careful treatment. In a prototype, it is easy to think of a location reading as proof that someone is at a lab. On real devices, location can be unavailable, imprecise, or affected by settings and environment. It can be a useful signal in an attendance process, but it should not be treated as absolute proof of physical presence. Testing surfaced behavior we had not seen while building the initial flow, and it made us question what the system could reasonably infer.
These changes were not just a matter of adding features. They changed what we needed to test and what failure looked like. A permission problem or a session mismatch could leave someone unable to complete attendance, even if the happy path worked on our own devices.
What changed for me
Before UA LabSign, I tended to think about software mainly through features and requirements: build the flow, make it work, move on. The possibility that other people might depend on this system made failure feel different. A bug in a demo interrupts a demonstration. A broken attendance flow can affect someone trying to use the system and the person responsible for managing it.
That did not mean every edge case could be anticipated or every failure prevented. It did mean reliability, clear feedback, and recovery paths belonged in the definition of the work. A system is not finished just because its main feature succeeds once under expected conditions.
Requirements tell you what to build. Real users expose what the requirements forgot. For me, that is the point where the meaning of “working” changed: from proving an idea to taking responsibility for what happens when someone uses it.