COST ESTIMATION IN SOFTWARE PROJECT PLANNING

Software Engineering
Unit: Planning a Software Project
Topic: Cost Estimation

01
Learning Objectives

Explain the need for software cost estimation

Identify major project cost components
Understand LOC and Function Point estimation
Explain effort and schedule estimation
Apply Basic COCOMO formulas
Understand estimation uncertainty and best practices

02
What is Cost Estimation?

Process of predicting the effort, time, resources and financial cost required for a software project.
Cost estimation supports budgeting, staffing, scheduling and project feasibility.
Typical flow: Software Size → Effort → Schedule → Resources → Cost

03
Why Cost Estimation is Important?

Prepare project budgets and customer quotations

Decide project feasibility
Allocate personnel and resources
Plan project schedules
Control project costs
Support contract negotiation
Poor estimates may cause budget overruns, delays and reduced quality

04
Cost Estimation in Project Planning

Cost estimation is closely connected with scheduling and staffing.

A change in one factor can affect the others.
Example: A shorter deadline may require additional staff, increasing project cost.
Planning should consider scope, cost, time, resources and quality together.

05
Components of Software Cost

Personnel costs – developers, testers, managers and specialists

Hardware costs – computers, servers, storage and networking
Software/tool costs – licenses, development and testing tools
Training and travel costs
Cloud/infrastructure and communication costs
Outsourcing and maintenance costs
Contingency or management reserve

06
Personnel Cost – Example

Personnel cost is often the largest component of software development cost.

Example: 5 developers × ₹60,000/month × 6 months
Personnel Cost = ₹18,00,000
Other project costs should be added separately.

07
Software Size Estimation

Software size represents the amount of functionality or code to be developed.

Common approaches:
• Lines of Code (LOC)
• Function Points (FP)
• Use Case Points
• Story Points / Velocity in Agile
Size is an important input to many effort and cost models.

08
Lines of Code (LOC)

LOC represents the number of source-code lines in a software system.

Example: 2,000 + 3,000 + 1,500 LOC = 6,500 LOC
1 KLOC = 1,000 LOC
Advantages: simple and widely understood
Limitations: language dependent and difficult to estimate accurately before coding

09
Function Point Analysis

Function Point Analysis measures software size based on functionality delivered to users.
Five major function types:
• External Inputs (EI)
• External Outputs (EO)
• External Inquiries (EQ)
• Internal Logical Files (ILF)
• External Interface Files (EIF)

10
Function Point Components – Example

EI – data entering the system, e.g., customer registration

EO – outputs generated by the system, e.g., account statement
EQ – inquiry requiring input and output, e.g., balance enquiry
ILF – data maintained inside the application
EIF – data used but maintained by another application

11
Function Point Calculation

Unadjusted Function Points (UFP) = Σ(Count × Complexity Weight)

Adjusted FP = UFP × Value Adjustment Factor
Example:
10 EI×4 + 8 EO×5 + 6 EQ×4 + 5 ILF×10 + 3 EIF×7
UFP = 175 FP

12
What is Effort?

Effort represents the amount of human work required to develop software.

Common units: person-hours, person-days and person-months.
Example: 4 people × 6 months = 24 person-months of effort.
Effort and calendar duration are not the same.

13
Effort vs Duration

Effort = total amount of human work

Duration = calendar time required
Example: 4 people working for 6 months = 24 person-months effort and 6 months duration.
Adding people does not reduce schedule proportionally because of communication and coordination overhead.

14
Cost Estimation Techniques

Expert Judgment
Estimation by Analogy
Top-Down Estimation
Bottom-Up Estimation
Algorithmic / Parametric Models
Three-Point Estimation
Function Point-based Estimation
Agile estimation using Story Points and Velocity

15
Expert Judgment

Experienced professionals estimate size, effort, duration and cost using knowledge and previous experience.
Advantages: quick and useful when historical data is limited.
Disadvantages: subjective and affected by experience, optimism and bias.
Best practice: involve multiple experts and document assumptions.

16
Estimation by Analogy

Compare the proposed project with a previously completed similar project.

Example: Previous project = 100 FP and 1,000 person-hours.
New project = 150 FP.
Approximate effort = 1,000 × 150/100 = 1,500 person-hours.
Accuracy depends on how similar the projects are.

17
Top-Down Estimation

Estimate the entire project first and then distribute the estimate among major components.
Useful during early planning when detailed information is unavailable.
Advantages: fast and gives an overall budget.
Limitation: small tasks and integration effort may be overlooked.

18
Bottom-Up Estimation

Break the project into small tasks and estimate each task separately.
Example: Requirements 80h + Design 120h + Coding 400h + Testing 200h + Deployment 50h.
Total = 850 person-hours.
Provides detailed estimates when requirements are sufficiently known.

19
COCOMO Model

COCOMO = Constructive Cost Model

Developed by Barry W. Boehm.
An algorithmic model for estimating effort, development time and staffing.
Basic COCOMO uses software size in KLOC and project mode.
Formula: Effort = a × (KLOC)^b

20
Basic COCOMO – Development Time

TDEV = c × (Effort)^d
TDEV = development time in months
Effort = estimated person-months
Average Staffing = Effort / Development Time
COCOMO is a model; actual estimates should also consider project-specific risks and historical data.

21
COCOMO Project Modes

Organic – small/simple projects, experienced team and familiar environment

Semi-detached – medium-size projects with mixed experience and moderate complexity
Embedded – large/complex projects with strong hardware, software or regulatory constraints

22
Basic COCOMO Coefficients

Mode | a | b | c | d
Organic | 2.4 | 1.05 | 2.5 | 0.38
Semi-detached | 3.0 | 1.12 | 2.5 | 0.35
Embedded | 3.6 | 1.20 | 2.5 | 0.32
Use the coefficient set appropriate to the project mode.

23
COCOMO Numerical Example

Organic project size = 20 KLOC

Effort = 2.4 × (20)^1.05 ≈ 55.8 person-months
Development time = 2.5 × (55.8)^0.38 ≈ 11.5
12.3 months
Average staffing ≈ 55.8 / 11.5
12.3 ≈ 4.8
4.5 persons
This is a simplified educational calculation.

24
Converting Effort to Cost

Personnel Cost = Effort × Cost per Person-Month

Example: Effort = 55.8 person-months
Cost per person-month = ₹80,000
Personnel Cost = 55.8 × ₹80,000 = ₹44,64,000
Add hardware, software, infrastructure, overhead and contingency as appropriate.

25
Three-Point Estimation

Three estimates are considered:

Optimistic (O), Most Likely (M), Pessimistic (P)
PERT-style expected estimate = (O + 4M + P) / 6
Example: O=4 months, M=6 months, P=10 months
Expected = (4 + 4×6 + 10)/6 ≈ 6.33 months

26
Agile Cost Estimation

Agile teams commonly use Story Points, Velocity, Sprint duration and team capacity.
Example: Backlog = 200 story points
Velocity = 40 story points/sprint
Estimated sprints = 200/40 = 5
At 2 weeks/sprint → approximately 10 weeks
Cost can be derived from team cost per sprint.

27
Fixed Price vs Time & Material

Fixed Price: customer and supplier agree on a fixed project price.

Supplier carries significant estimation and delivery risk.
Time & Material: payment is based on actual effort/time at agreed rates.
Customer carries more cost uncertainty.
Choice depends on scope stability, contract conditions and risk allocation.

28
Why Estimates are Difficult

Requirements may be incomplete or change frequently.

Software size may be uncertain.
Productivity differs among teams.
New technologies may be unfamiliar.
Integration and technical problems may arise.
Staff availability and experience can change.
Therefore, an estimate is a reasoned prediction, not a guarantee.

29
Factors Affecting Software Cost

Product: size, complexity, reliability and quality requirements

People: skills, experience and productivity
Process: methodology, tools and quality practices
Project: schedule, technology, customer requirements and risk
Environment: infrastructure, regulatory and organizational constraints

30
Cost Estimation Best Practices

Clearly define project scope.

Break the project into manageable tasks.
Use historical project data.
Involve experienced team members.
Use more than one estimation technique.
Document assumptions and constraints.
Identify risks and uncertainty.
Re-estimate when requirements or project conditions change.
Include an appropriate contingency or reserve.

31
Cost Estimation Process

1. Understand Requirements
2. Estimate Software Size
3. Estimate Effort
4. Estimate Schedule
5. Determine Staffing
6. Calculate Personnel Cost
7. Add Other Project Costs
8. Add Risk/Contingency
9. Prepare Project Budget
10. Monitor Actual Cost

32
Important Formulas

Basic COCOMO: E = a × (KLOC)^b

Development Time: TDEV = c × (Effort)^d
Average Staffing = Effort / Development Time
Personnel Cost = Effort × Cost per Person-Month
PERT Estimate = (O + 4M + P) / 6
Risk Exposure = Probability × Impact

33
Technique Comparison

Expert Judgment – experienced experts are available

Analogy – similar historical project exists
Top-Down – early planning
Bottom-Up – detailed task information exists
Function Points – functionality can be identified
COCOMO – size and project characteristics can be estimated
Three-Point – uncertainty is significant
Agile/Velocity – team has historical velocity

34
Worked Example

Project size = 30 KLOC; project type = Organic

Effort = 2.4 × (30)^1.05 ≈ 78.2 person-months
Development time = 2.5 × (78.2)^0.38 ≈ 14.0 months
Average staffing ≈ 78.2/14.0 ≈ 5.6 persons
At ₹75,000 per person-month: personnel cost ≈ ₹58.65 lakh
Actual budget should include non-personnel costs, overheads and contingency.

35
Key Takeaways

Cost estimation is an essential part of software project planning.

Software size is a foundation for many estimation approaches.
LOC and Function Points are common size measures.
Effort is usually measured in person-hours or person-months.
COCOMO is an important algorithmic estimation model.
Bottom-up estimation provides detailed task-level estimates.
Estimates contain uncertainty and should be reviewed regularly.
Good estimation supports cost, schedule, staffing and risk management.

36
Questions for Students

Define software cost estimation.

What are the major components of software cost?
Explain LOC-based estimation.
What is Function Point Analysis?
Differentiate effort and duration.
Explain top-down and bottom-up estimation.
What is COCOMO?
Explain the three COCOMO project modes.
Calculate effort using Basic COCOMO.
Explain three-point estimation.
Why is software cost estimation difficult?

37
Recommended Textbooks

Roger S. Pressman & Bruce R. Maxim – Software Engineering: A Practitioner's Approach

Ian Sommerville – Software Engineering
Pankaj Jalote – An Integrated Approach to Software Engineering
Barry W. Boehm – Software Engineering Economics
Use the prescribed edition in your institution's syllabus.

38