Function Point Analysis Calculator
Calculate software project size using the industry-standard Function Point Analysis (FPA) methodology. Get detailed metrics and visual breakdown of your function points.
Function Point Analysis Results
Comprehensive Guide to Function Point Analysis (FPA)
Function Point Analysis (FPA) is an ISO/IEC standardized method (ISO/IEC 20926:2009) for measuring the functional size of software applications. Developed by Allan Albrecht at IBM in 1979, FPA has become the industry standard for software sizing, used by organizations worldwide to estimate project costs, allocate resources, and measure productivity.
Why Function Point Analysis Matters
- Objective Measurement: Unlike lines of code (LOC) which vary by programming language, function points measure functionality from the user’s perspective
- Language Independent: Provides consistent measurements across different technologies and platforms
- Early Estimation: Can be applied during requirements phase before coding begins
- Benchmarking: Enables comparison of productivity across projects and organizations
- Contract Management: Used in fixed-price contracts to define scope objectively
The Five Function Point Components
FPA evaluates five types of functional components that represent the business functionality provided to users:
- External Inputs (EI): Unique user inputs that update internal logical files (e.g., forms, transactions)
- External Outputs (EO): Unique user outputs that contain derived data (e.g., reports, screens with calculations)
- External Inquiries (EQ): Unique user inputs that result in immediate outputs without internal file updates (e.g., search functions)
- Internal Logical Files (ILF): Internal data stores maintained by the application (e.g., databases, configuration files)
- External Interface Files (EIF): Data files shared with other applications (e.g., API data exchanges, shared databases)
| Component Type | Low Complexity | Average Complexity | High Complexity |
|---|---|---|---|
| External Inputs (EI) | 3 | 4 | 6 |
| External Outputs (EO) | 4 | 5 | 7 |
| External Inquiries (EQ) | 3 | 4 | 6 |
| Internal Logical Files (ILF) | 7 | 10 | 15 |
| External Interface Files (EIF) | 5 | 7 | 10 |
The Function Point Calculation Process
Step 1: Identify the Scope and Boundary
Before counting function points, you must clearly define:
- The application boundary (what’s included in the count)
- The user’s perspective (who are the primary users)
- The functional requirements (what the system must do)
Step 2: Count the Functional Components
For each of the five component types:
- Identify all unique instances
- Classify each as low, average, or high complexity
- Multiply the count by the appropriate weighting factor
Step 3: Calculate Unadjusted Function Points (UFP)
The UFP is the sum of all weighted component counts:
UFP = Σ(EI × weight) + Σ(EO × weight) + Σ(EQ × weight) + Σ(ILF × weight) + Σ(EIF × weight)
Step 4: Apply Technical Complexity Factor (TCF)
The TCF adjusts the UFP based on 14 technical complexity factors (each rated 0-5):
- Data communications
- Distributed data processing
- Performance requirements
- Heavily used configuration
- Transaction rate
- Online data entry
- End-user efficiency
- Online update
- Complex processing
- Reusability
- Installation ease
- Operational ease
- Multiple sites
- Facilitate change
The TCF is calculated as: TCF = 0.65 + (0.01 × ΣFI) where FI are the individual factor ratings.
Step 5: Calculate Adjusted Function Points (AFP)
The final adjusted function point count is:
AFP = UFP × TCF
| Development Type | Function Points per Person-Month | Hours per Function Point | Source |
|---|---|---|---|
| New Development (Simple) | 15-25 | 12-20 | ISBSG Repository |
| New Development (Average) | 8-15 | 20-40 | ISBSG Repository |
| New Development (Complex) | 4-8 | 40-80 | ISBSG Repository |
| Enhancement Projects | 10-20 | 15-30 | ISBSG Repository |
| Maintenance | 5-15 | 25-60 | ISBSG Repository |
Advanced Function Point Analysis Techniques
Early Function Points (EFP)
For projects in early stages where detailed requirements aren’t available, you can estimate function points using:
- Functional decomposition
- Use case analysis
- Story point mapping
- Analogy with similar past projects
SNAP (Software Non-functional Assessment Process)
Complements FPA by measuring non-functional requirements in four categories:
- Data Operations (file handling, data validation)
- Interface Operations (user interfaces, APIs)
- Architectural Operations (security, performance)
- Batch Processes (report generation, data conversion)
Automated Function Point Counting
Modern tools can automate parts of the FPA process by:
- Analyzing requirements documents
- Scanning source code for functional components
- Integrating with ALM tools
- Generating standardized reports
Common Function Point Analysis Mistakes to Avoid
- Incorrect Boundary Definition: Including or excluding components incorrectly skews results
- Double Counting: Counting the same functionality in multiple components
- Ignoring Complexity: Always assess each component’s complexity accurately
- Overlooking Maintenance: Enhancement projects require different counting rules
- Misapplying TCF: Technical factors should reflect actual project complexity
- Not Documenting Assumptions: Always record counting rules and assumptions
Function Point Analysis in Agile Environments
FPA can be effectively integrated with Agile methodologies:
- Backlog Refinement: Use function points to size user stories
- Velocity Measurement: Track function points completed per sprint
- Release Planning: Estimate total function points for release scope
- Team Productivity: Measure function points per team member
- Continuous Improvement: Compare actual vs. estimated function points
Industry Standards and Certifications
Several organizations provide FPA standards and certifications:
- International Function Point Users Group (IFPUG): The original FPA standard (ISO/IEC 20926)
- COSMIC: Common Software Measurement International Consortium (ISO/IEC 19761)
- NESMA: Netherlands Software Metrics Association
- FiSMA:
Function Point Analysis Tools
Popular commercial and open-source FPA tools include:
- CAST Software: Automated function point counting with code analysis
- SCOPE: Function point and SNAP measurement tool
- Function Point WORKBENCH: Comprehensive FPA solution
- FP Count: Web-based function point calculator
- OpenFPA: Open-source function point analysis tool
Case Study: Function Point Analysis in a Banking Application
A major bank used FPA to estimate a new online banking system:
- Initial Estimate: 1,200 function points
- Actual Delivery: 1,180 function points (98% accuracy)
- Development Time: 18 person-months
- Productivity: 65 function points per person-month
- Cost Savings: $2.1M through accurate resource allocation
Future Trends in Function Point Analysis
Emerging developments in software measurement include:
- AI-Assisted Counting: Machine learning to automate component identification
- Cloud-Native Metrics: Specialized counting rules for microservices and serverless
- DevOps Integration: Real-time function point tracking in CI/CD pipelines
- Blockchain Measurement: New standards for smart contract sizing
- Predictive Analytics: Using historical FPA data for better estimates
Authoritative Resources
For more information about Function Point Analysis, consult these authoritative sources: