Team full-stack project
QuizQuest
A team-built full-stack quiz platform with teacher and student flows, authentication work, frontend and backend integration, and a PostgreSQL-backed application structure.
Implementation highlights
Authentication and onboarding
A big part of my work lived around login, registration, and the experience of entering the application correctly. That meant coordinating frontend forms and navigation with backend auth behavior and persistent database state.
Role-based user flows
QuizQuest has different expectations for teachers and students, so the interface needs to branch in a way that still feels coherent. I worked on making those flows clearer and more aligned from the user side.
Shared stack and development workflow
Because it was a team project, the setup mattered too. Working through Prisma generation, migrations, Dockerized local DB flow, environment variables, and shared repo issues was part of making the project usable for everyone on the team.
Project gallery
Screens, outputs, and working views
Landing and onboarding screen
The main entry point introduces the product and routes users toward login or registration.
Teacher and student role selection
A role-based entry screen that clarifies how each type of user moves through the platform.
Overview
QuizQuest was built as a gamified learning platform with distinct teacher and student experiences. It gave me practical full-stack experience in a shared codebase where feature work, integration work, and team coordination all mattered.
My contribution centered on authentication and the user-facing flow around it, along with the plumbing needed to make frontend state, backend routes, and database-backed behavior line up.
That combination made it a good example of the kind of early-career work I want more of: meaningful feature ownership inside a real collaborative architecture, without pretending I built the entire product by myself.
Problem / Goal
The platform needed to support more than one kind of user without feeling fragmented. Teacher and student experiences have different needs, but they still have to belong to the same product.
Authentication was not isolated to one page. It shaped routing, permissions, database-backed state, and how people entered the rest of the application.
Because it was a team project, integration was part of the problem too. The product only worked well if frontend, backend, and database behavior stayed in sync across multiple contributors.
Approach / Architecture
The stack used a React and TypeScript frontend, a Node.js and Express backend, PostgreSQL for persistence, Prisma as the ORM layer, and Docker to make local database setup more manageable.
I focused on the user-facing parts of authentication and role entry, then connected that work to backend behavior and the underlying database state.
The teacher and student flows were important because they changed how the product should behave after sign-in. That meant the UX work was tied closely to backend rules instead of being a purely visual task.
Working in a shared repo also meant paying attention to Git coordination, local environment issues, and how changes in one layer could affect the rest of the app.
Engineering details
I worked on registration and login paths that needed to agree with Express route behavior and database-backed user records.
Prisma generation, migrations, and local DB connectivity were real parts of the day-to-day implementation, not just background setup.
Frontend and backend integration mattered because auth bugs usually surface at the boundaries between pages, APIs, and stored state.
Teacher/student branching made the product more interesting because the role split had to show up consistently in both interface behavior and backend logic.
The shared repo environment made coordination and debugging part of the technical work, especially when multiple people were touching adjacent flows.
Challenges
Team projects create integration risk even when each contributor's feature looks reasonable on its own.
Authentication issues spread quickly because they affect navigation, access, and persistent state all at once.
Local development setup can slow a team down if database configuration, Prisma generation, or environment variables drift out of sync.
Maintaining a polished user experience while multiple contributors are shipping at once required careful communication.
What I learned
QuizQuest gave me a much more practical feel for working in a shared full-stack codebase instead of treating frontend and backend work as separate exercises.
It also made me better at thinking about authentication as a cross-cutting system concern rather than just a form and a route.
Most of all, it reinforced how much good collaboration depends on clear ownership, clean integration, and reliable local setup.
Previous
A serious product and algorithm project built around puzzle quality, reproducible generation, and a responsive user experience.
Next
An applied ML project that covers the whole workflow from audio preprocessing through feature extraction, model training, and evaluation.