02

Replacing WeChat groups and Excelwith one systemthree roles can actually trust

Company
Graduation Project
Year
2025 – 2026
Type
Full-stack System · Role Workflow
Role
Solo Designer & Developer

Universities manage academic competitions through spreadsheets, group chats, and manual processes. This graduation project delivered a complete B/S system with role-based workflows for administrators, teachers, and students — covering the full lifecycle from competition publishing to result archiving.

Competition management system — login & project overview

A graduation project that had to work like a real product

A campus with 8,000+ students, 12 departments, and 100+ academic competitions every year — all managed through WeChat groups and Excel files. My graduation brief was to replace that entire workflow with a structured system.

I was the sole designer and developer — every product decision from data model to button placement was mine to make and defend in front of the graduation committee.

Competition info lived in group chats and spreadsheets nobody maintained

Typical workflow before this system: an admin posts competition details in a WeChat group, students' questions get buried in chat history, teachers collect registrations via shared Excel, and results end up in different folders on different computers every semester.

Original broken workflow — four pain-point breakpoints

The four points where information dropped, blocked, or got lost in the old workflow

01 · No single source of truth

Competition details, deadlines, and registration status scattered across WeChat, email attachments, and multiple Excel versions. Students miss deadlines because they can't find the latest info.

02 · Manual review bottleneck

Teachers review registrations one by one in spreadsheets with no status tracking. Peak periods (100+ registrations/week) create delays and lost submissions.

03 · No historical data

Past results aren't archived systematically. When the university needs participation statistics for accreditation reports, staff spend days collecting data from old files.

If the lifecycle becomes a state machine, four tools collapse into one

“If we encode the full competition lifecycle as a server-side state machine and pin every action to a role, the system can replace four tools — WeChat, Excel, email, and file folders — with one. And reviewers can stop tracking state in their heads.”

This was the bet the whole project rode on. If true, the system's value isn't “more features” — it's collapsing tool-switching cost and removing the human as the state-tracking bottleneck. Everything downstream (data model, permissions, UI) was derived from this hypothesis.

Five offline steps, one auditable state machine

The full loop: admin publishes a competition → students submit registrations → teachers review → system pushes notifications → students see results. Every step writes to the same record, so progress is locatable, explainable, and auditable.

Five-step business loop diagram

Five-step loop driven by role permissions and status fields

One data model, three role-driven workflows

Competition management isn't one workflow — it's three workflows sharing the same data. Admins publish and configure; teachers review and manage results; students browse, register, and check outcomes. Each role needs a different view of the same underlying system.

Considered · Low-code (DingTalk Yida / Jiandaoyun)

Rejected: row-level permissions across three roles aren't expressible in form-builder logic, and demos at 100 concurrent users hit platform throttling.

Considered · Monolithic dashboard with role flags

Rejected: client-side role conditionals leak admin field names through DOM inspection. Permissions belonged on the server, not in CSS visibility.

Chosen · Frontend-backend split + server-side RBAC

Three tailored interfaces share one API and one database. RBAC enforced at the API layer means a tampered frontend still can't escalate privileges.

“The project forced me to think beyond individual pages. Each module had to fit the same role model, permission rules, and lifecycle state logic so the system would feel coherent end to end.”

Designing for three users who see the same data differently

The central challenge was information architecture. The same competition record means different things to different roles: configuration to admin, a review queue to teacher, a registration card to student. One data model, three mental models.

🔐

Permission as UX

Each role gets a tailored dashboard. A student never sees admin controls — not hidden, just genuinely a different interface.

🔄

Lifecycle as navigation

Competition state (Draft → Published → Registration → Review → Results → Archived) drives what actions surface, instead of a static sidebar.

Batch over one-by-one

Teachers' biggest pain was reviewing registrations one at a time. The review interface is built around batch select, approve/reject, and bulk notes.

📚

Data as institutional memory

Every registration, decision, and result is timestamped and attributed — the system becomes the university's archive automatically, no extra step.

Admin view — competition queue with status filters

Admin · publish & configure

Teacher view — batch enrollment review

Teacher · batch review

Student view — team registration card

Student · browse & register

Four decisions worth defending in front of the committee

01

Why state-driven navigation, not a static sidebar

A static sidebar treats every competition the same. But what a teacher needs to see for a competition in “Review” state is fundamentally different from one in “Archived” state. Surfacing actions based on lifecycle state cut the action-to-completion time in user-testing rounds with three classmates by roughly half.

02

Why batch review, not card-by-card swipe

The Tinder-style card swipe was tempting — it looks modern. Rejected because real review patterns are bulk: “approve everyone from this department,” “reject all incomplete submissions.” Forcing one-at-a-time review would recreate the original Excel bottleneck in nicer paint.

03

Why three separate dashboards, not one with role flags

A single dashboard with conditional rendering ships faster but exposes admin field names in the DOM and makes onboarding harder (“why do I see this if I can't use it?”). Three real dashboards cost more code but each one feels purpose-built — and the API enforces permissions regardless.

04

Where admin-only fields live in the form

Inline-collapsed inside the relevant section, not on a separate “admin settings” page. The reasoning: forcing context-switching to a separate page broke the cognitive thread of “I'm publishing one competition,” and the data showed admins were forgetting to set fee-related fields when they lived elsewhere.

Architecture decisions that kept the demo stable

Spring Boot + Vue 3 with JWT auth and Redis-backed token blacklisting. A 15-table normalized schema designed for queries like “all registrations for competition X, grouped by team, with reviewer info”. JMeter at 100 concurrent users exposed an N+1 on category joins — fixed with eager loading, P95 dropped from 1.2s to 180ms.

These weren't engineering vanity — they were the difference between a smooth live defense and a frozen screen in front of the committee.

System architecture diagram

Layered architecture · Vue → Axios → Controller → Service → MySQL/Redis

Entity-relationship diagram

15-table normalized schema

What actually held up under load — and in front of the committee

This was a graduation project, not a production deployment — the numbers below are demo-scale evidence, not user adoption. They describe what the system can do, validated under load and in a live 30-minute defense.

100
Concurrent users sustained (JMeter)
180ms
P95 latency · down from 1.2s
0
Failures in 30-min live defense
A
Committee grade · top-tier graduation project
Admin dashboard — data overview screen

Admin dashboard at full demo capacity: 350+ competitions, 6,296 registration records, 428 archived awards, 150 categories (seed data modeled on the university's actual schedule).

Full lifecycle coverage

Every state transition exercised end-to-end: draft, publish, open registration, review, result publication, archive. Each path demonstrated live.

Concurrency validated under load

JMeter at 100 concurrent users confirmed peak-registration capacity. The N+1 fix (P95: 1.2s → 180ms) held up against the full seeded dataset.

Defense: live demo, passed top-tier

All three role workflows demonstrated live without a fallback recording. Committee highlighted the RBAC design and the system's ability to handle the full lifecycle without manual intervention.

What I learned doing this end to end

01

End-to-end ownership builds product thinking

Owning every layer taught me how product decisions ripple through a system. When I changed the permission model, I felt it in the database, the API, and the UI within the same hour.

02

Design demo stability as a feature

Performance tuning, seed data, and regression checks weren't engineering polish — they were the difference between a clean live demo and a frozen screen. Treat critical demo moments like production traffic.

03

Start with user flows, not tech stack

If I started over, I'd map the three role workflows first and derive the data model from those — instead of designing the database up front and fitting UI around it.

If this kept going, here's where I'd take it

01

Multi-school multi-tenant

Extend RBAC to an organization layer so different universities (or departments inside one university) can run isolated instances on the same deployment. The hardest part isn't engineering — it's defining which entities are shared (taxonomies, competition templates) vs. tenant-scoped.

02

Mobile-first redesign for students

Students register from phones in dorms, between classes, on the bus. The current web-first design treats mobile as a fallback. A native-feeling mobile flow (offline-first form drafts, push notifications for status changes) would close the biggest UX gap.

03

GenAI-assisted review for teachers

Use an LLM to pre-screen registration materials (resume attachments, project descriptions) and surface a “suspicious / consistent / outstanding” label per submission — keeping the teacher as final decision-maker but cutting the time-per-review by an estimated 60%. This is where role-based workflow products and AI agents will meet next, and where I want to spend my next chapter.

Next Project

Clippy