Function Point Analysis (FPA): A Step-by-Step Guide : Project Management 105

5 min readOct 9, 2024

Function Point Analysis (FPA) is a standardized method for measuring the functional size of software applications. It provides a framework to evaluate the complexity and functionality of a system, which can be beneficial for project estimation, benchmarking, and resource allocation. This guide will walk you through the key concepts, steps, benefits, and limitations of FPA.

Key Concepts

Function Points: A unit of measurement that quantifies the functionality provided to the user based on the requirements of the system.
Functional Components:
Inputs: Data received by the system from external sources.
Outputs: Data produced by the system for external users or systems.
User Inquiries: Requests for data or information that require processing.
Internal Logical Files: Data stores that the system maintains internally.
External Interface Files: Data stores that the system uses but are maintained by external applications.

Steps for Function Point Analysis

Step 1: Identify the Functional Components

Determine the functional components of your system:
External Inputs (EIs): Count the number of unique input forms or data received by the system.
External Outputs (EOs): Count the unique outputs generated by the system for users.
User Inquiries (UIs): Identify the number of requests for data that require processing.
Internal Logical Files (ILFs): Identify the internal data stores that the application maintains.
External Interface Files (EIFs): Count the data stores used by the application that are maintained externally.

Step 2: Assign Weights to Functional Components

Each functional component is assigned a weight based on its complexity (low, average, or high). The typical weights are as follows:

External Inputs (EIs):
Low: 4
Average: 5
High: 6
External Outputs (EOs):
Low: 4
Average: 5
High: 7
User Inquiries (UIs):
Low: 4
Average: 5
High: 6
Internal Logical Files (ILFs):
Low: 7
Average: 10
High: 15
External Interface Files (EIFs):
Low: 5
Average: 7
High: 10

Step 3: Calculate Function Points

Use the following formula to calculate the total function points:

Function Points=∑(Number of Components×Weight)\text{Function Points} = \sum (\text{Number of Components} \times \text{Weight})Function Points=∑(Number of Components×Weight)

Multiply the number of each type of functional component by its corresponding weight.
Sum the results to obtain the total function points.

Step 4: Adjust for Environmental Factors

Apply an adjustment factor to account for project-specific variables that can affect complexity. Assess the 14 general system characteristics on a scale from 0 to 5, including factors like performance, security, and user experience requirements.

Step 5: Final Calculation of Adjusted Function Points

Calculate the adjusted function points using the formula:

Adjusted Function Points=Function Points×(0.65+0.01×Sum of Adjustment Factors)\text{Adjusted Function Points} = \text{Function Points} \times \left(0.65 + 0.01 \times \text{Sum of Adjustment Factors}\right)Adjusted Function Points=Function Points×(0.65+0.01×Sum of Adjustment Factors)

Benefits of Function Point Analysis

Objective Measurement: Provides a standardized method for measuring software size and functionality, making it easier to compare different systems or projects.
Improved Estimation: Aids in estimating project timelines, resources, and costs based on historical data.
Enhanced Communication: Facilitates better communication among stakeholders by providing a clear and understandable metric for functionality.

Limitations of Function Point Analysis

Subjectivity: The assignment of weights can be subjective and may vary depending on the analyst’s experience.
Maintenance Complexity: Keeping track of function points in evolving projects can be challenging.
Limited Scope: FPA primarily focuses on functional size and does not account for non-functional requirements such as performance or usability.

Pseudocode for Function Point Analysis

function calculateFunctionPoints(inputs, outputs, inquiries, internalFiles, externalFiles):
    // Define weights for each functional component based on complexity
    weights = {
        "externalInputs": { "low": 4, "average": 5, "high": 6 },
        "externalOutputs": { "low": 4, "average": 5, "high": 7 },
        "userInquiries": { "low": 4, "average": 5, "high": 6 },
        "internalFiles": { "low": 7, "average": 10, "high": 15 },
        "externalFiles": { "low": 5, "average": 7, "high": 10 }
    }

    // Calculate function points for each component
    totalFunctionPoints = 0
    totalFunctionPoints += (inputs.lowCount * weights.externalInputs.low) 
                        + (inputs.averageCount * weights.externalInputs.average) 
                        + (inputs.highCount * weights.externalInputs.high)

    totalFunctionPoints += (outputs.lowCount * weights.externalOutputs.low) 
                        + (outputs.averageCount * weights.externalOutputs.average) 
                        + (outputs.highCount * weights.externalOutputs.high)

    totalFunctionPoints += (inquiries.lowCount * weights.userInquiries.low) 
                        + (inquiries.averageCount * weights.userInquiries.average) 
                        + (inquiries.highCount * weights.userInquiries.high)

    totalFunctionPoints += (internalFiles.lowCount * weights.internalFiles.low) 
                        + (internalFiles.averageCount * weights.internalFiles.average) 
                        + (internalFiles.highCount * weights.internalFiles.high)

    totalFunctionPoints += (externalFiles.lowCount * weights.externalFiles.low) 
                        + (externalFiles.averageCount * weights.externalFiles.average) 
                        + (externalFiles.highCount * weights.externalFiles.high)

    // Adjust for environmental factors
    adjustmentFactor = calculateAdjustmentFactor() // Implement this based on project characteristics
    adjustedFunctionPoints = totalFunctionPoints * (0.65 + 0.01 * adjustmentFactor)

    return adjustedFunctionPoints

function calculateAdjustmentFactor():
    // Placeholder for logic to calculate adjustment factors
    // Based on 14 general system characteristics
    adjustmentFactors = []
    for each characteristic in characteristics:
        adjustmentFactors.append(getUserInput(characteristic)) // Example: score from 0 to 5

    return sum(adjustmentFactors)

Example: Lottery Ticket Draw in an eCommerce Site

In this scenario, we analyze the functional components of a lottery ticket draw feature in an eCommerce application. The feature allows users to input their list of lottery ticket numbers and check if they own any winning tickets, which can be multiple.

Key Functional Components:

External Inputs (EIs):

Ticket List Input: Users input their ticket numbers via a form (1 EI).

External Outputs (EOs):

Winning Ticket Notifications: The system generates notifications indicating which of the user’s tickets are winners (1 or more EOs).

User Inquiries (UIs):

Check Ticket Status: Users can request the status of their ticket numbers (1 UI).

Internal Logical Files (ILFs):

User Ticket Records: The system maintains a database of user ticket numbers (1 ILF).

External Interface Files (EIFs):

Winning Numbers Database: The application accesses an external database containing multiple winning ticket numbers (1 EIF).

Function Point Analysis Steps:

Identify the Functional Components:

EIs: 1 Ticket List Input
EOs: Multiple Winning Ticket Notifications (assume a maximum of 5 notifications for analysis)
UIs: 1 Check Ticket Status
ILFs: 1 User Ticket Records
EIFs: 1 Winning Numbers Database

Assign Weights to Functional Components:

External Inputs (EIs):
Ticket List Input: Low (Weight = 4)
External Outputs (EOs):
Winning Ticket Notifications: Assuming a maximum of 5 notifications, we count this as 5 outputs at Low complexity (Weight = 4 each)
User Inquiries (UIs):
Check Ticket Status: Low (Weight = 4)
Internal Logical Files (ILFs):
User Ticket Records: Low (Weight = 7)
External Interface Files (EIFs):
Winning Numbers Database: Low (Weight = 5)

Calculate Function Points:
Function Points=(1×4)+(5×4)+(1×4)+(1×7)+(1×5)=4+20+4+7+5=40\text{Function Points} = (1 \times 4) + (5 \times 4) + (1 \times 4) + (1 \times 7) + (1 \times 5) = 4 + 20 + 4 + 7 + 5 = 40Function Points=(1×4)+(5×4)+(1×4)+(1×7)+(1×5)=4+20+4+7+5=40
Adjust for Environmental Factors:

Assume an adjustment factor based on project characteristics results in a score of 10.

Final Calculation of Adjusted Function Points:
Adjusted Function Points=40×(0.65+0.01×10)=40×0.75=30\text{Adjusted Function Points} = 40 \times (0.65 + 0.01 \times 10) = 40 \times 0.75 = 30Adjusted Function Points=40×(0.65+0.01×10)=40×0.75=30

By applying Function Point Analysis to the lottery ticket draw feature, we determine that the adjusted function points are 30. This systematic approach enables better planning and resource allocation for developing this feature in the eCommerce application, enhancing the user experience by allowing them to easily check their lottery ticket ownership.

Conclusion

By applying Function Point Analysis, project managers can gain valuable insights into the complexity of their projects, enabling better planning and resource management. Utilizing this systematic approach can lead to improved project outcomes and clearer communication among stakeholders.