Unit 4 Project Planning,

Management And
Estimation:

Created by: Priti Dhimmar

Project Planning in Software
Engineering
• Project planning in software engineering is a critical phase that
ensures a software project is well-organized, efficient, and
successfully completed within scope, time, and budget. It involves
defining the objectives, scope, resources, and tasks required for
software development.
• 1. Project Initiation
• Project initiation is the first phase of project planning, where the
project idea is evaluated, and key decisions are made to determine its
feasibility.
Key Activities in Project
Initiation:
• Define Project Objectives: Establish what the project aims to achieve.
• Identify Stakeholders: Determine who will be affected by the project
(customers, developers, testers, management, etc.).
• Conduct Feasibility Study: Analyze technical, economic, legal, and
operational feasibility.(successfully accomplished)
• Develop Business Case: Justify the project in terms of benefits and
costs.
• Create Project Charter: A document that formally authorizes the
project, defining high-level requirements and constraints.
2. Planning Scope Management
• Scope management involves defining what is included in the project and
ensuring that only necessary tasks are performed.
• Key Aspects of Scope Management:
• Scope Definition: Clearly describe the software product, its features, and
functionalities.
• Requirements Gathering: Collect and document user and system requirements.
• Scope Validation: Get approval from stakeholders to ensure alignment with
business needs.(project is moving in the right direction and meets stakeholder expectations
before proceeding further.)
• Scope Control: Monitor and manage changes to prevent scope creep
(unauthorized expansion of project scope=> approve changes).
Creating the Work Breakdown
Structure (WBS)
• The Work Breakdown Structure (WBS) is a hierarchical decomposition of the
project into smaller, manageable tasks.
• Ex: Construction of a House-foundation, framing, roofing, plumbing, electrical,
colour, final finishing.
• Steps to Create WBS:
• Identify Major Deliverables: Break down the software system into major
components (e.g., UI, backend, database).
• Decompose into Subtasks: Divide each component into smaller tasks (e.g., UI
→ Login Page, Dashboard, Reports).
• Assign Responsibilities: Allocate tasks to development teams.
• Define Milestones: Establish checkpoints for tracking progress.
• Benefits of WBS:
• Improves project visibility and tracking.
• Helps in resource allocation and time estimation.
• Enhances communication among team members.
• Reduces project risks by ensuring no task is overlooked.
Scheduling in Software Engineering
• Project scheduling is a critical aspect of software engineering that
ensures tasks are completed in a structured manner within the
specified time frame. It involves defining task sequences, setting
deadlines, and allocating resources efficiently.( Req analysis, system
design, development phase, testing and debugging, deployment and
maintanance)
• 1. Importance of Project Schedules
• A project schedule helps teams stay on track, ensuring timely
software delivery while optimizing resource utilization.
Key Reasons Why Project
Scheduling is Important:
• Time Management: Ensures that the project is completed on time by
defining deadlines for each task.
• Resource Optimization: Assigns team members efficiently to avoid workload
imbalance.
• Improved Communication: Provides clear timelines and expectations for all
stakeholders.
• Cost Control: Helps in budgeting by estimating time-based costs.
• Risk Mitigation: Identifies potential delays early and allows corrective action.
• Performance Tracking: Helps measure project progress and make necessary
adjustments.
2.Developing the Project Schedule
• To create a project schedule, software engineering teams follow these steps:
• Steps to Develop a Schedule:
• Identify Tasks – List all project activities based on the Work Breakdown
Structure (WBS).
•Requirement Gathering
•UI/UX Design
•Backend Development
•Frontend Development
•API Integration
•Testing
•Deployment
• Define Dependencies – Establish task relationships (which task must be
completed before another starts).
• Backend Development should be completed before API Integration.
• Estimate Time Duration – Approximate the time required for each task.
• Requirement Gathering (1 week)
•UI/UX Design (2 weeks)
•Backend Development (4 weeks)
•Frontend Development (3 weeks)
•API Integration (2 weeks)
•Testing (3 weeks)
•Deployment (1 week)
• Allocate Resources – Assign team members, tools, and budgets.
• Develop the Timeline – Use scheduling techniques like Gantt Charts,
PERT, and CPM.
• Use Gantt Chart to visualize task duration and dependencies.
• Use Critical Path Method (CPM) to find the longest sequence of
dependent tasks.
• Monitor and Adjust – Track progress and update schedules as
needed.(Adjust schedules if any delays occur.)
3. Scheduling Techniques
• A. Gantt Charts
• A Gantt Chart is a visual timeline that shows tasks, their duration, and
dependencies.
• Features of Gantt Charts:
• Horizontal bars represent tasks, with their length indicating duration.
• Arrows or links show dependencies between tasks.
• Milestones highlight important deadlines.
 Example of a Gantt Chart:

Task Start Date Duration End Date Dependencies

Requirement Analysis Jan 1 10 days Jan 10 None

Design Phase Jan 11 15 days Jan 25 Requirement Analysis

Development Jan 26 30 days Feb 25 Design Phase

Testing Feb 26 20 days Mar 17 Development

Gant chart diagrams:
Advantages of Gantt Charts:

• ✔ Easy to understand and visually track progress.

✔ Helps identify overlapping tasks and dependencies.
✔ Useful for small to medium-sized projects.
B. PERT (Program Evaluation and
Review Technique)
• PERT is a statistical technique used for project scheduling that helps in analyzing
task durations and uncertainties.(taking time to completion)
• Characteristics of PERT:
• Uses a network diagram with nodes (tasks) and arrows (dependencies).
• Calculates expected task durations based on:or Using the PERT Formula:
•Optimistic Time (O): The shortest possible duration
•Most Likely Time (M): The expected duration
•Pessimistic Time (P): The longest possible duration
• Expected Time (TE) = (O+ 4 M + P) ÷ 6
• Identifies the Critical Path (longest sequence of dependent tasks) to determine
project duration.
Advantages of PERT:

• ✔ Useful for projects with uncertain task durations.

✔ Helps in better risk assessment and timeline estimation.
• C. CPM (Critical Path Method)
• CPM is a deterministic scheduling technique used to find the longest
sequence of dependent tasks (Critical Path) that determines the
shortest time to complete the project.
Steps in CPM:

• Identify all tasks and dependencies.

• Estimate task durations.
• Draw the CPM Network Diagram (a flowchart-like structure).
• Determine the Critical Path (tasks with zero slack).
• Monitor and adjust the schedule.
Advantages of CPM:

• ✔ Helps prioritize critical tasks to prevent project delays.

✔ Provides accurate project time estimation.
✔ Suitable for projects with well-defined activities.
Project Management in Software
Engineering
• Software project management involves planning, organizing, and
overseeing the development of a software product to ensure
successful completion within time, cost, and quality constraints. It
includes managing people, products, processes, and projects
efficiently.
• 1. The Management Spectrum
• The Management Spectrum in software project
management consists of four key areas:
1.People – The individuals who execute the project.
2.Product – The software being developed.
3.Process – The methodology used to build the software.
(waterfall model, Agile methodology etc)
4.Project – The overall effort required to complete the
software.(person-hours, person-days, or person-months)
• Each of these aspects plays a crucial role in ensuring
project success.
2. People Management

• People are the most important asset in software development. Effective

management of team members ensures productivity and collaboration.
• Key Aspects of People Management:
• Stakeholders: Customers, developers, testers, and management.
• Roles and Responsibilities: Clear role definitions for project managers,
developers, testers, etc.
• Team Motivation: Encouraging creativity, teamwork, and personal growth.
• Communication: Clear and open channels between stakeholders.
• Conflict Resolution: Managing differences to maintain a productive
environment.
3. Product Management

• The product is the software being developed. Managing the product

effectively ensures it meets customer requirements and quality standards.
• Key Aspects of Product Management:
• Product Scope: Clearly defining software requirements and functionality.
• User Requirements: Gathering customer needs and expectations.
• Technology Selection: Choosing the right frameworks, tools, and
platforms.
• Quality Assurance: Ensuring the software meets quality and security
standards.
4. Process Management

• The process defines the framework used for software development. It

includes methodologies and best practices to ensure a structured
approach.
• Common Software Development Processes:
• Waterfall Model: Sequential development process.
• Agile Methodology: Iterative and flexible approach.
• Scrum & Kanban: Agile frameworks for task management.
• DevOps: Integrating development and operations for continuous
delivery.
• Importance of Process Management:
• ✔ Ensures consistency and predictability.
✔ Improves efficiency and reduces errors.
✔ Helps in tracking progress and making adjustments.
5. Project Management
• Project management involves planning, scheduling, tracking, and
controlling all project activities.
• Key Aspects of Project Management:
• Project Planning: Defining goals, scope, and milestones.
• Resource Allocation: Assigning team members and tools.
• Risk Management: Identifying and mitigating potential risks.
• Progress Monitoring: Tracking deliverables and making necessary
adjustments.
6. The W5HH Principle

• The W5HH (What, Why, When, Who, Where, and How will, How
much) Principle is a project management guideline that helps in
planning and executing a project effectively.
• Key Questions in W5HH:
• What needs to be done? – Define project goals and tasks.
• Why is it being done? – Justify business needs and benefits.
• When will it be accomplished? – Set deadlines and timelines.
• Who is responsible? – Assign roles and responsibilities.
• Where will it be done? – Define the development environment.
• How will it be done? – Outline the process, methodology, and tools.
• The W5HH principle ensures a structured and organized approach to
software project management.
7. Metrics in the Process and Project
Domains
• Metrics help in measuring and improving software development
processes and project management efficiency.
• Types of Metrics:
• Process Metrics:
• Measures the efficiency of the development process.
• Examples:
• Defect Density: Number of defects per module.
• Cycle Time: Time taken to complete one development iteration.
• Process Compliance: Adherence to project guidelines.
 Project Metrics:

•Measures project progress, cost, and performance.

•Examples:
•Effort Variance: Difference between estimated and actual effort.
•Schedule Variance: Difference between planned and actual schedule.
•Cost Performance Index (CPI): Measures project cost efficiency.
Software Measurement in Software
Engineering
• Software measurement is the process of quantifying software
attributes to evaluate software quality, productivity, and project
progress. It helps in planning, tracking, and improving software
development processes.
• 1. Size-Oriented and Function-Oriented Metrics
• Software metrics can be classified into two major types:
• A. Size-Oriented Metrics
• Size-oriented metrics measure the software based on the physical size
of the code. The most common metric used in this category is Lines of
Code (LOC).
• Lines of Code (LOC)
• Measures the total number of lines in the source code.
• Includes only executable statements, excluding comments and blank
lines.
• Used to estimate effort, cost, and productivity.
• Limitations of LOC:
• ❌ Does not account for code complexity.
❌ Different programming languages have different LOC counts for the
same functionality.
❌ Encourages writing more code instead of optimizing solutions.
B. Function-Oriented Metrics

• Function-oriented metrics focus on measuring software based on the

functionality it provides rather than the amount of code written. The
most common metric in this category is Function Points (FP).
• Function Points (FP)
• Measures software size based on the number of functional
components (inputs, outputs, user interactions, etc.).
• Provides a language-independent measurement.
• Calculated using complexity-weighted factors.
• Function Point Calculation:
• The FP metric is computed based on five functional elements:

Component Simple Average Complex

External Inputs 3 4 6

External Outputs 4 5 7

External Inquiries 3 4 6

External Files 7 10 15

External Interfaces 5 7 10
• Total Unadjusted Function Points (UFP) = Sum of all components.
• Then, the Final Function Point (FP) is adjusted using environmental
factors such as complexity, performance, security, etc.
• Advantages of Function Points:
• ✔ Language-independent.
✔ Better reflects software complexity.
✔ Useful for early project estimation.
• Limitations of Function Points:
• ❌ Requires expert judgment to classify functionalities.
❌ More complex to calculate compared to LOC.
2. Metrics for Project Management
• Project metrics help in tracking and improving project performance,
resource utilization, and efficiency.
• Common Project Metrics:
• Effort Estimation (Person-Months):
• Estimated time required to complete a project based on team size.
• Formula:
• Effort (Person-Months)=Function points(FP)/Productivity Rate(FP per
person-month)
• Schedule Variance (SV):
• Measures the difference between planned and actual progress.
• formula:
• SV=Earned value-planned value
• SV > 0 → Ahead of schedule, SV < 0 → Behind schedule.
Cost Performance Index (CPI):
• Indicates cost efficiency of the project.
• Formula:
• CPI = Earned Value(EV)/Actual Cost(AC)
• CPI > 1 → Under budget, CPI < 1 → Over budget.
• Defect Density:
• Measures the number of defects per size unit (LOC or FP).
• Formula:Defect Density=Total Defects/size of Software(LOC or FP)
•
• CPI > 1 → Under budget, CPI < 1 → Over budget.
Defect Density:
• Measures the number of defects per size unit (LOC or FP).
• Formula:
• Defect Density=Total Defects/ Size of Software(LOC or FP)
• Helps in assessing software quality.
Productivity Measurement:
• Measures team efficiency based on delivered work.
• Formula:
• Productivity= Function Points (FP) or LOC/Effort(person-
Months)
• Higher productivity indicates better efficiency.
Project Estimation in Software
Engineering
• Software project estimation involves predicting the effort, time, and
cost required to develop a software product. Accurate estimation
helps in resource allocation, budgeting, and project scheduling.
• 1. Software Project Estimation
• Software project estimation is the process of forecasting the time,
effort, resources, and cost needed to complete a project.
Key Factors Affecting
Estimation:
• Project Scope: Clearly defined objectives and requirements.
• Team Expertise: Experience of developers and project managers.
• Technology Stack: Complexity of programming languages,
frameworks, and tools.
• Project Constraints: Budget, deadlines, and available resources.
• External Factors: Market conditions, client expectations, and
regulatory requirements.
• Types of Software Estimates:
• Effort Estimation: Predicts work required (in person-months).
• Cost Estimation: Forecasts total project budget.
• Schedule Estimation: Determines project timeline and milestones.
2. Decomposition Techniques for
Estimation
• Decomposition techniques break down the project into smaller
components to estimate effort and cost more accurately.
• A. Function-Oriented Decomposition
• Divides the project based on functional modules (e.g., Login, Payment
Processing, Reports).
• Uses Function Points (FP) to estimate the effort required.
• B. Work Breakdown Structure (WBS)
• Breaks the project into manageable tasks and subtasks.
• Assigns effort and duration estimates to each task.
• Helps in tracking project progress.
• C. Process-Based Estimation
• Breaks the project into phases (e.g., Requirements, Design,
Development, Testing).
• Estimates effort for each phase based on historical data.
3. Cost Estimation Tools and
Techniques
• Several tools and techniques are used for cost estimation in software
projects.
• A. Algorithmic Models
• These models use mathematical formulas to estimate cost based on
project size and complexity.
• 1. COCOMO (Constructive Cost Model)
• A widely used algorithmic estimation model.
• Estimates effort (in person-months) based on project size (measured in
KLOC or Function Points).
• Basic COCOMO Formula:Effort (Person-Months)=a*(size)^b
• Where a and b are constants based on project type (Organic, Semi-
Detached, Embedded).
• Three Variants of COCOMO:
• Basic COCOMO: Simple projects.
• Intermediate COCOMO: Considers project complexity and team expertise.
• Detailed COCOMO: Accounts for multiple cost drivers.
• B. Expert Judgment
• Based on experience and intuition of domain experts.
• Useful when historical data is limited.
• Subjective and may vary between experts.
• C. Estimation by Analogy
• Compares the current project with similar past projects.
• Adjusts the effort and cost estimates based on differences.
• D. Parametric Estimation
• Uses statistical data and cost estimation formulas.
• Example: Function Points × Cost per Function Point.
• E. Bottom-Up Estimation
• Estimates cost for each small task and sums them up.
• Highly accurate but time-consuming.
• F. Top-Down Estimation
• Starts with a high-level estimate and refines it.
• Quick but less accurate.
4. Typical Problems with IT Cost
Estimates
• Estimating IT project costs can be challenging due to several factors:
• Common Problems:
• ❌ Unclear Requirements: Changes in scope cause cost overruns.
❌ Underestimation of Complexity: Hidden challenges increase effort.
❌ Inaccurate Data: Lack of historical data leads to wrong assumptions.
❌ Scope Creep: New features added mid-project increase costs.
❌ Optimistic Assumptions: Unrealistic estimates lead to delays.
❌ Technology Changes: New tools may require additional training and
costs.
❌ Resource Availability: Key personnel may not always be available as
planned.