DEV Community: wathika

Building a healthcare appointment system

wathika — Mon, 28 Jul 2025 15:01:00 +0000

🏥 HealthCare Appointment System
A full-stack clinic booking system that allows patients to schedule appointments with doctors, and enables doctors to manage their availability and appointments. Designed for small to medium-sized clinics seeking to digitize and streamline operations.

🚀 Tech Stack
Backend: Python 3.12, Django + Django REST Framework (DRF)

Database: PostgreSQL

API Testing: Postman

Version Control: Git + GitHub

Frontend: React

Deployment:

Backend: render.com

Frontend: vercel.com

👥 1. User Registration and Roles
Users can register as one of the following:

Patient

Doctor

Admin (limited to only 2 per clinic)

All newly registered users are set to inactive by default. They must be activated by an admin for security purposes.

National ID is the primary login credential and also used to uniquely identify users in the system.

Upon activation:

A PatientProfile, DoctorProfile, or AdminProfile is automatically created based on the selected role.

        {
            "email": "Margarita11@gmail.com",
            "full_name": "Ruben Hoppe Iv",
            "national_id": "858523627",
            "phone_number": "2547858523627",
            "role": "patient",
            "profile_pic": "https://shorturl.at/cA9tj",
            "doctor_profile": null,
            "patient_profile": {
                "user": 14,
                "age": 23,
                "medical_history": ""
            }
        }

🔐 2. Authentication & Access Control
JWT authentication is implemented using SimpleJWT.

The access token is valid for 1 hour, and the refresh token lasts 1 day.

The token payload includes:

email
role
exp (expiry)

You can access the user's role directly via: request.user.role

Role-based permissions:

Doctors: Can update availability, view/cancel appointments, and view all patients.

Patients: Can schedule, view, and cancel appointments. Also able to browse all doctors for booking.

Admins: Can activate/deactivate users and manage system settings.

📆 3. Appointment Booking
Patients can book appointments using a selected doctor, date (calendar input), and time (24-hour format).
The system performs several checks before confirming:

Is the doctor available?

Is the appointment time in the future?

If both are valid, an appointment is created with the status scheduled.

⚙️ 4. Doctor Availability
Doctors can toggle their availability status (True/False).

Patients can only book appointments with available doctors.

If a doctor is marked as unavailable, they will not receive new bookings.

📋 5. Appointment Management
🧑 Patient Actions:
View upcoming and past appointments.

Cancel appointments before the scheduled time.

👨‍⚕️ Doctor Actions:
View all appointments where they are assigned.

Mark appointments as completed when done.

Example appointment response:

{
  "success": true,
  "message": "",
  "data": [
    {
      "id": 1,
      "appointment_date": "2025-08-23",
      "appointment_time": "08:00:00",
      "status": "scheduled",
      "created_at": "2025-07-28T17:26:29.745662+03:00",
      "patient": 1,
      "doctor": 1
    }
  ]
}

🧑‍💼 6. Admin Controls
The system allows only one or two admins (enforced via the AdminProfile model).

Admins can:

Activate or deactivate user accounts.

Manage clinic-wide settings (e.g., appointing doctors, enforcing limits).

View system activity logs (future enhancement).

🔒 7. Security & Validation
DRF permissions restrict access based on user roles.

Key validations include:

Preventing bookings in the past.

Ensuring doctor availability before assigning appointments.

Enforcing unique constraints on National ID, email, and phone number.

📦 Links
🧑‍💻 GitHub: github.com/Boonerd/healthcare-appointment-system
Postman testing: https://www.postman.com/wathika/workspace/healthcare-system-appointment/collection/34083824-b0f81078-d6c9-4172-a254-106883c2c60b?action=share&creator=34083824

UNI NOTES PROJECT: A Collaborative Platform for Sharing School Notes

wathika — Tue, 17 Sep 2024 15:53:31 +0000

Defining the Purpose of UNI NOTES PROJECT
The UNI NOTES PROJECT is a web platform designed to help students share, view, and download school notes seamlessly. Whether you missed a class or are looking for study materials, this project makes it easy to collaborate and access notes. With features like search and commenting, it fosters a more interactive and supportive learning environment.

Team Members and Roles
This project was a solo endeavour. As the sole developer, I was responsible for everything, from design and development to deployment and maintenance. The project took roughly two months, broken into weekly sprints focused on specific features.

Who Was UNI NOTES PROJECT Created For?
This platform is aimed at students, primarily those in higher education, looking for an efficient way to exchange study materials. Teachers and educators can also use the platform to distribute supplementary notes and encourage collaboration among students.

Personal Focus and Challenges
My focus was on building a platform that was simple to use, while ensuring it could handle scalable traffic and secure data management. The engineering challenge was in balancing the load between multiple servers to ensure smooth performance, while also focusing on user interface and experience with React and Flask.

Why I Chose This Project: A Personal Story
I’ve always believed in the power of collaboration when it comes to learning. Back in high school, I wasn’t the best at taking notes. My classmates, however, excelled at this. I vividly remember how we used to share photocopies of notes to help each other study for exams. I benefited tremendously from this collaboration, and it gave me the idea to recreate a modern version of that experience through the web.

After university, I noticed the same thing: students struggled to catch up when they missed classes or needed better notes. This inspired me to create the UNI NOTES PROJECT to ensure no student feels left behind due to a lack of access to materials. This project allows students from anywhere, regardless of geography or background, to benefit from shared resources.

Summary of the Project’s Accomplishments
UNI NOTES PROJECT was successfully deployed and includes essential features for note sharing and access:

Core Features: Upload, view, and download notes.
Search Functionality: Users can search for notes based on keywords or tags.
Scalability: Load balancing with Nginx ensures smooth performance even under heavy load.
Below is the architecture diagram that illustrates how data flows through the application:

Frontend: Built with React, using Axios for API communication.
Backend: Powered by Flask, interacting with a MySQL database.
Nginx: Handles load balancing to ensure traffic is evenly distributed across multiple servers.

Key Features Completed:
User Authentication: Only authorized users can upload or download notes.
Responsive Design: The platform is mobile-friendly, allowing access from any device.
Search and Commenting: Facilitates interaction and makes it easy to find specific notes.
Most Difficult Technical Challenge
One of the biggest technical hurdles I faced was optimizing database performance as the platform scale. Here’s how I tackled it:

Situation: When the application started handling a higher volume of users, I noticed that database queries were slowing down the entire system.
Task: I needed to optimize the MySQL database to ensure efficient queries while maintaining data integrity.
Action: After researching various optimization techniques, I decided to index the most frequently queried fields (like tags and titles) and rewrite several SQL queries for efficiency. I also implemented database connection pooling to manage concurrent connections more effectively.
Result: These optimizations significantly improved query speed and reduced server response time, even under heavy load. The system now handles traffic more gracefully without slowing down or crashing.

What I’ve Learned
This project taught me a lot about building and scaling a full-stack application. Here are some key takeaways:

Technical Lessons: Proper indexing and query optimization are crucial for database performance. Also, handling load balancing with Nginx has given me insights into scaling web applications for higher traffic.
What I’d Do Differently: I would spend more time initially planning database architecture. A well-optimized database schema can save a lot of headaches later on.
Self-Discovery: I learned that I thrive under challenges that require both deep technical problem-solving and creative design. Working solo on such a comprehensive project gave me confidence in my ability to manage all aspects of development.
About Me
I’m a full-stack developer with a passion for building platforms that promote collaboration and learning. With experience in Flask, React, and MySQL, I focus on creating scalable, secure applications. You can find more of my work and connect with me through the following links:

GitHub Repository for UNI NOTES PROJECT
https://github.com/wathika-eng/classnotes

Thank you for reading about the UNI NOTES PROJECT! I look forward to hearing your thoughts and feedback.

Python phase 3 moringa revamp

wathika — Fri, 14 Jun 2024 20:02:45 +0000

What I've Learned in Four Weeks: From Python Basics to SQLAlchemy

Introduction

Over the past four weeks, I've embarked on an exciting journey to master Python programming. Starting from the basics, I gradually delved into more advanced topics, culminating in the use of SQLAlchemy for database interactions. In this blog post, I will share my learning journey, highlighting key concepts and showcasing some code samples to illustrate what I've learned.

Week 1: Getting Started with Python
My journey began with the fundamentals of Python. During this week, I focused on understanding the syntax and basic constructs of the language.

Key Concepts
Variables and Data Types: I learned about different data types such as integers, floats, strings, and booleans.
Control Structures: I explored if-else statements, for and while loops, and how to use them to control the flow of my programs.
Functions: I understood the importance of functions for code reusability and modularity.
Code Sample: Basic Python

`def greet(name):
return f"Hello, {name}!"

print(greet("World"))`

Week 2: Data Structures and Libraries
In the second week, I focused on Python's built-in data structures and some essential libraries.

Key Concepts
Lists, Tuples, and Dictionaries: I learned how to store and manipulate collections of data.
List Comprehensions: I discovered a concise way to create lists.
Libraries: I got introduced to libraries like math and datetime.
Code Sample: List Comprehensions

squares = [x**2 for x in range(10)] print(squares)

Week 3: Object-Oriented Programming (OOP)
The third week was dedicated to understanding the principles of object-oriented programming in Python.

Key Concepts
Classes and Objects: I learned how to define classes and create objects.
Inheritance: I explored how to inherit attributes and methods from other classes.
Polymorphism and Encapsulation: I understood how to design flexible and reusable code.
Code Sample: OOP in Python

`class Animal:
def init(self, name):
self.name = name

def speak(self):
    raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
def speak(self):
return f"{self.name} says Woof!"

dog = Dog("Buddy")
print(dog.speak())`

Week 4: Working with Databases using SQLAlchemy
In the final week, I delved into SQLAlchemy, a powerful ORM (Object-Relational Mapping) library for Python, which allowed me to interact with databases seamlessly.

Key Concepts
Engine and Sessions: I learned how to set up the engine and create sessions to interact with the database.
Models and Schemas: I explored how to define models and map them to database tables.
CRUD Operations: I practised performing Create, Read, Update, and Delete operations using SQLAlchemy.

Code Sample: SQLAlchemy Basics

from sqlalchemy import create_engine, Column, Integer, String from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker

Create an engine

engine = create_engine('sqlite:///example.db', echo=True)

Define a base class for declarative class definitions

Base = declarative_base()

Define a model

class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String) age = Column(Integer)

Create the table

Base.metadata.create_all(engine)

Create a new session

Session = sessionmaker(bind=engine) session = Session()

Add a new user

new_user = User(name='Alice', age=30) session.add(new_user) session.commit()

Query the database

users = session.query(User).all() for user in users: print(user.name, user.age)

Conclusion
The past four weeks have been incredibly rewarding. Starting from the basics of Python, progressing through data structures and OOP, and finally mastering SQLAlchemy has equipped me with a solid foundation for future projects. Each step has been a building block, and I am excited to continue expanding my knowledge and applying these skills to real-world applications.

If you're just starting with Python, I encourage you to take it one step at a time and enjoy the learning process. Happy coding!