Delivery Process - CassiniLaw/KnowledgeBase GitHub Wiki

Project development process

Sanjel overall project process

Usually the Sprint cycle of a Sanjel project is 1 month.


sequenceDiagram
    actor Sanjel
    box Development Team
        actor Project Manager
        actor Development Team
        actor Finance
        participant Bill
    end

    box Artifact
        participant Project Plan
        participant Development Solution Artifact
        participant Development Artifact
    end

    Sanjel->> Project Manager: Issue requirements
    Project Manager->>Project Plan: Project Manager organizes requirements to determine the nature of tasks in the Project Plan

    par Next stage requirements analysis
        loop Analyze each next stage requirements
            Project Manager->> Development Team: Conduct technical evaluation based on customer requirements
            par
            Development Team->> Development Solution rtifact: Prepare various Development Solution Artifacts based on customer requirements
            Development Team-->> Project Manager: Feedback on technical feasibility and workload assessment
            end
        end

        Project Manager->> Project Plan: Develop a delivery plan based on customer requirements and feedback from the Development Team

        Project Manager->> Finance: Submit a request for financial review of the work plan
        Finance->> Project Plan: Review the work plan
        Finance-->> Project Manager : Work plan approved
        Project Plan-->> Sanjel: Submit Project Plan
        Sanjel->> Project Plan: Internal audit Project Plan
        opt
            Sanjel->> Project Plan: Modify Project Plan
        end
    and Post-audit tasks
        loop Post-audit tasks
            Project Manager->> Development Team: Assign personnel and tasks according to the Project Plan
            par
                Development Team->> Development Artifacts: Design and implement each functional point according to the requirements of the task and create necessary Development Artifacts
                Development Team-->> Project Manager: Feedback on actual workload
            end
        end

        Development Team->> Development Team: Internal acceptance
        opt Internal acceptance passed
            Development Team->> Sanjel: Release UAT environment, Sanjel acceptance
            opt Acceptance passed
                Development Team-->> Sanjel: Delivery due
            end
        end
    end

    Project Manager->> Billing: Arrange Bills (Artifact: Bills) (cycle: one month)
    Project Manager->> Finance: Submit Billing review request
    Finance->> Billing: Internal review
    Finance->> Project Manager: Notify of approval
    Project Manager-->> Sanjel: Send Bill
    Sanjel->> Finance: Payment
    Finance->> Finance: Confirm receipt

Participants

  1. Sanjel
  2. Development team
    1. Project manager
    2. Development team
    3. Finance
    4. Billing
  3. Artifacts
    1. Project plan
    2. Development solution artifacts
    3. Development artifacts

Activities

  1. Sanjel issues requirements to the project manager
  2. The project manager organizes the requirements to determine the nature of the tasks in the project plan
  3. Requirements analysis tasks for the next stage
    1. Analyze each requirement for the next stage
      1. The project manager arranges the development team to conduct technical evaluation based on customer requirements
      2. The development team works in parallel
        1. The development team prepares various development solution artifacts based on customer requirements
        2. The development team provides feedback to the project manager on technical feasibility and evaluation workload
    2. The project manager formulates a project plan based on customer requirements and feedback from the development team
    3. The project manager submits a request for project plan review to the finance department
    4. Finance reviews the work plan
    5. Finance notifies the project manager that the work plan has been reviewed and approved
    6. The project plan is submitted to Sanjel
    7. Sanjel internally reviews the project plan
    8. Sanjel modifies the project plan based on the review results
  4. Tasks after Sanjel's review
    1. For each task after review
      1. The project manager arranges the development team to allocate personnel and tasks according to the project plan
      2. The development team works in parallel
        1. The development team designs and implements each functional point according to the requirements of the task and creates the necessary development artifacts
        2. The development team feedbacks the actual workload to the project manager
        3. Internal acceptance by the development team
        4. If the internal acceptance passes
          1. The development team releases the UAT environment and Sanjel accepts
          2. If Sanjel passes the acceptance
            1. The development team delivers to Sanjel on time
        5. The project manager organizes the bill (artifact: bill) (cycle: one month)
        6. The project manager submits a bill review request to the finance department
        7. The finance department conducts an internal review of the bill
        8. The finance department notifies the project manager that the review has passed
        9. The project manager sends the bill to Sanjel
        10. Sanjel pays the finance department
        11. Financial confirmation of receipt

MetaShare internal development process - requirement analysis and solution evaluation stage


sequenceDiagram
    actor Project Manager
    box Development Team
        actor Business Analyst
        actor Architect
        actor Programmer
        participant Project Plan
    end

    box Development Solution Artifact
        participant Architectural Prototype
        participant Solution Sepcification
        participant Business Model
        participant Use Case Specification
        participant Statechart Diagram
        participant Test Case
        participant Test Data
    end

    Project Manager ->> Project Plan: evaluate with the Development Team
    note right of Project Manager: create a ticket for this task in MetaShareAnalysis and assign it to team members
    par Architecture-level solution
        opt if a new Architecture is required
            Project Manager->> Architect: determine the Architecture-level solution
            note right of Architect: the Architect creates a ticket as a subtask
            Architect->> Architectural Prototype : 
            Architect->> Solution Sepcification : 
            note right of Architect: the Architect sets the ticket to InReview state

            Architectural Prototype -->> Project Manager :   
            Solution Sepcification -->> Project Manager :  
            Architect->> Programmer: Clarify technical implementation plan
            Architect->> Project Plan: Determine cycle, Architecture-level task content, priority
        end
    and Requirements analysis
        Project Manager->> Business Analyst: Get requirements and organize and split
        Note right of Business Analyst: Business Analyst creates Ticket as a subtask
        Business Analyst->> Business Model : 
        Business Analyst->> Use Case Specification : 
        Business Analyst->> Statechart Diagram : 
        Business Analyst->> Test Case : 
        Business Analyst->> Test Data : 
        Note right of Business Analyst : Business Analyst sets Ticket to InReview state

        Business Model -->> Project Manager : 
        Use Case Specification -->> Project Manager : 
        Statechart Diagram -->> Project Manager : 
        Test Case -->> Project Manager : 
        Test Data -->> Project Manager : 

        Business Analyst->> Programmer : Team understands requirements
        Programmer -->> Project Manager : Evaluate workload
        Project Manager ->> Project Plan : Determine the task content and workload of the Project Plan
    end

    Project Manager ->> Project Plan : Determine the cycle, task content, priority, and workload of the Project Plan
    Note right of Project Manager : Check all subtasks of the task ticket and set the ticket to Reviewed status

Participants

  1. Project manager
  2. Development team
    1. Business analysis
    2. Architect
    3. Programmer
    4. Project plan
  3. Development solution artifacts
    1. Architecture prototype
    2. Solution description
    3. Business model
    4. Use case description
    5. State diagram
    6. Test case
    7. Test data

Activities

  1. The project manager and the development team jointly evaluate the project plan. The project manager creates a ticket for the task in MetaShareAnalysis and assigns it to team members
  2. For architecture-level solutions
    1. If a new architecture is required
      1. The project manager and the architect determine the architecture-level solution, and the architect creates a ticket as a subtask
      2. The architect creates an architecture prototype
      3. The architect creates a solution description and sets the Ticket to the InReview state
      4. The architect submits the architecture prototype
      5. The architect submits the solution description
      6. The architect clarifies the technical implementation plan to the programmer
      7. The architect and the project manager jointly improve the project plan, determine the cycle, architecture-level task content, and priority
  3. Requirements analysis
    1. The project manager and the business analyst confirm the acquisition of requirements and organize and split them, and the business analyst creates a Ticket as a subtask
    2. The business analyst creates a business model
    3. The business analyst creates a use case description
    4. The business analyst creates a state diagram
    5. The business analyst creates a test case
    6. The business analyst creates test data and sets the Ticket to the InReview state
    7. The business analyst submits the business model
    8. The business analyst submits a use case description
    9. The business analyst submits a state diagram
    10. The business analyst submits a test case
    11. The business analyst submits test data
    12. Business analysis submits demand-related artifacts to the development team and assists the team in understanding the demand
    13. The development team and the project manager jointly evaluate the workload
    14. The development team and the project manager jointly improve the project plan and determine the task content and workload of the project plan
  4. The project manager improves the project plan and determines the cycle, task content, priority, and workload of the project plan. The project manager checks all subtasks of the task ticket and sets the ticket to the Reviewed state

MetaShare internal development process - design implementation and test release stage


sequenceDiagram
    participant Project Plan
    actor Project Manager

    box Development Team
        actor Business Analyst
        actor Architect
        actor Programmer
        participant Development Solution Artifact
    end

    box Development Artifact
        participant Principles and Practices
        participant Use Case Specification
        participant Source Code
        participant Internal Test Results
        participant System Documentation
    end

    Project Plan-->> Project Manager: Execute Project Plan
    Note right of Project Plan: Select Ticket in Backlog as Parent Task
    Note right of Project Plan: Create Tickets as Child Tasks in the following analysis and design activities and put them in Planning
    Note right of Project Plan: Move Ticket in Planning to Todo according to priority and personnel situation
    Note right of Project Plan: Select Ticket in Todo for execution

    Project Manager->> Architect: Determine architecture implementation tasks with architect

    loop Every architecture-level task
        Development Solution Artifact-->> Architect: Review, especially architecture-level use case implementation solution
        Project Manager-->> Project Plan: Arrange architecture-level implementation tasks
        Note right of Project Plan: Adjust the priority of the corresponding implementation task ticket to High
        Note right of Project Plan: Create a Business Analyst task ticket and adjust the priority to High
        Note right of Project Plan: Create an architect task ticket and adjust the priority to High
    end

    loop Complete the tasks in the ticket in order of priority
        par Business Analyst Task
            Project Manager->> Business Analyst: Business Analyst Task
            Note right of Business Analyst: Business Analyst Task Ticket becomes InProgress
            Business Analyst->> Development Solution Artifact: Review
            Business Analyst->> Use Case Specification: Refine the use case and improve the Use Case Specification
            Business Analyst-->> Project Manager: Feedback on the actual workload
            Note right of Project Manager: Business Analyst Task Ticket becomes InReview
        and Architecture-level Task
            Use Case Specification->> Architect: Reference
            Note right of Architect: Architect task Ticket becomes InProgress
            Architect->> Architect: Implementation of architecture-level tasks
            Architect->> Principles and Practices: Summarize implementation patterns and analyze use cases
            Architect->> System Documentation: Improve relevant System Documentation
            Architect-->> Project Manager: Feedback on actual workload
            Note right of Project Manager: Architect task Ticket becomes InReview
        and Implementation tasks
            Use Case Specification -->> Programmer: Reference
            Note right of Programmer: Implementation task Ticket becomes InProgress
            Development Solution Artifacts -->> Programmer: Reference business model and use case description
            Principles and Practices -->> Programmer: Reference

            opt Tasks are not decomposed or are too large
                Architect->> Programmer: Guide through training, pairing, design or code review
                Architect->> Programmer: Determine implementation pattern
                Architect->> Programmer: Task decomposition
                Note right of Architect: Create a Ticket as a Child Task in Planning according to the implementation mode of the use case
            end

            Programmer->> Source Code: Implement the use case according to the business model and use case description
            Programmer->> Source Code: Use test data to run all test cases for the use case
            Programmer->> Internal Test Results: Submit Internal Test Results
            Programmer->> System Documents: Improve relevant system documents
            Programmer-->> Project Manager: Feedback on actual workload
            Note right of Project Manager: Change the implementation task Ticket to InReview
        end

        Project Manager -->> Project Plan: Revise the Project Plan and record the actual workload
        Note left of Project Manager: Check all subtasks of the task Ticket and set the Ticket to Reviewed status
    end

Participants

  1. Project plan
  2. Project manager
  3. Development team
    1. Business analysis
    2. Architect
    3. Programmer
    4. Development solution artifacts
  4. Development artifacts
    1. Design implementation principles and practices
    2. Use case analysis documents
    3. System source code
    4. Internal test results
    5. System documentation

Activities

  1. The project manager executes the project plan and creates Tickets according to the following principles
    1. Select the Ticket in the Backlog as the Parent Task
    2. Create Tickets as Child Tasks in the following analysis and design activities and put them in Planning
    3. Move the Ticket in Planning to Todo according to priority and personnel situation
    4. Select the Ticket in Todo to execute
  2. The project manager and the architect determine the architecture implementation tasks
  3. For each architecture-level task
    1. The architect reviews the development solution artifacts
    2. The project manager revises the project plan, arranges the architecture-level implementation tasks, and creates and adjusts the priority of Tickets according to the following principles
      1. Adjust the priority of the Ticket for the corresponding implementation task to High
      2. Create a business analysis task Ticket and adjust the priority to High
      3. Create an architect task Ticket and adjust the priority to High
  4. Complete the tasks in the Ticket in order of priority
    1. Business analysis tasks
      1. The project manager arranges the business analysis task, and the business analysis task Ticket becomes InProgress
      2. Business analysis reviews the development solution artifacts
      3. Business analysis refines the use case and improves the use case analysis document
      4. Business analysis feedbacks the actual workload to the project manager, and the business analysis task Ticket becomes InReview
    2. Architecture-level tasks
      1. After the business analysis completes the relevant use case analysis documents, the architect refers to the use case analysis documents, and the architect task Ticket becomes InProgress
      2. The architect completes the implementation of the architecture-level tasks
      3. The architect summarizes the implementation mode and analyzes the use case, and creates or improves the principles and practices of design implementation
      4. The architect completes the relevant system documents
      5. The architect gives feedback to the project manager on the actual workload, and the architect's task ticket changes to InReview
    3. Implement the task
      1. After the business analysis completes the relevant use case analysis documents, the programmer refers to the use case analysis documents, and the implementation task ticket changes to InProgress
      2. The programmer refers to the development solution artifacts provided by the business analysis, mainly the business model and use case description
      3. The programmer refers to the design implementation principles and practices provided by the architect
      4. If the task is not decomposed or the task is too large, the architect needs to help the programmer complete the following tasks
        1. The architect guides the programmer through training, pairing, design or code review
        2. The architect helps the programmer determine the implementation mode
        3. The architect helps the programmer complete the task decomposition, and creates a ticket as a Child Task in Planning according to the implementation mode of the use case
      5. The programmer implements the system source code related to the use case function according to the business model and use case description
      6. The programmer uses the test data to run all test cases on the use case to ensure the quality of the submitted system source code
      7. The programmer submits the internal test results
      8. The programmer completes the relevant system documents
      9. The programmer reports the actual workload to the project manager, and the task ticket is changed to InReview
  5. The project manager revises the project plan, records the actual workload, checks all subtasks of the task ticket, and sets the ticket to Reviewed status