Skip to main content

​
About SGJM Team

SGJM Team is a dedicated software engineering team working on the Job Manager Subsystem of the DEVision platform as part of the EEET2582/ISYS3461 course at RMIT University.

​
Team Name Origin

Saint Giong (Thánh Gióng) is one of the four immortal heroes in Vietnamese folklore, symbolizing:
  • Strength and determination in overcoming challenges
  • Strategic thinking and problem-solving
  • Protection and support for the community
These values guide our approach to software development and team collaboration.

​
Team Members

Vo Hoang Phuc

Project Manager & Frontend LeaderStudent ID: S3926761
  • Leads frontend development team
  • Frontend architectural design and practices
  • UI/UX design and implementation
  • Frontend-backend integration
  • SGJA Coordinator - Liaison with Job Applicant team

Nguyen Dinh Viet

Backend LeaderStudent ID: S3927291
  • Leads backend development team
  • Backend architectural design and practices
  • Microservices infrastructure and implementation
  • System deployment
  • Backend-frontend integration

Nguyen Son Tung

Backend Developer & SGJA CoordinatorStudent ID: S3979348
  • Backend architectural design and practices
  • Microservices implementation
  • System deployment
  • Backend-frontend integration
  • SGJA Coordinator - Liaison with Job Applicant team

Nguyen The Bao Ngoc

Backend DeveloperStudent ID: S3924436
  • Backend architectural design and practices
  • Microservices implementation
  • System deployment
  • Backend-frontend integration

Nguyen Le Thuc Quynh

Frontend Developer & Meeting Note TakerStudent ID: S3924993
  • Frontend architectural design and practices
  • UI/UX design and implementation
  • Frontend-backend integration
  • Meeting Note Taker - Official meeting minutes recorder

​
Team Structure

​
Frontend Team

Vo Hoang Phuc

Frontend Leader
  • Architectural design and practices
  • UI/UX design and implementation
  • Frontend-backend integration coordination

Nguyen Le Thuc Quynh

Frontend Developer
  • Architectural design and practices
  • UI/UX design and implementation
  • Frontend-backend integration

​
Backend Team

Nguyen Dinh Viet

Backend Leader
  • Architectural design and practices
  • Microservices infrastructure
  • Deployment and integration

Nguyen Son Tung

Backend Developer
  • Architectural design and practices
  • Microservices implementation
  • Deployment and integration

Nguyen The Bao Ngoc

Backend Developer
  • Architectural design and practices
  • Microservices implementation
  • Deployment and integration

​
Stakeholders

Internal Stakeholders:
  • Dr. Tri Huynh (Course Lecturer)
  • SaintGiong Squad (Job Manager and Job Applicant teams)
External Stakeholders:
  • Job Applicants (end users)
  • Company Recruiters (end users)
  • Service Providers (Stripe, PayPal, etc.)

​
Team Roles & Coordination

​
Leadership Roles

Frontend Leader

Phuc VoAssigns tasks for FE team and coordinates frontend development

Backend Leader

Viet NguyenAssigns tasks for BE team and coordinates backend development

Meeting Note Taker

Quynh NguyenOfficial recorder of all meeting minutes and documentation

​
SGJA Coordination

SGJM ↔ SGJA IntegrationTeam SGJM (Job Manager) collaborates closely with Team SGJA (Job Applicant) within the Saint Giong Squad to ensure seamless system integration.
Coordinators:
  • Phuc Vo - Primary liaison with SGJA team
  • Tung Nguyen - Secondary liaison with SGJA team
Coordination Responsibilities:
  • API integration planning and execution
  • Cross-system data flow design
  • Kafka messaging coordination
  • Joint testing and deployment
  • Shared Payment Service development
Communication Channels:
  • Regular sync meetings with SGJA team
  • Shared documentation and specifications
  • Joint sprint reviews
  • Collaborative problem-solving

​
Team Responsibilities

Our team is responsible for the complete development lifecycle of the Job Manager subsystem:

​
Development Tasks

​
Frontend Team Responsibilities

Frontend Architecture

Design and implement frontend architectural patterns and practices

UX/UI Design

Design user interfaces for all features and maintain design consistency

Frontend Implementation

Implement React-based user interfaces and components

Backend Integration

Integrate frontend with backend APIs and services

​
Backend Team Responsibilities

Backend Architecture

Design and implement microservices architecture and practices

Data Model Design

Design and implement the conceptual ER model and database schema

Backend Implementation

Develop APIs, business logic, and microservices

Deployment

Handle system deployment, scaling, and infrastructure management

Frontend Integration

Provide APIs and support frontend integration needs

​
Shared Responsibilities

Technical Documentation

Maintain comprehensive documentation for the entire system

Code Quality

Ensure code quality, testing, and adherence to best practices

​
Integration Responsibilities

  • Provide APIs to Job Applicant subsystem
  • Consume APIs from Job Applicant subsystem
  • Develop shared Payment Service
  • Ensure seamless system integration

​
Development Methodology

​
Agile Approach

We follow an iterative development methodology based on SCRUM principles:
1

Sprint Planning

Define tasks and goals for the upcoming sprint
2

Daily Development

Individual and pair programming on assigned tasks
3

Sprint Review

Bi-weekly meetings with the lecturer to demonstrate progress
4

Retrospective

Reflect on lessons learned and identify improvements

​
Regular Meeting Schedules

Daily Standup

Time: 10:00 AMFrequency: Every weekdayDuration: 15 minutesPlatform: Discord

Sprint Planning

Time: 10:00 AM SaturdayFrequency: First week of current sprintDuration: 1 hourPlatform: Microsoft Teams

Sprint Review & Retrospective

Time: 10:00 AM SaturdayFrequency: Last week of current sprintDuration: VariablePlatform: Microsoft Teams

​
Team Working Hours

Frontend Team

Hours: 9:00 AM - 10:00 PMActive working hours for frontend development and collaboration

Backend Team

Hours: 9:00 AM - 10:00 PMActive working hours for backend development and collaboration

​
Project Management

Estimation System: 1 point = 1 hour of workTeam Capacity: 12 hours/person/week × 5 members = 60 hours/week ≈ 60 estimation points per sprint
Estimation Scale:
  • 1 point ~ 1 hour
  • 21 points ~ 21 hours (maximum task size before breaking down)

​
Project Management Tools

We utilize digital project management tools to track all tasks:
  • Task Board: Tuturuuu - Kanban board for task tracking and sprint management
  • Version Control: GitHub for all deliverables
  • Team Drive: SharePoint - Shared document storage for meeting minutes, reports, and diagrams
  • Communication:
    • Text: Facebook Messenger
    • Voice: Discord Server
    • Hours: 9:00 AM - 10:00 PM
  • Documentation: Mintlify for comprehensive docs

​
Communication Standards

General Messages:
  • Respond or react to confirm you’ve read the message
Mentions/Direct Messages:
  • Provide substantive reply within 12 hours
Required Attendance:
  • Daily Standup: Every weekday at 10:00 AM
  • Sprint Planning: Mandatory, first Saturday of sprint
  • Sprint Review & Retrospective: Mandatory, last Saturday of sprint
  • Team Meetings: 2 per week (1 online, 1 offline with meeting minutes) Advance Notice:
    • Provide 24-hour advance notice for absences
    • Submit valid justification and supporting evidence
    • Unexcused absences result in teamwork assessment penalties
GitHub Workflow:
  • Commits: Regular commits and pushes required
  • Branching: Use Conventional Branch naming (type/[ID]-task-description)
  • Pull Requests: Require 2 approvals before merging
  • Commits: Follow Conventional Commits specification
PR Format:
Title: [ID] Description

Description:
- What? (changes made)
- Why? (reason for changes)
- How? (implementation approach)
- Screenshots (required for UI changes, tested locally)
Note: Backend PRs must include unit tests

​
Contribution Requirements

Every team member must contribute to ALL required tasks with recognizable deliverables or substantial feedback.

​
Required Contributions

All team members must contribute to:
  1. Data Model Design - ER diagrams and database schema
  2. System Architecture - Architecture diagrams and design decisions
  3. UX/UI Design - Interface design for ALL requirements
  4. Technical Report - Documentation and justifications
  5. Development - Frontend, Backend, or Full Stack

​
Development Contribution

Each member must contribute through:
  • Individual programming
  • Pair programming
  • Code reviews
  • Technical documentation
Fair contribution is determined by: - Complexity of supported features - Average workload of the entire team - Quality of deliverables

​
Teamwork Standards

​
Communication Standards

  • Professional language in all communications
  • Regular updates on task progress
  • Proactive identification of blockers
  • Transparent collaboration

​
Review Cycle

Bi-weekly Meetings with the lecturer to:
  • Present recent progress
  • Discuss lessons learned and experiences
  • Identify project impediments or risks
  • Get feedback and guidance

​
Attendance Policy

Punctuality and presence at scheduled meetings are mandatory.
Requirements:
  • Attend all scheduled sprint reviews
  • Provide 24-hour advance notice for absences
  • Submit valid justification and supporting evidence
  • Unexcused absences result in teamwork assessment penalties

​
GitHub Usage Policy

​
Repository Management

Push primitive, partially completed, or finalized deliverables regularly
Use appropriate commit messages and pull request descriptions
Use feature branches and pull requests for code review
Keep README and docs up-to-date with code changes

​
Penalties

  • Not using GitHub frequently: Up to 10 points penalty
  • Missing GitHub contribution proof: 3 points penalty
  • Missing repository zip file: 3 points penalty
  • Missing Project Charter: 3 points penalty

​
Quality Assurance

​
Code Quality

All code must meet these standards:
  • Follows architectural patterns (N-Tier, Modular Monolith, or Microservices)
  • Includes proper error handling
  • Has appropriate validation (frontend and backend)
  • Follows security best practices
  • Is well-documented with comments

​
Security Requirements

Never introduce security vulnerabilities such as: - Command injection - XSS (Cross-Site Scripting) - SQL injection - Other OWASP Top 10 vulnerabilities

​
Code Review Process

  1. Create feature branch from main
  2. Implement feature with proper testing
  3. Submit pull request with description
  4. Team reviews code for quality and security
  5. Address feedback and make improvements
  6. Merge after approval

​
Performance Evaluation

​
Assessment Criteria

Performance is evaluated on three dimensions:

Development Contribution

Code quality and feature implementation

Management Adherence

Board updates and task tracking

Active Involvement

Participation in meetings and discussions

​
Grade Distribution

Final contribution assessment and weight distribution will be determined by the course coordinator based on:
  • Quality and quantity of contributions
  • Adherence to methodological requirements
  • Team collaboration and communication
  • Meeting attendance and participation

​
Escalation Process

If team members are not completing allocated tasks, inform the Course Coordinator immediately to enable early intervention.
Early communication helps prevent problems from escalating and ensures project success.

​
Resources