1. Dashboard

Live ticket totals, open/in-progress/resolved counts, and critical-ticket highlights at a glance.

2. Ticket Queue

Filterable ticket table with priority, status, assignment, and search across the full ticket backlog.

3. Ticket Detail

Description, comment thread, attachments, and a full activity timeline for a single ticket.

Active Project Case Study

HelpDesk Ticketing System

A Full-Stack ASP.NET Core + React Service Desk with Role-Based Access, JWT Authentication, and a Complete Ticket Lifecycle

ASP.NET Core (.NET 10) EF Core Identity + JWT React TypeScript Vite Tailwind CSS TanStack Query SQLite / PostgreSQL

Live Demo View Code

At a Glance

Problem: Support requests scattered across email and chat, with no ownership, status, or audit trail.
Role: Designed and built the full-stack system: ASP.NET Core API, React frontend, schema, JWT auth, and role-based access.
Solution: A structured help desk with three roles, a defined ticket lifecycle, and a complete activity ledger.
Result: Every ticket is owned, assigned, and audited end-to-end, with role-aware dashboards for backlog and turnaround.
Proof: Live demo, GitHub repository, screenshots, and the schema and API documentation below.

Executive Summary

HelpDesk is a production-ready help desk ticketing system built on ASP.NET Core (.NET 10) with a React + TypeScript frontend. It replaces scattered email threads and spreadsheets with a structured service desk: employees raise tickets, technicians resolve them, and admins manage users, departments, and categories.

Access is enforced by JWT authentication and three roles (Employee, Technician, Admin). Every ticket moves through a defined lifecycle while a ticket_activity_logs ledger records who did what, making the entire support workflow traceable.

The Support Chaos

• Lost Requests: Issues submitted over email and chat disappear into inboxes with no single source of truth.
• No Ownership: Nobody knows who is working on what, and duplicate or unassigned tickets fall through the cracks.
• No Audit Trail: Status changes, reassignments, and resolutions happen silently with no record of who did what.
• No Visibility: Managers lack metrics on backlog, turnaround, and workload per department.

The Structured Service Desk

• Centralized Tickets: Every request becomes a ticket with title, category, department, priority, and status.
• Clear Ownership: Admins assign technicians; technicians see their queue and resolve tickets with full accountability.
• Full Activity Log: Creation, assignment, status/priority changes, and comments are all recorded on a timeline.
• Role-Based Dashboards: Live metrics for open, in-progress, resolved, and critical tickets per department and category.

Core Architecture

1. ASP.NET Core API + EF Core

A versioned /api/v1 JSON API powers the React frontend. Entity Framework Core maps seven normalized tables, and ASP.NET Core Identity handles password hashing while JWT bearer tokens secure every protected route.

Role-based [Authorize] guards enforce Employee, Technician, and Admin boundaries.
Tickets are treated as stateful resources; assignment, status, and priority changes flow through dedicated PATCH endpoints.
Attachments use multipart/form-data with size, MIME, and metadata validation stored in the DB.

2. React + TypeScript Frontend

Built with Vite and Tailwind CSS, the client uses TanStack Query for server-state caching and React Hook Form + Zod for validated forms:

Role-aware sidebar and protected routes via React Router.
Ticket queue with search, filters (status, priority, category, department), and pagination.
Ticket detail view combining description, comment thread, attachments, and an activity timeline.
Automatic Axios Authorization: Bearer injection from the auth store.

3. Ticket Lifecycle & Activity Audit

Tickets progress through OPEN → IN_PROGRESS → RESOLVED → CLOSED, with REOPENED as a recovery path. Priorities range from LOW to CRITICAL. Every meaningful event writes a ticket_activity_logs entry with old/new values, giving a complete, chronological audit of each ticket.

Database & Schema Design

Seven normalized tables (SQLite by default, PostgreSQL-ready) model the full service desk domain while keeping historical activity and file metadata separate from live state:

users

Identity + Roles

email [UNIQUE] string(255)
department_id [FK] nullable
role employee | technician | admin
password_hash string
is_active boolean

departments

1 : * users

name string(255)
description text nullable

IT Support, HR, Finance, Operations.

tickets

Core Resource

created_by_id [FK] unsigned bigint
assigned_to_id [FK NULL] nullable
category / department [FK] unsigned bigint
priority low | medium | high | critical
status open | in_progress | resolved | reopened | closed

ticket_comments

Communication

ticket_id [FK CASCADE] unsigned bigint
user_id [FK] unsigned bigint
content text

ticket_attachments

File Metadata

ticket_id [FK CASCADE] unsigned bigint
file_name / file_path string
file_size bigint
mime_type string

ticket_activity_logs

Audit Ledger

ticket_id [FK CASCADE] unsigned bigint
user_id [FK] unsigned bigint
action string
old_value / new_value string nullable

REST API Surface

A clean, versioned JSON API under /api/v1 powers the React frontend and any future integrations:

Domain	Key Endpoints	Description
Auth	POST /api/v1/auth/login · register · logout	JWT issue and session management via ASP.NET Core Identity.
Tickets	GET/POST/PUT/DELETE /api/v1/tickets	Search, filter, sort, and paginate; PATCH for assignment, status, and priority.
Comments	GET/POST /api/v1/tickets/{id}/comments	Nested thread with edit/delete authorization checks.
Attachments	POST /api/v1/tickets/{id}/attachments	Multipart upload with size and MIME validation; metadata stored in DB.
Activity	GET /api/v1/tickets/{id}/activity	Read-only timeline of every change, with optional admin-wide filters.
Dashboard	GET /api/v1/dashboard/summary · tickets-by-*	Role-aware metrics: totals, status, priority, category, and department.

Key Benefits & Tangible Outcomes

End-to-End Accountability

Every ticket is owned, assigned, and audited from creation to closure, eliminating lost or duplicate requests.

Complete Audit Trail

Status, priority, and assignment changes are logged with old/new values for full traceability.

Strict Role Isolation

Employees see their own tickets, technicians see their queue, and admins manage the entire system.

Data-Driven Support

Role-aware dashboards surface backlog, resolution, and critical tickets by department and category.

Need a help desk or internal ticketing tool?

Let's coordinate to build secure .NET backends, role-based React dashboards, or workflow automation tailored to your team.

Get in Touch →

← Back to Portfolio Next Case Study →