Skip to main content
Technology

Built to be deployed, not just demonstrated

A single ASP.NET Core MVC application over one SQL Server database. Deliberately boring infrastructure, so the interesting part can be the intelligence layer.

Platform

  • .NET 8 (LTS)
  • ASP.NET Core MVC
  • Razor views
  • Dependency injection throughout

Data

  • SQL Server
  • Entity Framework Core 8
  • Code-first migrations
  • Indexed, normalised schema

Security

  • ASP.NET Core Identity
  • Role-based authorisation policies
  • Anti-forgery on every unsafe verb
  • Audit logging

Front end

  • Bootstrap 5
  • Custom design system
  • Chart.js for analytics
  • Font Awesome

Real time

  • SignalR notification hub
  • Per-role delivery groups
  • Persisted before delivery
  • Graceful degradation without JS

Processing

  • Hosted background worker
  • Durable job queue
  • No long work on request threads
  • Structured logging via Serilog

Architecture decisions worth stating

One deployable application, not twelve projects

Separation of concerns is achieved through folders, interfaces and services inside a single project. A small team has to understand, debug and deploy this during a hackathon; a twelve-project solution would buy architectural purity at the cost of every practical quality that matters here.

The AI layer sits behind an interface

IAiService and ISkillExtractionService define the contract. The shipped provider is a gazetteer-based extractor that runs fully offline with no API key, so the platform is never dependent on an external service being reachable. Swapping in a hosted model means registering a different implementation and changing nothing else.

No hardcoded intelligence

Every weight, threshold and normalisation constant lives in strongly typed configuration. Demand scoring, drift classification, gap severity and curriculum alignment can all be retuned per deployment without a code change.

Charts are never hardcoded in JavaScript

Every chart reads a JSON payload the server produced from live queries. The client-side code knows how to render a chart; it never knows what the values are.

Derived data is recomputed, never hand-edited

Demand scores, drift results, district gaps and curriculum alignment are all outputs. They are replaced wholesale on each pipeline run, which means they cannot silently diverge from the evidence.

Project structure

SkillSync/
├── Controllers/       thin, no business logic
├── Models/            domain entities by area
├── ViewModels/        presentation shapes
├── Data/              DbContext, migrations, seed
├── Services/          application services
├── Interfaces/        service contracts
├── AI/                extraction, normalisation
│   └── Providers/     pluggable AI implementations
├── Analytics/         the intelligence engines
│   ├── SkillDemandService
│   ├── SkillDriftService
│   ├── SkillGapService
│   ├── CurriculumAlignmentService
│   ├── DistrictIntelligenceService
│   └── RecommendationService
├── Infrastructure/    config, cross-cutting
├── Middleware/        global exception handling
├── Hubs/              SignalR
├── Views/             Razor
└── wwwroot/           css, js, assets

SkillSync.Tests/       unit tests

Request flow

Controller → Service → EF Core → SQL Server
Controller → AI Service → IAiService → Provider
Controller → Queue → Background Worker → Engines

Controllers stay thin. Long-running intelligence work is queued rather than executed on the request thread, so no HTTP request ever waits on a full pipeline run.