SkillForge — AI-Powered Student Skills & Career Development Platform

💡 Inspiration

Every year, thousands of computer science and self-taught students finish courses, bootcamps, and tutorials without ever knowing exactly where they stand against real industry expectations. They ask themselves: "Am I ready to apply for a Junior Developer role? What am I actually missing to become an AI Engineer or DevOps Specialist?" That gap between "I've learned something" and "I'm employable" is one of the biggest silent barriers to youth employment today — directly tied to UN SDG 4 (Quality Education) and SDG 8 (Decent Work & Economic Growth).

We built SkillForge because we wanted more than another course-recommendation app. We wanted a system that could measure a student's actual skill level, compare it against a real target role, and plan — step by step — how to close that gap, the same way a personal mentor would.

🚀 What it does

SkillForge is a full-stack, microservices-based platform that:

• Lets students take structured skill assessments across domains (Python, Web Development, DevOps, AI, Git, Databases).
• Calculates a precise skill gap between the student's current proficiency and the requirements of a chosen target career (e.g., AI Engineer, DevOps Specialist).
• Uses an autonomous AI agent with a 4-tool ReAct reasoning loop to generate a milestone-driven, personalized career roadmap — and shows its reasoning trace transparently, so students can see why each recommendation was made.
• Runs a RAG-powered chatbot grounded in a curated knowledge base of tech roadmaps and course catalogs, so answers are cited and trustworthy rather than hallucinated.
• Supports three distinct roles — student, mentor, and admin — with full JWT authentication and role-based access control (RBAC).
• Visualizes its own DevOps backbone: a live "DevOps Topology" view showing the Docker, Kubernetes, and Terraform configuration powering the platform.

🏗️ How we built it

We designed SkillForge as a decoupled microservices system rather than a monolith, both to reflect real-world engineering practice and to satisfy the hackathon's technical breadth requirements:

• Frontend: React 18 + Vite + Tailwind CSS for a responsive, chart-driven student dashboard.
• API Gateway: An Express-based reverse proxy that routes requests to the appropriate downstream service.
• Auth Service: Node.js/Express with bcrypt password hashing and stateless JWT sessions, enforcing RBAC middleware for student/mentor/admin permissions.
• Core Service: Handles student profiles, quizzes, and mentorship data.
• AI & RAG Service: A Python service combining a semantic retrieval engine (rag_engine.py) with an agentic planner (agent.py) that autonomously selects and chains tools to build a roadmap.
• Python Microservice: Pure object-oriented Python (SkillAnalyzer, SkillGapCalculator, RoadmapGenerator) demonstrating encapsulation and inheritance principles, unit-tested with pytest.
• Infrastructure: Multi-stage Dockerfiles and a 6-service Docker Compose network for local development; Kubernetes manifests (Deployments, Services, ConfigMaps, Secrets) for production; Terraform modules provisioning AWS VPC, subnets, and container clusters for infrastructure-as-code.
• Automation: Bash and PowerShell scripts so the entire stack can be spun up with a single command on Linux, macOS, or Windows.

Each service communicates over REST APIs, and the whole system is orchestrated so a new contributor can go from git clone to a running platform in minutes.

🧗 Challenges we ran into

• Keeping the agent grounded: Autonomous agents can drift into confident-sounding but incorrect roadmaps. We had to constrain the agent's tool-calling loop and pair it tightly with the RAG knowledge base so every recommendation traces back to a real, retrievable source.
• Cross-service consistency: With five independently deployable services (gateway, auth, core, AI, Python), keeping data contracts and JWT validation consistent across languages (Node.js and Python) required careful API design and shared schema conventions.
• Infrastructure complexity on a deadline: Standing up Docker, Kubernetes, and Terraform in the same project meant we had to be disciplined about environment parity — what works in Docker Compose locally needed to translate cleanly into Kubernetes manifests and Terraform-provisioned cloud infrastructure without configuration drift.
• Balancing depth vs. time: Implementing genuine OOP-based skill analysis, a working RAG pipeline, and an agentic planner — all within a hackathon timeline — meant constant prioritization of what to build fully versus what to scaffold.

🏆 Accomplishments we're proud of

• A working end-to-end pipeline: quiz → skill scoring → gap calculation → AI-generated roadmap, all visible to the user in real time.
• An agent that exposes its own reasoning trace instead of acting as a black box.
• A genuinely production-shaped infrastructure setup (Docker → Kubernetes → Terraform) rather than a single hardcoded demo script.
• Full RBAC-secured multi-role experience (student, mentor, admin) built from scratch.

📚 What we learned

• How to design a RAG system where retrieval quality directly determines the trustworthiness of downstream agent decisions.
• Practical patterns for orchestrating a polyglot microservices architecture (Node.js + Python) behind a single gateway.
• The operational discipline required to keep local Docker environments, Kubernetes manifests, and Terraform-provisioned infrastructure in sync.
• That transparent AI reasoning (showing the "why," not just the "what") builds significantly more user trust than a black-box recommendation.

🔭 What's next for SkillForge

• Expanding the knowledge base with real-time industry job postings to keep skill-gap calculations current.
• Adding peer and mentor feedback loops directly into the roadmap-adjustment cycle.
• Building an analytics dashboard for institutions to track cohort-wide skill trends against labor market demand.

Built With

• agentic-ai
• amazon-web-services
• bash
• bcrypt
• docker
• docker-compose
• express.js
• fastapi
• hcl
• javascript
• jwt
• kubernetes
• llm
• microservices
• mongodb
• node.js
• powershell
• python
• rag
• react
• rest-api
• tailwindcss
• terraform
• vite