Feature flags concept in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does a feature flag affect Spring Boot application behavior?

Consider a Spring Boot app with a feature flag controlling a new payment method. What happens when the flag is OFF?

Spring Boot

public boolean isNewPaymentEnabled() {
    return featureFlagService.isEnabled("newPayment");
}

if (isNewPaymentEnabled()) {
    // use new payment method
} else {
    // use old payment method
}

A The app uses the old payment method only.

B The app uses both old and new payment methods simultaneously.

C The app throws an error because the feature flag is off.

D The app disables all payment methods.

💡 Hint

Think about what the flag controls and what happens when it is false.

When the feature flag is OFF, the app skips the new payment method and uses the old one as fallback.

📝 Syntax

intermediate

Which code snippet correctly checks a feature flag in Spring Boot?

You want to check if a feature flag named "betaFeature" is enabled using a FeatureFlagService. Which option is correct?

A if (featureFlagService.isEnable("betaFeature")) { /* enabled */ }

B if (featureFlagService.enabled("betaFeature")) { /* enabled */ }

C if (featureFlagService.isEnabled("betaFeature")) { /* enabled */ }

D if (featureFlagService.check("betaFeature")) { /* enabled */ }

💡 Hint

Look for the common naming pattern for boolean checks in Java.

The method is usually named isEnabled to indicate a boolean check. Other options are invalid method names.

❓ state_output

advanced

What is the output when toggling a feature flag at runtime?

Given a Spring Boot app where a feature flag "darkMode" is initially OFF, what happens if you enable it at runtime and then reload the page?

Spring Boot

boolean darkMode = featureFlagService.isEnabled("darkMode");
System.out.println("Dark mode enabled: " + darkMode);

A Prints true initially and false after reload.

B Always prints false because flags can't change at runtime.

C Throws an exception when toggling the flag.

D First prints false, then after enabling and reload, prints true.

💡 Hint

Feature flags can be dynamic if implemented properly.

When the flag is toggled on, the app reads the new value on reload and reflects the change.

🔧 Debug

advanced

Why does the feature flag check always return false?

You wrote this code but the feature flag check always returns false even when enabled: @Service public class FeatureFlagService { private Map flags = Map.of("newUI", false); public boolean isEnabled(String flag) { return flags.getOrDefault(flag, false); } } What is the likely cause?

A The flags map is immutable and never updated after initialization.

B The isEnabled method has a typo in the flag name.

C The service is not annotated with @Component.

D The flags map keys are case sensitive and mismatched.

💡 Hint

Think about how Map.of works in Java.

Map.of creates an immutable map. You cannot update flags later, so the flag stays false.

🧠 Conceptual

expert

What is the main benefit of using feature flags in Spring Boot applications?

Choose the best explanation for why developers use feature flags in Spring Boot projects.

A They automatically fix bugs in the code at runtime.

B They allow turning features on or off without redeploying the app.

C They improve database query performance by caching results.

D They replace the need for unit testing by isolating features.

💡 Hint

Think about how feature flags help with releasing new features safely.

Feature flags let teams enable or disable features dynamically, avoiding full redeploys and reducing risk.

Practice

1. What is the main purpose of using feature flags in a Spring Boot application?

easy

A. To improve database performance

B. To manage application logging levels

C. To handle user authentication

D. To enable or disable features without changing the code

Solution

1. Step 1: Understand feature flags concept

   Feature flags allow toggling features on or off dynamically without redeploying code.

2. Step 2: Identify the main use in Spring Boot

   In Spring Boot, feature flags help control feature availability safely during runtime.

3. Final Answer:

   To enable or disable features without changing the code -> Option D

4. Quick Check:

   Feature flags = toggle features dynamically [OK]

Hint: Feature flags toggle features without code changes [OK]

Common Mistakes:

• Confusing feature flags with database optimization
• Thinking feature flags manage authentication
• Assuming feature flags control logging

2. Which of the following is the correct way to check a feature flag in a Spring Boot controller method?

easy

A. if(featureFlagService.isFeatureEnabled("newFeature")) { ... }

B. if(featureFlagService.checkFlag("newFeature")) { ... }

C. if(featureFlagService.enableFeature("newFeature")) { ... }

D. if(featureFlagService.toggleFeature("newFeature")) { ... }

Solution

1. Step 1: Recall typical method naming for feature flags

   Common method to check if a feature is enabled is named like isFeatureEnabled.

2. Step 2: Match method name with options

   Only if(featureFlagService.isFeatureEnabled("newFeature")) { ... } uses isFeatureEnabled which clearly indicates checking status.

3. Final Answer:

   if(featureFlagService.isFeatureEnabled("newFeature")) { ... } -> Option A

4. Quick Check:

   Check feature flag with isFeatureEnabled() [OK]

Hint: Look for method named isFeatureEnabled() to check flags [OK]

Common Mistakes:

• Using methods that sound like they change state (enableFeature, toggleFeature)
• Using incorrect method names not standard in feature flag services

3. Given the following Spring Boot code snippet, what will be the output if the feature flag "betaFeature" is disabled?

if(featureFlagService.isFeatureEnabled("betaFeature")) {
    System.out.println("Beta feature is ON");
} else {
    System.out.println("Beta feature is OFF");
}

medium

A. Beta feature is ON

B. Beta feature is OFF

C. No output

D. Runtime error

Solution

1. Step 1: Understand the condition check

   The code prints "Beta feature is ON" only if the flag is enabled (true).

2. Step 2: Analyze the flag state given

   The flag "betaFeature" is disabled, so isFeatureEnabled returns false, triggering the else block.

3. Final Answer:

   Beta feature is OFF -> Option B

4. Quick Check:

   Flag disabled = else block runs [OK]

Hint: Disabled flag triggers else block output [OK]

Common Mistakes:

• Assuming disabled flag prints ON message
• Expecting no output when else block exists
• Thinking code throws error on false flag

4. Identify the error in this Spring Boot feature flag usage:

@GetMapping("/feature")
public String feature() {
    if(featureFlagService.isFeatureEnabled) {
        return "Feature ON";
    } else {
        return "Feature OFF";
    }
}

medium

A. Return type should be void

B. Incorrect HTTP method annotation

C. Missing parentheses when calling isFeatureEnabled method

D. Feature flag service not injected

Solution

1. Step 1: Check method call syntax

   isFeatureEnabled is a method and must be called with parentheses ().

2. Step 2: Verify other code parts

   HTTP annotation and return type are correct; no injection info given but not error here.

3. Final Answer:

   Missing parentheses when calling isFeatureEnabled method -> Option C

4. Quick Check:

   Method calls need () [OK]

Hint: Method calls always need parentheses () [OK]

Common Mistakes:

• Forgetting () after method names
• Confusing HTTP method annotations
• Assuming return type must be void

5. You want to implement a feature flag in Spring Boot that disables a new payment method only for users in a "betaTesters" group. Which approach correctly combines feature flags with user context?

hard

A. Check if feature flag is enabled and user belongs to betaTesters before allowing payment

B. Enable feature flag globally and ignore user groups

C. Disable feature flag and allow all users access

D. Use feature flag only in frontend without backend checks

Solution

1. Step 1: Understand combining feature flags with user context

   Feature flags can be combined with user group checks to control feature access precisely.

2. Step 2: Evaluate options for correct logic

   Check if feature flag is enabled and user belongs to betaTesters before allowing payment correctly checks both the flag and user group before enabling the feature.

3. Final Answer:

   Check if feature flag is enabled and user belongs to betaTesters before allowing payment -> Option A

4. Quick Check:

   Feature flag + user group check = controlled access [OK]

Hint: Combine flag check with user group for precise control [OK]

Common Mistakes:

• Ignoring user groups when using feature flags
• Relying only on frontend checks
• Enabling feature globally without restrictions