Function Point Calculator (IFPUG-style)

Estimate software size in function points with full breakdown of function types, value adjustment factor (VAF), effort, cost, and productivity.

Function Point Analysis Tool

1. Functional User Requirements

Unadjusted FP

Enter the number of functions by type and complexity. We use typical IFPUG weights (Low / Average / High).

Function Type Low Avg High Weight (L/A/H) FP

2. General System Characteristics (GSC)

VAF

Rate each characteristic from 0 (no influence) to 5 (strong influence). We compute the Total Degree of Influence (TDI) and Value Adjustment Factor (VAF).

TDI: 0
VAF: 0.65 (0.65 + 0.01 × TDI)

3. Effort, Cost & Productivity (optional)

Estimation

Provide your productivity and rate assumptions to estimate effort, duration, and cost.

Typical range: 5–15 hours per FP.

$

Fully loaded cost per hour.

Effective project hours per person per week.

Results

Unadjusted Function Points (UFP) 0
Value Adjustment Factor (VAF) 0.65
Adjusted Function Points (AFP) 0
Estimated effort (hours) 0
Estimated duration (weeks, 1 FTE) 0
Estimated cost $0

Note: These are rough estimates. Calibrate hours/FP and hourly rate with your own historical data for better accuracy.

What is Function Point Analysis?

Function Point Analysis (FPA) is a standardized method for measuring the size of a software system based on the business functionality it delivers, rather than on lines of code or technology stack. It is widely used for:

  • Early-stage effort and cost estimation
  • Comparing productivity across teams, vendors, or technologies
  • Benchmarking and tracking cost per FP or hours per FP
  • Contracting and vendor management in large organizations

Function types and standard weights

In the IFPUG method, you classify each user-visible function into one of five types and assign a complexity level (Low, Average, High). Each combination has a standard weight:

External Inputs (EI) – data entering the system (e.g., create/update forms)
External Outputs (EO) – data leaving the system with processing (e.g., reports, emails)
External Inquiries (EQ) – request/response with no significant processing (e.g., search screens)
Internal Logical Files (ILF) – logical groups of data maintained by the system (e.g., Customer table)
External Interface Files (EIF) – logical groups of data used but not maintained by the system
Function type Low Average High
External Input (EI) 3 4 6
External Output (EO) 4 5 7
External Inquiry (EQ) 3 4 6
Internal Logical File (ILF) 7 10 15
External Interface File (EIF) 5 7 10

Formulas used by this calculator

1. Unadjusted Function Points (UFP)

For each function type and complexity level, we multiply the count by the corresponding weight and sum everything:

\[ \text{UFP} = \sum_{\text{all functions}} (\text{count} \times \text{weight}) \]

2. Value Adjustment Factor (VAF)

We rate 14 General System Characteristics (GSC) from 0 to 5. Their sum is the Total Degree of Influence (TDI).

\[ \text{TDI} = \sum_{i=1}^{14} \text{GSC}_i \quad\text{and}\quad \text{VAF} = 0.65 + 0.01 \times \text{TDI} \]

3. Adjusted Function Points (AFP)

\[ \text{AFP} = \text{UFP} \times \text{VAF} \]

4. Effort, duration, and cost

Given your assumptions:

  • \(H_{FP}\): hours per FP (productivity)
  • \(R\): hourly rate
  • \(H_w\): hours per week per person
\[ \text{Effort (hours)} = \text{AFP} \times H_{FP} \] \[ \text{Duration (weeks, 1 FTE)} = \frac{\text{Effort (hours)}}{H_w} \] \[ \text{Cost} = \text{Effort (hours)} \times R \]

Typical ranges and interpretation

  • Small enhancement: < 100 FP
  • Medium application: 100–500 FP
  • Large system: > 500 FP

Productivity can vary widely (5–20 hours/FP) depending on team experience, domain complexity, tooling, and non-functional requirements. Use your own historical projects to calibrate the hours/FP and cost/FP values.

Best practices for accurate Function Point counts

  • Use consistent counting rules (e.g., IFPUG, NESMA) across projects.
  • Document assumptions for each function (what is considered Low vs High complexity).
  • Separate functional size (FP) from technical complexity (architecture, performance, security).
  • Maintain a historical database of projects with FP, effort, and cost to refine your estimates over time.

Function Point Calculator – FAQ

What is a function point in software engineering?

A function point (FP) is a technology-independent measure of the amount of business functionality delivered by a software system. It focuses on what the system does for the user (inputs, outputs, data files, interfaces), not on how it is implemented (language, framework, architecture).

How accurate is function point–based estimation?

Function points provide a solid basis for estimation, but accuracy depends on:

  • How consistently you apply counting rules
  • The quality of your requirements
  • How well your hours-per-FP and cost-per-FP values reflect your actual historical data

Many organizations achieve good accuracy once they calibrate the model with several completed projects.

Can I use this calculator for Agile or incremental projects?

Yes. You can estimate the FP size of a release, epic, or feature set and then track delivered FP per iteration. Some teams use FP alongside story points to maintain a technology-neutral productivity baseline across products and vendors.

What is the difference between UFP and AFP?

UFP (Unadjusted Function Points) is the raw functional size based purely on the five function types and their complexity. AFP (Adjusted Function Points) multiplies UFP by the Value Adjustment Factor (VAF) to account for general system characteristics such as performance, reusability, and complexity of processing.