An interactive, full-stack web application designed to improve the learning of Java programming through structured modules, adaptive learning paths, and real-time code evaluation.
🔗 Live Demo:
https://adaptive-learning-platform-23f1.vercel.app/
The first time you press the Login button, the request may take up to 5 minutes to respond. This happens because the backend API is hosted on Render, which goes into a cold state after 5 minutes of inactivity. Once the backend wakes up, all requests after the inital logic are fast and run smoothly.
🔗 🎥 Walkthrough:
https://www.youtube.com/watch?v=iiC-daTAA1I
Traditional approaches to learning programming often rely on static content and delayed feedback, which can slow skill development and reduce engagement.
This project addresses that problem by providing a web-based learning platform that enables:
- Interactive coding exercises
- Immediate automated feedback
- Structured progression through learning modules
- Adaptive learning paths based on user performance
The system allows learners to write, test, and debug Java code directly in the browser while receiving instant evaluation.
The primary aim of this project was to design and implement an interactive platform that enhances the learning of Java programming through:
- Real-time code execution and feedback
- Modular and structured learning content
- A scalable and maintainable system architecture
-
🧪 Interactive Coding Environment
- Monaco editor integration
- In-browser Java coding experience
-
⚡ Real-Time Code Execution
- Backend runner executes Java code securely
- Immediate feedback using predefined test cases
-
🧩 Multiple Learning Activities
- Coding challenges
- Debugging exercises
- Quiz-based assessments
-
📈 Adaptive Learning Path
- Tracks user progress
- Dynamically determines next level
-
🔐 Secure Code Execution
- Isolated runner environment
- Input sanitisation and controlled execution
-
📊 User Progress Tracking
- Stores completion, levels, and attempts
- Supports analytics and improvement tracking
The platform follows a layered architecture, separating concerns across:
- Frontend (Next.js / React)
- Backend API (Node.js / Express)
- Database (PostgreSQL via Neon)
- Code Execution Runner (Isolated Java service)
- Next.js
- React
- Tailwind CSS
- Monaco Editor
- Node.js
- Express.js
- PostgreSQL (Neon)
- Vercel (Frontend + Runner)
- Render (Backend API)
- UptimeRobot (prevents runner cold starts)
- User writes Java code in the browser
- Code is sent to backend API
- Backend forwards request to runner service
- Runner:
- Compiles code (
javac) - Executes code (
java)
- Compiles code (
- Output is returned as JSON
- Backend evaluates against test cases
- Feedback is returned to the user
- Input sanitisation before execution
- Isolated runner environment
- Execution time limits to prevent infinite loops
- Controlled payload structure between frontend and backend
The system was tested through:
- ✅ API testing using Postman
- ✅ Validation of incorrect inputs and error handling
- ✅ Code execution edge cases (compile/runtime errors)
- ✅ End-to-end testing of learning flows
- ✅ Manual UI testing
- Runner kept active using UptimeRobot to avoid cold starts
- Backend designed with modular services for scalability
- Optimised request/response handling for fast feedback
Running user-submitted code safely was a key challenge.
✔ Solution:
- Built an isolated runner service
- Added execution limits and sanitisation
Cold starts and rendering issues affected performance.
✔ Solution:
- Introduced uptime monitoring
- Refactored deployment structure
Ensuring correct level progression required careful logic.
✔ Solution:
- Implemented backend validation and clamping logic
- Centralised progression handling in services
- Role-based access control (admin/content author)
- Improved token handling (secure cookies, refresh tokens)
- Caching frequently accessed data
- Job queue for code execution
- Pre-warmed execution containers
- Database indexing for performance
- Full-stack system design and architecture
- Secure handling of user-generated code
- API design and backend structuring
- Debugging real-world deployment issues
- Importance of iterative development
Jerry Arthur
BSc (Hons) Software Engineering
This project was developed as part of a final-year dissertation and demonstrates the design and implementation of a scalable, interactive learning system.