Collaborative Project Management Platform

Full-stack web application for team project management with JWT authentication, role-based access, real-time dashboards, and complete CI/CD pipeline - 30,555 lines of code, 12 user stories, 7 database tables.

September 2025

~2 weeks

Project Lead & Technical Director

Java 17Spring Boot 3.4Spring SecurityJWT (jjwt)Spring Data JPAHibernateMapStructLombokAngular 20TypeScript 5.9Angular MaterialRxJSPostgreSQL 15DockerDocker ComposeNginxGitHub ActionsDocker HubJUnit 5MockitoJaCoCoKarmaJasmineSwagger/OpenAPI

Collaborative Project Management Platform

September 2025

~2 weeks

Project Lead & Technical Director

Lines of Code

30,555

Java, TypeScript, HTML, SCSS, SQL

User Stories

All implemented

API Endpoints

~55

REST endpoints (CRUD)

Database Tables

PostgreSQL with triggers & indexes

Presentation

Project definition and scope

The Collaborative Project Management Platform is a full-stack web application designed for team-based project planning, tracking, and collaboration. The platform allows teams to create projects, invite members with differentiated roles, manage tasks with priorities and statuses, and monitor progress through dashboards.

Built as a case study for Block 3 of the RNCP Level 7 title "Expert in Software Engineering" delivered by the ESIEA INTECH Group, the project covers three key competencies: Development (C.10), Automation (C.12), and Industrialization (C.13).

The application implements a complete authentication system with JWT tokens, a role-based permission model (Administrator, Member, Observer), email notifications via MailHog, and a full audit trail tracking every modification made to tasks through database triggers.

Domain

Project management, team collaboration - comparable to tools like Jira, Trello, or Asana, adapted to a professional and educational context.

Target Users

Development teams (B2B), project managers and Product Owners for progress tracking, observers (clients, stakeholders) in read-only mode.

Functional Scope

JWT Authentication (registration, login)

Project Management (CRUD, statuses)

Member Invitation by Email (tokens)

Role-Based Permissions (Admin, Member, Observer)

Task Management (priority, status, assignment)

Dashboard with Status Views

Email Notifications on Assignment

Complete Audit Trail (task history)

Global Multi-Entity Search

Architecture (3-Tier SPA)

Objectives, Context, Stakes & Risks

Strategic vision and constraints

Objectives

Develop a functional application implementing all 12 user stories defined in the specification
Achieve test coverage >= 60% in statements and branches, both frontend and backend
Dockerize the complete application (frontend, backend, database)
Set up a CI/CD pipeline automating tests and Docker image deployment to Docker Hub
Document the deployment process in a complete README

Context

The project was developed within the RNCP Level 7 certification framework, with imposed technologies: Angular (frontend), Spring Boot + Java (backend), PostgreSQL or MySQL (database), Docker, Git, and CI/CD.

The approach recommended by the course was feature-driven development, building each feature end-to-end (front + back). The project follows a fictional scenario where the developer works at Code Solutions, a software development company. The CEO (John D.) assigns the PMT project, with user stories provided by Nicolas (Product Owner) and technical guidelines by Mariana (Tech Lead).

Business Stakes

Competency Validation

Validation of competencies C.10, C.12, and C.13 of the certification block

Full-Stack Mastery

Demonstration of complete mastery from database design to Docker Hub deployment

Software Quality

Test coverage, layered architecture, API documentation (Swagger)

Identified Risks

Angular + Spring Boot Integration

Medium probability, high impact. Mitigated by layered architecture, DTOs, and proper CORS configuration.

Insufficient Test Coverage

Medium probability, high impact. Mitigated by JaCoCo (backend) and Karma/Jest (frontend) with configured thresholds.

Complex Docker Configuration

Low probability, medium impact. Mitigated by Docker Compose with healthchecks and multi-stage builds.

The Steps - What I Did

Chronological phases and personal contributions

Project Phases Timeline

Phase 1

Phase 1 - Design

Sept 12-21, 2025

Analysis of requirements and 12 user stories
Database schema design (7 tables, triggers, indexes)
Detailed conformity reports for each user story
Database diagram creation (Draw.io)

Phase 2

Phase 2 - Development

Sept 15-24, 2025

Spring Boot backend implementation (81 Java files)
Angular frontend implementation (69 TypeScript files)
Frontend-backend integration with HTTP interceptors and CORS
Complete seed data (20 users, 28 projects, 120+ tasks)

Phase 3

Phase 3 - Testing

Sept 20-24, 2025

Backend unit tests (JUnit/Mockito): 20 test files
Frontend tests (Karma/Jasmine): 11 spec files
Integration tests: SpringWebTesting, UserStory, RoleBasedPermissions
JaCoCo (backend) and Karma coverage configuration

Phase 4

Phase 4 - Industrialization

Sept 22-24, 2025

Multi-stage Dockerfiles for frontend and backend
Docker Compose configuration (dev + prod)
GitHub Actions pipeline (5 jobs)
Docker Hub configuration for image publishing

Entity-Relationship Diagram (7 tables)

Database Objects

CI/CD Pipeline (GitHub Actions - 5 jobs)

The Actors - Interactions

Team structure and collaboration dynamics

The project was carried out by Jose DA COSTA as project lead and technical director, with the assistance of Claude Code (Anthropic AI) as a development tool.

The development followed an iterative prompt-driven development approach with approximately 220 instruction-generation-validation-correction cycles. Jose provided the specifications, architectural decisions, UI/UX design choices, and performed quality assurance through manual testing in the browser. Claude Code handled code generation, test writing, DevOps configuration, and documentation.

The file `PROMPTS.md` (3,516 lines, ~220 distinct instructions) traces the complete history of this collaboration, covering all phases from design to deployment.

Team Composition

Jose DA COSTA

Project Lead & Technical Director

Project Lead & Technical Director - Specifications, architectural decisions, UI/UX design, quality assurance, manual testing

Claude Code (AI)

Development Tool

Development Tool - Code generation, tests, DevOps configuration, documentation, bug fixes

Nicolas (fictional)

Product Owner

Product Owner - Provides the 12 user stories (course scenario)

Fictional scenario

Mariana (fictional)

Tech Lead

Tech Lead - Provides technical guidelines (course scenario)

Fictional scenario

Contribution Distribution

The Results

Measurable outcomes and delivered value

User Story Completion

All 12 user stories implemented

Bonus Features (beyond requirements)

Dark mode with localStorage persistence

Global multi-entity search

Administration panel (users, settings)

User profile management

Reports and analytical views

Reusable confirmation dialog

Multiple Spring profiles (dev, local, docker, prod)

Code Metrics by Language

Backend Architecture

Frontend Architecture

Seed Data Volumes

For Me

This project reinforced my full-stack development skills across the Java/Angular stack. It was my first time combining Spring Security with JWT in a production-like setup, and implementing database triggers for automatic audit trails was a particularly valuable pattern I now apply in other projects.

The prompt-driven development approach with ~220 iterations taught me to formulate precise technical specifications and validate AI-generated code systematically - a workflow that significantly increased my productivity on subsequent projects.

For the Organization

The project demonstrates complete mastery of the software lifecycle, from database design to Docker Hub deployment. The realistic seed data (20 users, 28 projects, 120+ tasks covering all statuses and priorities) provides a convincing live demonstration.

The complete documentation (README, 12 conformity reports per user story, auto-generated Swagger, Makefile with 25+ commands) sets a professional standard for deliverable quality.

The Aftermath

Post-delivery evolution and current status

Immediately after delivery, the project was submitted as a case study for Block 3 of the RNCP Level 7 certification. The complete deliverable includes source code, Docker images on Docker Hub, 12 detailed conformity reports, and comprehensive documentation.

Current status: The project is archived as a completed case study. The source code remains available on GitHub, and Docker images can still be pulled from Docker Hub. The production domain (`pmt.codesolutions.com`) was never configured as it was part of the fictional scenario.

Lasting impact: Several architectural patterns from this project were reused in later work - particularly the database trigger approach for audit trails, the JWT authentication flow, and the Docker multi-stage build strategy. The Makefile pattern with 25+ organized commands became a template for subsequent projects.

Critical Reflection

Honest retrospective and lessons learned

What Worked Well

Functional completeness: all 12 user stories fully implemented, plus 7 bonus features
Solid architecture: clear separation of concerns (Controller/Service/Repository), centralized exception handling, HTTP interceptors
Well-designed database: automatic audit trail via triggers, partial indexes for performance, CHECK constraints for data integrity
Complete industrialization: Docker Compose for dev and prod, multi-stage builds, comprehensive Makefile, CI/CD pipeline
Realistic seed data: 20 users, 28 projects with all statuses, 120+ tasks with varied priorities - enabling a convincing demonstration

Areas for Improvement

Minimal Git history: only 3 commits, all on the same day. A more granular history with feature branches and atomic commits would better demonstrate Git mastery.
E2E tests not implemented: the CI/CD pipeline includes Playwright E2E tests, but they are disabled with placeholder echo commands.
Coverage checks disabled in CI: JaCoCo and Karma coverage thresholds exist in config but are bypassed in the pipeline.
No linting configured: the frontend lint script returns a placeholder. No ESLint or Prettier setup.
Production deployment not operational: the deploy job is disabled. No real hosting was configured.

What I Would Do Differently

Adopt a mature Git strategy with feature branches, PRs, and conventional commits to better demonstrate C.12 competency
Apply TDD (Test-Driven Development) to naturally guarantee coverage and demonstrate a more rigorous approach
Deploy on a free platform (Railway, Fly.io, Render) to make C.13 more convincing with a live demo
Add monitoring and observability (Sentry or similar) to reinforce the production-ready aspect

Lasting Lessons

Industrialization is an upfront investment that pays off: time spent on Docker, Makefile, and CI/CD is quickly recovered in reliability and reproducibility.

SQL triggers for audit trails are powerful: automatic change logging via PostgreSQL triggers is an elegant approach independent of application code.

Layered architecture facilitates testing: clean Controller/Service/Repository separation allows independent testing of each layer with mocks.

Realistic seed data is essential: rich and varied demo data makes a project presentation significantly more convincing.