What does the severity level grading depend on?

The gradation of error severity (severity) depends on the impact of the defect on the functionality, stability, or security of the software product. It assesses the potential harm to the user or business.

Main factors influencing severity:

• Functionality criticality: How important the affected function is for the operation of the application.
• Impact on main operations: Whether the defect prevents the execution of key tasks.
• Data or financial loss: Whether the defect can lead to data leakage or loss, as well as financial losses.
• System availability: Whether the defect completely or partially blocks the use of the application.
• Workaround availability: Whether there is an alternative way to perform the action.
• Frequency of occurrence: How often the defect manifests (although this is more of a priority factor, it can also influence severity if the defect is critical and constantly occurs).

Typical severity levels (may vary depending on the project and company):

• Blocker: The product is completely unusable, critical functionality is blocked, work or testing cannot continue. Data loss or financial losses are guaranteed.
• Critical: Critical functionality does not work or works incorrectly. Main operations are seriously disrupted, but partial operation is possible. No workaround available.
• Major: Important but not critical functionality does not work or works incorrectly. There may be disruptions in main operations, but a workaround exists. Data loss is possible but not critical.
• Minor: Insignificant functionality disruption or usability issues. Does not affect main operations. A simple workaround exists.
• Trivial: Cosmetic defects, text errors that do not affect functionality.

// Example of determining severity based on defect type and impact
enum DefectSeverity {
    case blocker, critical, major, minor, trivial
}

func determineSeverity(defectFunctionality: FunctionalityLevel, impact: ImpactLevel) -> DefectSeverity {
    switch (defectFunctionality, impact) {
    case (.critical, .blocksAll): return .blocker // Critical function, fully blocks operation
    case (.critical, .majorIssue): return .critical // Critical function, serious issues
    case (.essential, .blocksAll): return .critical // Main function, fully blocks operation
    case (.essential, .majorIssue): return .major // Main function, serious issues
    case (_, .minorIssue): return .minor // Minor issues
    case (_, .cosmetic): return .trivial // Cosmetic issues
    default: return .minor // Default value
    }
}

enum FunctionalityLevel {
    case critical, essential, minor
}

enum ImpactLevel {
    case blocksAll, majorIssue, minorIssue, cosmetic
}

// Usage:
let severity = determineSeverity(defectFunctionality: .critical, impact: .blocksAll)
print(severity) // Outputs: blocker