Real-World Scenario

Imagine this requirement:

Discount calculation depends on customer type:

● Standard Customer → 5% discount
● Premium Customer → 15% discount
● Partner Customer → Custom logic

Tomorrow, marketing adds:

● Festival discount strategy
● Region-based discount strategy

If all logic sits inside one method, every new rule risks breaking old ones.

Strategy Pattern solves this by:

● Putting each rule in its own class
● Selecting strategy at runtime using configuration or data

What is Strategy Pattern?

Strategy Pattern defines:

● A common interface
● Multiple interchangeable implementations
● Runtime selection of behavior

Instead of changing code inside methods, you change which strategy is used.

This supports:

● Open–Closed Principle
● Clean separation of business logic
● Independent testing of rules

Demo: Discount Calculation Using Strategy Pattern

◆ Step 1 – Strategy Interface

public interface DiscountStrategy {
    Decimal calculateDiscount(Decimal amount);
}

◆ Step 2 – Strategy Implementations

Standard Customer

public class StandardDiscountStrategy implements DiscountStrategy {
    public Decimal calculateDiscount(Decimal amount) {
        return amount * 0.05;
    }
}

Premium Customer

public class PremiumDiscountStrategy implements DiscountStrategy {
    public Decimal calculateDiscount(Decimal amount) {
        return amount * 0.15;
    }
}

Partner Customer

public class PartnerDiscountStrategy implements DiscountStrategy {
    public Decimal calculateDiscount(Decimal amount) {
        return amount * 0.25;
    }
}

Each class has only one responsibility — discount calculation.

◆ Step 3 – Strategy Selector (Factory + Strategy Together)

public class DiscountStrategyFactory {

    public static DiscountStrategy getStrategy(String customerType) {

        if(customerType == 'Standard') {
            return new StandardDiscountStrategy();
        }
        if(customerType == 'Premium') {
            return new PremiumDiscountStrategy();
        }
        if(customerType == 'Partner') {
            return new PartnerDiscountStrategy();
        }

        throw new IllegalArgumentException('Unknown customer type');
    }
}

◆ Step 4 – Business Service Uses Strategy

public class PricingService {

    public static Decimal applyDiscount(Decimal amount, String customerType) {

        DiscountStrategy strategy =
            DiscountStrategyFactory.getStrategy(customerType);

        Decimal discount = strategy.calculateDiscount(amount);
        return amount - discount;
    }
}

Now the pricing service does not care about rule details.

How This Helps in Real Projects

When a new discount rule is added:

● Create new strategy class
● Update factory selection logic
● No modification to pricing service

This prevents regression bugs and keeps business rules isolated.

Strategy Pattern vs If-Else Logic

If-Else Logic	Strategy Pattern
All logic in one method	Each rule in its own class
Hard to test separately	Each strategy easily testable
Risky to modify	New rules don’t break old ones
Code becomes messy	Code remains clean

For complex approval rules, validations, routing logic, or pricing — Strategy Pattern is the safest design choice.

Testing Example

@IsTest
private class PricingServiceTest {

    @IsTest
    static void testPremiumDiscount() {

        Decimal finalAmount =
            PricingService.applyDiscount(1000, 'Premium');

        System.assertEquals(850, finalAmount);
    }
}

Each strategy can also be tested individually if needed.

Best Practices

● Keep strategy classes small and focused
● Do not mix multiple rules in one strategy
● Use configuration or metadata to select strategies in production
● Combine Strategy with Factory for clean selection logic
● Avoid static business logic blocks

Strategy Pattern is ideal when behavior changes but workflow remains same.

Conclusion

In this blog, you learned how to manage changing business rules using Strategy Pattern in Apex.

This pattern is extremely useful in approvals, pricing, validation frameworks, and routing engines.

Let rules evolve without rewriting your core logic — design for change. 🚀

Apex Beginner to Advance

Strategy Pattern for Business Rules in Apex