Coach Platform

A software-engineered coaching platform built to demonstrate scalable backend architecture, clean software engineering practices, and end-to-end application development.

The primary goal of this project is to showcase backend software engineering rather than frontend development. The backend is designed around Clean Architecture principles with a clear separation between domain, application, infrastructure, and presentation layers, enabling maintainable, testable, and scalable code.

To demonstrate complete client-server integration, the repository also includes an Ionic mobile application that consumes the backend APIs.

---

Project Goals

This project was built to demonstrate:

• Clean Architecture and separation of concerns
• Domain-driven software design
• Scalable REST API development
• Authentication and authorization
• PostgreSQL data modeling
• Dockerized development workflow
• API documentation with Swagger
• End-to-end integration with a mobile client

---

Features

Backend

• JWT Authentication & Authorization
• Role-based access control
• Modular REST API built with NestJS
• PostgreSQL persistence using TypeORM
• Layered architecture with dependency inversion
• File upload support
• Request validation
• Swagger/OpenAPI documentation
• Dockerized local development

Mobile Client

• Ionic application consuming backend APIs
• Authentication flow
• Demonstrates real client-server communication

---

Architecture

The backend follows the principles of Clean Architecture, keeping business logic independent from frameworks and infrastructure.

                    Ionic Mobile App
                           │
                           ▼
                  REST API (Controllers)
                           │
                           ▼
                 Application Layer (Use Cases)
                           │
                           ▼
                     Domain Layer
              (Entities & Business Rules)
                           │
                           ▼
                 Repository Interfaces
                           │
                           ▼
             Infrastructure Implementations
                 (TypeORM, JWT, Storage)
                           │
                           ▼
                      PostgreSQL

The dependency flow always points toward the domain layer, allowing infrastructure components to be replaced without affecting business logic.

---

Technology Stack

Layer	Technologies
Backend	NestJS, TypeScript
Database	PostgreSQL
ORM	TypeORM
Authentication	JWT
API Documentation	Swagger
Mobile	Ionic + Angular
Containerization	Docker
Validation	class-validator

---

Repository Structure

coach-platform/

├── backend/               # NestJS backend
├── frontend-ionic/        # Ionic mobile client
├── docs/                  # Architecture & technical documentation
│
├── README.md
└── LICENSE

---

Backend Structure

backend/src/

domain/
    Entities
    Repository interfaces
    Business rules
    Adapter interfaces

application/
    Use cases
    Application services

infrastructure/
    Database
    External services
    Repository implementations

presentation/
    Controllers
    DTOs
    API layer

This separation keeps the core business logic independent from NestJS, TypeORM, and other external libraries.

---

Getting Started

Clone the repository

git clone https://github.com/yazan-orcacoder/coach-platform.git

cd coach-platform/backend

Install dependencies

npm install

Configure environment

Create the required environment variables.

cp env/local.env .env

Start the database

docker compose up -d

Run the backend

npm run start:dev

The API will be available locally.

Swagger documentation can be accessed after starting the application.

---

Documentation

Detailed documentation is available in the docs directory.

• Architecture Overview
• Entity Relationship Diagram (ERD)
• API Documentation
• Design Decisions
• Deployment Guide

---

Screenshots

The repository will include:

• Swagger API documentation
• System architecture diagram
• Entity Relationship Diagram
• Mobile application screenshots
• Database schema

---

Design Principles

This project emphasizes software engineering practices over framework-specific implementation.

Key principles include:

• Clean Architecture
• Dependency Inversion
• Separation of Concerns
• Repository Pattern
• Modular Design
• Maintainability
• Scalability
• Testability

---

Roadmap

• Complete architecture documentation
• Publish Entity Relationship Diagram
• Add sequence diagrams
• Increase automated test coverage
• CI/CD pipeline
• Kubernetes deployment
• Monitoring and observability
• Performance benchmarks

---

License

This project is licensed under the MIT License.