Skip to content

ACAIR Platform

Full Stack Engineering

The ACAIR platform is the public site, student portal, and staff admin app for an applied AI institute. I built it as one monorepo with an Express and MongoDB API (54 routes, 13 models), two React apps, SeerBit payment verification with fee rules by department and level, and Docker, Nginx, and path-filtered GitHub Actions for releases.

How it’s built

ACAIR Platform · Student portal, admin app and payments API for an applied AI research institute

The ACAIR platform covers the public site, a student portal for bio-data, curriculum and fee payment, and a staff admin app. I unified the Express API and two React apps into one monorepo with 13 Mongoose models and 54 API routes, added SeerBit payment verification with fee rules by category, department, level and mode, and deployed it with Docker, Nginx and path-filtered GitHub Actions.

API route handlers
54
Mongoose models
13
admin app screens
13
student site and portal pages
17
independently deployed services
3

Technology and what it does here

Express 4
REST API for auth, students, payments, fee schedules, books and magazines
MongoDB + Mongoose 8
Students, payments, fee schedules, book orders, leads, mail
SeerBit
Checkout and server-side verification of amount and currency by reference
React 18 + Vite + TypeScript
Public site and student portal
React 19 + React Router 7
Separate admin app
Radix UI / shadcn
49 UI primitives in the portal
jsPDF + autotable
Lazy-loaded receipt and order PDFs in the browser
JWT + bcryptjs
Student and admin authentication middleware
Multer
Uploads for books, magazines and student files
Nodemailer
Verification codes and broadcast mail
Docker + Nginx
API container and three vhosts for site, admin and API
GitHub Actions
CI plus path-filtered deploy jobs per app

Implementation details

  • isPaymentSufficient only accepts a SeerBit payment whose amount covers the expected fee in the expected currency.
  • FeeSchedule matches fees to students by category, department, level and admission mode, each defaulting to 'All'.
  • settleFeePayment moves a pending Payment to success only after verification.
  • deploy.yml uses dorny/paths-filter so frontend, admin and backend release only when their directory changes.

System architecture

Separate student and admin frontends use the same API. The payment reference ties an eligible fee to the gateway verification and the receipt.

Drag to rotate

Student fee settlement

  1. Passes to the next component: Fee and student
  2. Passes to the next component: Saved payment
  3. Passes to the next component: Verified settlement

Decision branches

  • SeerBit verification

    Reference, amount, or currency does not match

    Keep the transaction pending and withhold the receipt.

Component details

Project screenshots

ACAIR public website homepage with links to programmes, admissions, and the portalOpen full-size screenshot in a new tab
ACAIR’s public homepage provides entry points to programmes, admissions, and the portal.
ACAIR public website section listing programmes and showing the learning facilityOpen full-size screenshot in a new tab
The public programmes section outlines ACAIR’s training options and facilities.

Results and testing

  • Fee verification checks

    An offline run of the fee controller with synthetic records confirmed that it rejects a different student’s reference, a currency mismatch, and an underpayment.

  • One repository and three release jobs

    The source contains separate student, admin, and API release jobs. The backend workflow checks the container’s HTTP response after restart and keeps uploads in persistent host storage.

  • Next engineering milestone

    Add regression checks for API access and make payment reconciliation recoverable. Keep pending references available for delayed transfers, and make the student balance recover after an interrupted payment update.

From Fee Schedule to Receipt

Students needed to see the fees that applied to them, and bank transfers could complete after the checkout window closed. The portal needed a payment reference it could check again later.

  • Apply the same fee rules in both places

    I reused the eligibility rules when listing fees and starting checkout. I kept older schedules usable when targeting fields were missing, and saved the amount on the pending payment so verification could use the original fee.

  • Verify payments on the server

    I added a shared SeerBit verification helper for fees and book orders. The fee endpoint looks up the reference for the signed-in student and checks the gateway’s result against the stored amount and currency. The update only moves a pending record to success, so repeated checks cannot apply that transition twice.

  • Give students a way to follow up

    I wired the hosted checkout into the student portal and refreshed payment history when it closed. Pending transactions have a status check, and confirmed payments have a downloadable receipt.

Administration and Delivery

The student portal and admin app serve different audiences. I kept their release steps separate and brought both apps and the API into one repository so changes could be reviewed together.

  • Connect the book catalogue to invoicing

    I added catalogue and order management to the admin app, and built the customer checkout and invoice flow. I then connected invoice verification to the same gateway helper used for fees.

  • Deploy each application independently

    I added GitHub Actions checks for the two frontend builds and the backend image. The VPS workflow selects jobs by changed paths, serves both frontend builds through Nginx, and runs the API in Docker with upload storage mounted outside the container.

Technologies

  • React
  • TypeScript
  • Vite
  • Express
  • MongoDB
  • SeerBit
  • Docker
  • Nginx
  • GitHub Actions

Next project · AI/ML Engineer

Sigmant

Portfolio assistant

Gabriel’s projects, experience, and research