Prescripto

Production-grade healthcare appointment platform built with the MERN stack and deployed with a complete Docker + AWS + CI/CD workflow.

Live Application • Admin Panel • Source Code

📌 Overview

Prescripto is a full-stack healthcare appointment platform connecting patients, doctors, and administrators through role-based workflows.

Patients can discover doctors, view profiles, manage their accounts, book appointments, and make online payments. Doctors can manage availability and appointments. Administrators can manage doctors, appointments, and platform activity.

The project goes beyond a typical MERN application: it is containerized, continuously built, published to GitHub Container Registry, deployed to AWS EC2, served through Nginx, secured with HTTPS, and operated with a SHA-based release workflow.

Production URL: https://prescripto.shop/

✨ Features

👤 Patient

User registration and authentication
Browse doctors by specialty
View doctor profiles
Appointment booking
Appointment management
Profile management
Online appointment payments with Razorpay
Protected user workflows

👨‍⚕️ Doctor

Secure doctor authentication
Doctor dashboard
Appointment statistics
Earnings information
View and manage appointments
Complete or cancel appointments
Availability management
Profile management

🛡️ Admin

Secure admin authentication
Platform dashboard
Dashboard analytics
Add doctors
Manage doctors
Manage appointments
Monitor platform activity

💳 Payments

Razorpay order creation
Browser-side Razorpay Checkout initialization
Payment response handling
Backend payment verification
Production payment flow

🖼️ Media

Multipart file uploads with Multer
Cloudinary-based media storage

🏗️ Architecture

                             Internet
                                │
                                ▼
                     ┌─────────────────────┐
                     │   prescripto.shop   │
                     │     HTTPS / TLS     │
                     └──────────┬──────────┘
                                │
                                ▼
                         ┌─────────────┐
                         │    Nginx    │
                         │ Reverse     │
                         │ Proxy       │
                         └──────┬──────┘
                                │
              ┌─────────────────┼─────────────────┐
              │                 │                 │
              ▼                 ▼                 ▼
             /               /admin/            /api/
              │                 │                 │
              ▼                 ▼                 ▼
        ┌───────────┐     ┌───────────┐     ┌───────────┐
        │ Frontend  │     │   Admin   │     │  Backend  │
        │  :5173    │     │   :5174   │     │   :4000   │
        └───────────┘     └───────────┘     └─────┬─────┘
                                                  │
                                      ┌───────────┴───────────┐
                                      ▼                       ▼
                                  MongoDB                 Razorpay

Production request routing

Route	Destination
`/`	Frontend → `127.0.0.1:5173`
`/admin/`	Admin → `127.0.0.1:5174`
`/api/`	Backend → `127.0.0.1:4000`

The application ports are bound to localhost. Nginx is the public entry point.

🚀 Production Deployment

Prescripto currently runs on:

AWS EC2
Amazon Linux 2023
Docker + Docker Compose
Nginx
Let's Encrypt / Certbot
GitHub Actions
GitHub Container Registry (GHCR)
Custom domain: prescripto.shop

Production topology

GitHub
   │
   │ push to main
   ▼
GitHub Actions
   │
   ├── Install dependencies
   ├── Lint
   ├── Build frontend
   ├── Build admin
   ├── Build Docker images
   └── Push images to GHCR
             │
             ▼
        SSH to EC2
             │
             ▼
        deploy.sh
             │
             ├── Pull latest main
             ├── Set IMAGE_TAG
             ├── docker compose pull
             ├── docker compose up -d
             ├── Prune unused images
             └── Health check

🐳 Docker

The production application consists of three containers:

prescripto-backend
prescripto-frontend
prescripto-admin

Production port mappings:

Backend   127.0.0.1:4000 → container:4000
Frontend  127.0.0.1:5173 → container:4173
Admin     127.0.0.1:5174 → container:4173

The frontend and admin applications are built with Vite and served with Vite Preview inside their containers.

SHA-based images

Images are tagged with the Git commit SHA instead of relying only on latest:

ghcr.io/vishwak-tech/prescripto-backend:<commit-sha>
ghcr.io/vishwak-tech/prescripto-frontend:<commit-sha>
ghcr.io/vishwak-tech/prescripto-admin:<commit-sha>

This provides traceable releases and supports deterministic rollback.

🔄 CI/CD

Every push to main triggers the production workflow.

git push
   │
   ▼
Checkout
   │
   ▼
Install dependencies
   │
   ▼
Lint
   │
   ▼
Build frontend + admin
   │
   ▼
Docker build
   │
   ▼
Push images to GHCR
   │
   ▼
SSH to EC2
   │
   ▼
Deploy with deploy.sh
   │
   ▼
Health check
   │
   ▼
Production

GitHub Actions responsibilities

Checkout source
Set up Node.js
Run npm ci
Lint frontend
Lint admin
Build frontend
Build admin
Authenticate to GHCR
Build backend/frontend/admin images
Push SHA-tagged images
Deploy the selected release to EC2

Deployment safety

The deployment script uses:

set -e

so a failed command stops the deployment sequence.

A post-deployment health check verifies that the application is reachable through Nginx.

🔐 Security

Network exposure

Only the intended public entry points are exposed:

22   → SSH
80   → HTTP
443  → HTTPS

Application services remain bound to localhost:

127.0.0.1:4000
127.0.0.1:5173
127.0.0.1:5174

SSH

Production access uses SSH key authentication.

Configured SSH hardening includes:

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes

Secrets

Production backend secrets are stored outside Git in:

backend/.env

The production file uses restrictive permissions:

-rw-------

Do not commit .env files or private credentials.

Frontend environment variables

The Razorpay Key ID is a public client-side configuration value required by Razorpay Checkout.

The Razorpay Key Secret must never be exposed in frontend code or a VITE_* variable. It belongs on the backend/server side.

💳 Razorpay Payment Flow

Patient
   │
   ▼
Request appointment payment
   │
   ▼
Backend creates Razorpay order
   │
   ▼
Frontend receives order
   │
   ▼
Razorpay Checkout opens
   │
   ▼
Payment completed
   │
   ▼
Frontend receives payment response
   │
   ▼
Backend verifies payment
   │
   ▼
Appointment/payment state updated

The production payment flow has been tested successfully.

🌐 DNS + HTTPS

Production domain:

https://prescripto.shop/

DNS:

A      @      → EC2 public IP
CNAME  www    → prescripto.shop

HTTP traffic is redirected to HTTPS.

TLS

HTTPS is provided using Let's Encrypt and Certbot.

The certificate covers:

prescripto.shop
www.prescripto.shop

Automatic renewal is enabled through the Certbot systemd timer.

Validation commands:

sudo nginx -t
sudo certbot certificates
sudo certbot renew --dry-run

📂 Repository Structure

prescripto/
├── frontend/                 # Patient-facing React application
│   ├── src/
│   ├── public/
│   ├── Dockerfile
│   └── package.json
│
├── admin/                    # Admin React application
│   ├── src/
│   ├── public/
│   ├── Dockerfile
│   └── package.json
│
├── backend/                  # Express REST API
│   ├── config/
│   ├── controllers/
│   ├── middleware/
│   ├── models/
│   ├── routes/
│   ├── Dockerfile
│   └── package.json
│
├── .github/
│   └── workflows/
│       └── deploy.yml       # CI/CD pipeline
│
├── docker-compose.yml       # Production service definitions
├── README.md
└── .gitignore

The exact folder structure may evolve as the application grows.

🛠️ Tech Stack

Layer	Technology
Frontend	React 19, Vite, Tailwind CSS, Axios
Admin	React, Vite, Tailwind CSS
Backend	Node.js, Express.js
Database	MongoDB, Mongoose
Authentication	JWT, bcrypt
File Uploads	Multer
Media Storage	Cloudinary
Payments	Razorpay
Containers	Docker, Docker Compose
CI/CD	GitHub Actions
Registry	GitHub Container Registry
Cloud	AWS EC2
Reverse Proxy	Nginx
DNS	Hostinger DNS
TLS	Let's Encrypt / Certbot

💻 Local Development

Prerequisites

Install:

Node.js
npm
Git
MongoDB or access to a MongoDB deployment
Cloudinary account
Razorpay account if payment functionality is required

1. Clone

git clone https://github.com/Vishwak-Tech/prescripto.git
cd prescripto

2. Backend

cd backend
npm install

Create backend/.env with the variables required by the backend configuration, for example:

MONGODB_URI=
JWT_SECRET=
CLOUDINARY_CLOUD_NAME=
CLOUDINARY_API_KEY=
CLOUDINARY_API_SECRET=
RAZORPAY_KEY_ID=
RAZORPAY_KEY_SECRET=

Use the variable names expected by the current backend code. Never commit real values.

Start the backend using the project's configured development command, for example:

npm run server

3. Frontend

cd frontend
npm install

Create:

frontend/.env

Example:

VITE_BACKEND_URL=http://localhost:4000
VITE_RAZORPAY_KEY_ID=

Start:

npm run dev

4. Admin

cd admin
npm install

Create:

admin/.env

Example:

VITE_BACKEND_URL=http://localhost:4000

Start:

npm run dev

🧪 Testing

Automated testing is the next planned improvement for Prescripto.

The intended testing strategy is:

Unit Tests
    ↓
Component Tests
    ↓
API / Integration Tests
    ↓
End-to-End Tests
    ↓
CI
    ↓
Build
    ↓
Docker
    ↓
Deploy

Planned coverage

Frontend

React Testing Library
User interactions
Forms and validation
Protected UI states
Critical appointment flows

Backend

API integration tests
Authentication/authorization
Appointment endpoints
Doctor endpoints
Payment verification

End-to-End

Patient login
Doctor discovery
Appointment booking
Payment flow
Admin workflows

Deployment principle

Tests should pass before a production deployment is allowed.

📊 Production Verification

The production system has been audited after deployment.

Application

https://prescripto.shop/                    → 200 OK
https://prescripto.shop/admin/              → 200 OK
https://prescripto.shop/api/admin/dashboard → 200 OK

Containers

All three services were verified running:

Backend
Frontend
Admin

Backend logs

Verified:

Server Is Running on PORT 4000
Database Connected

Nginx

Verified:

systemctl status nginx
nginx -t

TLS

Verified:

Valid certificate
prescripto.shop
www.prescripto.shop
Automatic renewal timer enabled
Renewal dry-run completed successfully

Security

Verified:

Application ports bound to localhost
SSH key authentication
Root SSH login disabled
Password SSH authentication disabled
Backend .env protected with restrictive permissions

Resources

Current single-server deployment is intentionally lightweight.

The production audit identified:

CPU load: low
RAM: limited by the t3.micro size
Disk: monitor growth as Docker images/logs accumulate

🔁 Rollback Strategy

Every release is identified by its Git commit SHA.

Example:

Release A → 77fc010...
Release B → 2fcf70b...
Release C → 8031091...
Release D → 9f201d7...
Release E → 3b0e6bf...

If a future release causes a production issue, a verified previous SHA can be redeployed:

cd ~/prescripto
./deploy.sh <KNOWN_GOOD_COMMIT_SHA>

The deployment script then pulls the corresponding images and recreates the services.

Why SHA-based releases?

Using:

image:<commit-sha>

instead of only:

image:latest

makes releases:

Traceable
Auditable
Easier to debug
Easier to roll back

🔧 Production Troubleshooting

Check containers

docker ps

Check Compose

cd ~/prescripto
docker compose ps

Backend logs

docker compose logs --tail=50 backend

Frontend logs

docker compose logs --tail=30 frontend

Admin logs

docker compose logs --tail=30 admin

Nginx

sudo systemctl status nginx --no-pager
sudo nginx -t

Ports

sudo ss -tulpn

Memory

free -h

Disk

df -h

Load

uptime

Certificate

sudo certbot certificates

🗺️ Roadmap

Completed

🤝 Contributing

Contributions are welcome.

1. Fork the repository

2. Create a branch

git checkout -b feature/your-feature

3. Make and test your changes

4. Commit

git add .
git commit -m "feat: describe your change"

5. Push

git push origin feature/your-feature

6. Open a Pull Request

Keep pull requests focused and explain the motivation and impact of the change.

👨‍💻 Author

Vishwak Koleti

Full Stack Developer | Backend | DevOps | AI

GitHub: https://github.com/Vishwak-Tech
LinkedIn: https://www.linkedin.com/in/vishwak-koleti-tech
Production: https://prescripto.shop/

⭐ Project Highlights

Prescripto represents an end-to-end engineering workflow:

                    DEVELOPMENT
                         │
                         ▼
                       Git
                         │
                         ▼
                      GitHub
                         │
                         ▼
                 GitHub Actions
                  CI / Build
                         │
                         ▼
                       Docker
                         │
                         ▼
                       GHCR
                         │
                         ▼
                     AWS EC2
                         │
                         ▼
                       Nginx
                         │
                         ▼
                    HTTPS / TLS
                         │
                         ▼
                  prescripto.shop

Built not only to demonstrate full-stack development, but to demonstrate how a real application can be packaged, deployed, secured, automated, verified, and operated in production.

Built with ❤️ by Vishwak Koleti

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
admin		admin
backend		backend
frontend		frontend
.gitignore		.gitignore
README.md		README.md
docker-compose.yml		docker-compose.yml

Latest commit

History

Folders and files

Repository files navigation

Prescripto

📌 Overview

✨ Features

👤 Patient

👨‍⚕️ Doctor

🛡️ Admin

💳 Payments

🖼️ Media

🏗️ Architecture

Production request routing

🚀 Production Deployment

Production topology

🐳 Docker

SHA-based images

🔄 CI/CD

GitHub Actions responsibilities

Deployment safety

🔐 Security

Network exposure

SSH

Secrets

Frontend environment variables

💳 Razorpay Payment Flow

🌐 DNS + HTTPS

TLS

📂 Repository Structure

🛠️ Tech Stack

💻 Local Development

Prerequisites

1. Clone

2. Backend

3. Frontend

4. Admin

🧪 Testing

Planned coverage

Frontend

Backend

End-to-End

Deployment principle

📊 Production Verification

Application

Containers

Backend logs

Nginx

TLS

Security

Resources

🔁 Rollback Strategy

Why SHA-based releases?

🔧 Production Troubleshooting

Check containers

Check Compose

Backend logs

Frontend logs

Admin logs

Nginx

Ports

Memory

Disk

Load

Certificate

🗺️ Roadmap

Completed

Next

🤝 Contributing

1. Fork the repository

2. Create a branch

3. Make and test your changes

4. Commit

5. Push

6. Open a Pull Request

👨‍💻 Author

Vishwak Koleti

⭐ Project Highlights

About

Topics