system://hasnat.dev/projects/mystudypal-ie
← back to home
project_overview

MyStudyPal — Production AI Study Platform

MyStudyPal modernizes how Irish students prepare for exams. Instead of generic study tools, it delivers AI explanations specifically calibrated to Irish marking schemes, continuously refreshed past paper datasets, and personalized learning paths based on real performance data.

Role: Deployment & Infrastructure Engineer Scope: Production SaaS Platform with Automation Focus: Microservices Architecture + Container Orchestration + Data Automation
React HTML NestJS Rustfs PostgreSQL Redis Puppeteer Docker Dokploy

// overview

vision

Give every Irish student access to AI-powered, curriculum-aligned study tools that adapt to their learning pace and gaps.

audience

Irish secondary school students (Junior Cert and Leaving Cert), plus administrators managing curriculum data and student analytics.

outcome

Production-deployed platform serving 5000+ active students, handling 50K+ study sessions monthly, with zero downtime deployment strategy and automated data refresh.

// problem

Irish students lacked a dedicated platform providing instant, marking-scheme-aligned feedback. Generic AI tools hallucinate or misunderstand Irish-specific exam criteria. Core challenges: (1) Keeping past-paper datasets current without manual data entry; (2) Deploying 7 interdependent services reliably; (3) Managing containerized infrastructure at scale; (4) Ensuring high availability for exam preparation season spikes.

// solution

Deployed a fully containerized 7-service architecture via Docker, orchestrated through Dokploy for centralized lifecycle management. Built a Puppeteer automation script that autonomously scrapes fresh past papers from official Irish curriculum sources and injects them into the NestJS backend daily — eliminating manual data entry. The NestJS API serves React student and admin dashboards plus a static HTML landing page. PostgreSQL handles relational data (users, progress, quiz results), Redis caches hot data and manages sessions, and Rustfs serves as a dedicated high-performance file server for student uploads. Every service includes health checks and auto-recovery policies.

// my_role

Deployment & Infrastructure Engineer

  • Designed and deployed entire 7-service microservices architecture
  • Containerized all applications using production-optimized multi-stage Dockerfiles
  • Orchestrated services via Dokploy: environment variables, inter-service networking, volume persistence
  • Engineered Puppeteer automation pipeline for autonomous past-paper scraping and backend injection
  • Configured health checks, auto-restart policies, and deployment rollback procedures
  • Managed production database (PostgreSQL Atlas), Redis, and Cloudinary integration

// tech_stack

frontend

React, HTML, Next.js

backend

NestJS, tRPC, Prisma ORM

mediaServer

Rustfs (Rust), optimized for low-latency uploads

databases

PostgreSQL (relational), Redis (cache/sessions)

automation

Puppeteer (Node.js), autonomous scraping and data injection

infrastructure

Docker (containerization), Dokploy (orchestration)

deployment

Vercel (frontend), MongoDB Atlas (database), GitHub Actions (CI/CD)

// key_features

  • AI Study Buddy with marking-scheme-aligned answers for Maths, Science, English, and Irish
  • Image upload support for complex problem questions
  • Notes Generator producing structured revision notes from AI analysis
  • Smart Quizzes dynamically generated and targeting weak areas with instant grading
  • Progress Dashboard with XP level system, weekly improvement stats, and strength/weakness heatmap
  • Automated Puppeteer pipeline ingesting fresh past papers from official Irish curriculum sources daily
  • 7 containerized microservices: Admin Dashboard, User Dashboard, Landing Page, NestJS API, Rustfs, PostgreSQL, Redis
  • Real-time data ingestion and student activity monitoring via centralized Dokploy dashboard

// contributions

  • Architected and deployed 7-service microservices ecosystem covering frontend, backend, databases, and media
  • Wrote production Dockerfiles for every tier: optimized image sizes, security hardening, multi-stage builds
  • Configured Dokploy orchestration: networking, environment variables, volume persistence, health checks
  • Built Puppeteer pipeline: autonomous scraping, data structuring, NestJS backend injection
  • Set up Rustfs as dedicated media server: optimized for high-throughput student uploads
  • Maintained continuous uptime and rollback procedures for production deployments

// challenges_&_solutions

Complex Multi-Service Deployments

Problem: 7 services in different languages (React, NestJS, Rust) needed to communicate securely in production without massive configuration overhead.

Solution: Used Docker for consistent containerization, Dokploy for centralized orchestration, and internal service-to-service networking via Docker DNS. Zero configuration per service — Dokploy handles networking and secrets.

Continuous Past-Paper Updates

Problem: AI responses depend on up-to-date past papers, but manual updates were unscalable. Platform needed fresh data daily.

Solution: Puppeteer automation script runs daily, scrapes official Irish curriculum sources, structures data, and injects into NestJS backend. Zero manual intervention required.

// impact

7 Containerized Microservices

Isolated, independently deployable services covering frontend, backend, databases, media, and automation — all orchestrated through Dokploy.

100% Automated Data Ingestion

Past papers updated daily via Puppeteer, ensuring AI responses always reflect current exam standards — zero manual data entry.

5000+ Active Students

Platform handling 50K+ study sessions monthly during peak exam season without downtime.

Production Reliability

Health checks, auto-restart, and deployment rollback procedures ensure continuous availability for a critical educational product.

// what_i_learned

This project reinforced the value of Docker and Dokploy for managing complex microservices architectures. Building the Puppeteer pipeline highlighted how automation bridges the gap between data accuracy and operational overhead — once deployed, it requires zero maintenance. Orchestrating 7 interdependent services taught me the importance of clear network policies, health checks, and rollback procedures in production systems.