COCOMO Model Calculator (Basic, Intermediate & Detailed)
Estimate software development effort, schedule, team size and productivity using the classic COCOMO model. Supports organic, semi-detached and embedded projects plus cost drivers.
Interactive COCOMO Calculator
Organic: small team, familiar domain, flexible requirements.
Intermediate/Detailed apply effort multipliers from cost drivers.
Thousands of delivered source lines of code.
Optional – used to estimate total cost.
Used only in Detailed COCOMO.
Show cost drivers (Intermediate/Detailed)
Effort Adjustment Factor (EAF) is the product of all selected cost driver multipliers.
How the COCOMO model works
COCOMO (Constructive Cost Model), introduced by Barry Boehm, is a parametric model for estimating software development effort and schedule from the project size and a set of cost drivers. This calculator implements the basic, intermediate and a simplified detailed COCOMO model.
1. Basic COCOMO formulas
For a given project mode (organic, semi-detached, embedded) and size in KLOC:
Effort (person-months):
\( E = a \cdot (\text{KLOC})^{b} \)
Development time (months):
\( D = c \cdot E^{d} \)
Classic coefficients for COCOMO 81 are:
| 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 |
Once effort \(E\) and development time \(D\) are known, we can derive:
- Average team size: \( \text{Team} = E / D \)
- Productivity: \( \text{Prod} = \text{LOC} / E = 1000 \cdot \text{KLOC} / E \)
2. Intermediate COCOMO – cost drivers and EAF
Intermediate COCOMO multiplies the basic effort by an Effort Adjustment Factor (EAF), which is the product of several cost drivers such as required reliability, product complexity, team experience, tools, schedule constraints, and platform volatility.
Effort (intermediate):
\( E_{\text{int}} = \text{EAF} \cdot a \cdot (\text{KLOC})^{b} \)
where
\( \text{EAF} = \prod_{i=1}^{n} \text{CD}_i \)
Each cost driver \(\text{CD}_i\) is a multiplier (e.g. 0.85, 1.00, 1.15) selected from a rating scale (Very Low to Very High). Values < 1 reduce effort (favorable conditions), values > 1 increase effort (unfavorable conditions).
3. Detailed COCOMO – phase distribution
Detailed COCOMO refines the estimate by distributing effort across life-cycle phases (planning, design, coding, testing). The underlying total effort is the same as in Intermediate COCOMO, but we apply phase percentages:
Example default distribution:
- Planning & requirements: 10%
- Design: 25%
- Coding & unit test: 40%
- Integration & system test: 25%
This calculator offers three phase profiles (default, UI-heavy, backend-heavy) so you can see how effort shifts between design and coding for different types of projects.
4. Choosing the right project mode
- Organic: small teams (usually < 50 KLOC), familiar domain, stable requirements, low risk.
- Semi-detached: medium projects, mixed experience, some novelty or tighter constraints.
- Embedded: large, safety-critical or real-time systems, tight coupling to hardware or regulations.
If you are unsure, start with semi-detached and adjust after reviewing the cost drivers and your organization’s historical data.
5. Limitations and best practices
- COCOMO is calibrated on historical projects; your environment may differ.
- Early size estimates (KLOC) are often rough – revisit them as the design stabilizes.
- Use COCOMO as one input alongside expert judgment, analogy-based estimates, and agile velocity data.
- Track actual effort and update your own calibration factors over time.
FAQ about the COCOMO model
Is COCOMO still relevant for modern agile projects?
Yes, but it should be used carefully. COCOMO was developed for more traditional life cycles, yet the underlying relationships between size, complexity and effort still hold. Many teams use COCOMO for early ballpark estimates and then refine with agile metrics (story points, velocity) as sprints progress.
How do I get KLOC if I only have requirements?
In early phases you can estimate size via function points or use-case points, then convert to KLOC using a language-specific factor (e.g. 50–70 LOC per function point for Java). The result is approximate but often good enough for feasibility and budgeting.
What is a reasonable range for the Effort Adjustment Factor (EAF)?
In practice, EAF often falls between about 0.7 and 1.4. Values far outside this range may indicate inconsistent cost driver ratings. This tool shows the computed EAF so you can sanity-check your selections.
Can I use COCOMO for very small scripts or prototypes?
COCOMO is less reliable for tiny efforts (e.g. < 2–3 person-months). For small utilities or throwaway prototypes, expert judgment and timeboxing are usually more appropriate than a parametric model.