CSA Retrospective: reQUESTers Project
Author: Nikhil
Project: reQUESTers
Period: November 2025 - January 2026
Overview
This retrospective documents my contributions to the reQUESTers project, a gamified learning platform designed to track student progress through quests and award certificates based on completion milestones. My primary focus was on designing the backend architecture, building out the comprehensive data flow for how the system would operate, and coordinating team efforts to keep development organized.
Key Contributions
- Comprehensive backend flow architecture and UML documentation
- Backend development (in progress, collaborating with Trevor)
- Certificate system planning and tier design
- Team coordination and self-grading framework
1. Certificate System Planning
Problem Statement
The platform needed a way to reward students for completing quests, but there was no system in place for tracking milestones or awarding certificates. Key challenges included:
- No defined structure for what certificate tiers would look like
- No backend schema or flow for how progress would map to certificate eligibility
- No clear plan for how the frontend and backend would communicate around certificates
Tier Design
I planned a multi-tier certificate system to give students meaningful progression milestones:
| Tier | Requirement | Badge |
|---|---|---|
| Bronze | 50% completion | Basic achievement |
| Silver | 75% completion | Intermediate achievement |
| Gold/Mastery | 100% completion | Full mastery |
This tier structure informed the backend flow design — every piece of the architecture needed to support tracking a user’s completion percentage and mapping it to the correct tier.
2. Backend Architecture & Data Flow
Comprehensive Backend Flow Design
A major part of my contribution was designing the full backend data flow for the project. I created detailed documentation (Issue #16) mapping out how every component would interact — from user actions to database updates to notifications. This gave the team a clear blueprint to build from.
UML Class Diagram
| Class | Fields / Methods |
|---|---|
| User | +int id, +String username |
| Quest | +int id, +String title, +int requiredAmount |
| UserQuestProgress | +int id, +int userId, +int questId, +int progress, +boolean completed, +Date updatedAt |
| QuestService | +updateProgress(), +checkCompletion() |
| NotificationService | +notifyQuestProgress(), +notifyQuestCompleted() |
| Relationships: User → UserQuestProgress ← Quest | QuestService calls NotificationService on completion events |
Layered Architecture Pattern
The system follows a clean Controller → Service → Repository pattern that I documented for the team:
- Controller Layer: Handles HTTP requests (
QuestController) - Service Layer: Business logic for progress tracking and notifications
- Repository Layer: Database interactions for Users, Quests, and Progress
- Event Publisher: Async notification handling
This architecture document served as the foundation for how Trevor and I began building the backend together.
3. Backend Flow Diagram
| Task Completion | ||
| ↓ | ||
| Automatic Scanning | ||
| ↓ | ||
| Validation Check | ||
| ✓ Valid ↓ | ✗ Invalid ↓ | |
| Database Update | Log Anomaly | |
| ↓ | ↓ | |
| Certificate Generation | Monitor & Alert | |
| ↓ | ||
| User Notification | ||
| ↓ | ||
| Dashboard Display | ||
This diagram captures the intended end-to-end flow that Trevor and I are working toward implementing. The architecture accounts for:
- Automatic progress scanning without manual intervention
- Validation at every checkpoint
- Anomaly detection and logging
- Real-time dashboard updates
Having this flow mapped out before writing code ensures that as we build out the backend, every component has a clear purpose and fits into the larger system.
4. Backend Development (In Progress)
Collaborative Work with Trevor
Trevor and I have been jointly tackling the backend implementation. While the backend is still in its early stages, we have been working through the initial scaffolding together — setting up the project structure, identifying the endpoints we need, and beginning to translate the architecture diagrams into actual code.
Planned Endpoints
/api/certificates- Certificate retrieval and status/api/progress- User progress tracking/api/scan-tasks- Automatic progress scanning
Current Status
The backend is still early in development. The architectural planning is solid, but the actual service logic, database persistence, and API wiring are works in progress. The detailed flow documentation I created is serving as the roadmap for what we build next.
5. Team Coordination
I created the team self-grading framework (Issue #46) to track all team contributions:
| Team Member | Primary Task | Evidence |
|---|---|---|
| Trevor | Certificate API + Frontend standardization | #47 |
| Nikhil | Certificate user flow + Backend integration | #44 |
| Travis | Big Six framework + Interactive lessons | #53 |
| Alex | Big Six framework + File organization | #55 |
| Akshay | Analytics page + Sprint layout | #51 |
| Anvay | Progress bars + Leaderboard tab | #50 |
6. Work Completed vs. Remaining
Completed
- Comprehensive backend flow architecture and UML documentation
- Certificate tier classification design (bronze, silver, mastery) linked to progress thresholds
- Backend flow diagram mapping the full system lifecycle
- Team self-grading framework and coordination
- Layered architecture pattern documentation (Controller → Service → Repository)
In Progress / Future Work
- Build backend service for certificate issuance with progress validation (collaborating with Trevor)
- Persist certificate metadata (awarded date, tier, proof) in database
- Wire up API endpoints with service logic
- Create UI components displaying certificate status and tiers
- Integrate automatic progress scanning for unlocking certificates
- Comprehensive end-to-end testing
7. Reflection & Learnings
Technical Skills Developed
- Backend Architecture Design: Learned to design scalable, layered systems following industry patterns (Controller → Service → Repository)
- UML & System Modeling: Built detailed class diagrams and flow charts to document how data moves through the system
- Database Schema Planning: Designed schemas for tracking user progress and certificate tiers before writing code
- Collaborative Development: Worked closely with Trevor on backend development, learning how to divide responsibilities and stay aligned
Soft Skills Developed
- Project Management: Created tracking systems for team accountability through the self-grading framework
- Technical Communication: Documented complex system architecture clearly enough for the whole team to follow
- Problem Decomposition: Broke down the full certificate pipeline into discrete, buildable components
What Went Well
- Thorough architectural planning gave the team a clear direction
- Comprehensive data flow documentation provides a strong blueprint for implementation
- Good team coordination through issue tracking and the self-grading framework
- Collaborative partnership with Trevor keeps backend development moving
Areas for Improvement
- Backend implementation needs to progress further — architecture is strong but code is still early
- Need to prioritize translating diagrams into working endpoints
- Should establish testing patterns early as the backend matures
8. Self-Assessment
Grade: 0.89/1.0
Justification
My work demonstrates:
- Strong architectural foundation — the comprehensive backend flow, UML diagrams, and layered architecture documentation give the project a clear technical direction
- Meaningful planning that drives development — every diagram and document directly maps to what we’re building
- Active collaboration — working with Trevor on backend development, not just planning in isolation
- Team leadership — the self-grading framework keeps the whole team accountable
The deduction accounts for:
- Backend implementation still in early stages
- Need to translate more of the architecture into working code
- End-to-end testing not yet started