Feature flags in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary benefit of using feature flags in microservices?

Feature flags allow teams to control features dynamically. Which of the following best describes their main benefit?

A They enable turning features on or off without redeploying services.

B They automatically fix bugs in deployed microservices.

C They replace the need for version control systems.

D They increase the size of the microservice codebase significantly.

💡 Hint

Think about how feature flags help with deployment flexibility.

Feature flags let you enable or disable features at runtime without redeploying, which helps in gradual rollouts and quick rollbacks.

❓ Architecture

intermediate

Which component is essential for managing feature flags centrally in a microservices architecture?

In a microservices system using feature flags, which component should hold the flag configurations to ensure consistency?

A A database that only the frontend accesses for feature flags.

B Each microservice stores its own feature flags locally without coordination.

C Feature flags embedded directly in the client-side code only.

D A centralized feature flag service accessible by all microservices.

💡 Hint

Consider how to keep feature flag states consistent across services.

A centralized feature flag service ensures all microservices get consistent flag values and can update flags dynamically.

❓ scaling

advanced

How to design a feature flag system that scales to thousands of microservices with minimal latency?

You need a feature flag system for thousands of microservices worldwide. Which design choice best supports low latency and scalability?

A Embed feature flags in static config files updated monthly.

B Use a distributed cache with local caching in each microservice and periodic refresh.

C Store feature flags only in a single central server without caching.

D Make each microservice query the central database for flags on every request.

💡 Hint

Think about reducing network calls and load on central systems.

Local caching with a distributed cache reduces latency and load, allowing fast access to flags and scalability.

❓ tradeoff

advanced

What is a key tradeoff when using feature flags for rapid deployment in microservices?

Feature flags enable quick feature toggling but introduce complexity. What is a major tradeoff to consider?

A Automatic scaling of microservices without configuration.

B Complete elimination of bugs in production code.

C Increased code complexity and risk of stale flags causing unexpected behavior.

D Reduced need for testing before deployment.

💡 Hint

Think about what happens if flags are not cleaned up or managed well.

Feature flags add complexity and require careful management to avoid stale flags causing bugs or confusion.

❓ estimation

expert

Estimate the storage needed for feature flags in a microservices system with 5000 services and 100 flags each.

Each feature flag state is stored as a boolean (1 byte). Estimate the total storage in megabytes needed to store all flags for all services.

A Approximately 0.5 MB

B Approximately 5 MB

C Approximately 500 MB

D Approximately 50 MB

💡 Hint

Calculate total flags and convert bytes to megabytes (1 MB = 1,048,576 bytes).

5000 services * 100 flags = 500,000 flags. Each flag is 1 byte, so 500,000 bytes ≈ 0.48 MB, rounded to about 0.5 MB.

Practice

1. What is the main purpose of using feature flags in microservices?

easy

A. To increase database storage capacity

B. To enable or disable features without deploying new code

C. To improve network bandwidth

D. To encrypt communication between services

Solution

1. Step 1: Understand feature flags concept

   Feature flags allow toggling features on or off dynamically without changing the codebase.

2. Step 2: Identify the main benefit in microservices

   This helps in testing, gradual rollout, and quick disabling of features without redeployment.

3. Final Answer:

   To enable or disable features without deploying new code -> Option B

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 scaling
• Thinking feature flags improve network speed
• Assuming feature flags handle encryption

2. Which of the following is the correct way to check a feature flag named new_ui_enabled in a microservice?

easy

A. featureFlags.enable('new_ui_enabled')

B. if (featureFlags.check('new_ui_enabled') == false) { /* use new UI */ }

C. if (featureFlags.isEnabled('new_ui_enabled')) { /* use new UI */ }

D. featureFlags.remove('new_ui_enabled')

Solution

1. Step 1: Identify correct method to check flag status

   Checking if a feature flag is enabled usually uses a method like isEnabled returning true or false.

2. Step 2: Analyze options

   if (featureFlags.isEnabled('new_ui_enabled')) { /* use new UI */ } correctly checks if the flag is enabled before using the feature. if (featureFlags.check('new_ui_enabled') == false) { /* use new UI */ } incorrectly uses check and false condition. featureFlags.enable('new_ui_enabled') and featureFlags.remove('new_ui_enabled') modify flags, not check them.

3. Final Answer:

   if (featureFlags.isEnabled('new_ui_enabled')) { /* use new UI */ } -> Option C

4. Quick Check:

   Check flag with isEnabled() = if (featureFlags.isEnabled('new_ui_enabled')) { /* use new UI */ } [OK]

Hint: Use isEnabled() to check feature flags status [OK]

Common Mistakes:

• Using enable() or remove() to check flags
• Checking flag with wrong method or negation
• Confusing flag check with flag update

3. Consider this pseudocode snippet in a microservice:

if (featureFlags.isEnabled('beta_feature')) {
  return 'Beta feature active';
} else {
  return 'Beta feature inactive';
}

What will be the output if the flag beta_feature is set to false?

medium

A. Beta feature inactive

B. Beta feature active

C. Error: flag not found

D. No output

Solution

1. Step 1: Understand flag value effect on condition

   The condition checks if beta_feature is enabled (true). If false, it goes to else branch.

2. Step 2: Determine output when flag is false

   Since the flag is false, the else block executes returning 'Beta feature inactive'.

3. Final Answer:

   Beta feature inactive -> Option A

4. Quick Check:

   Flag false triggers else = Beta feature inactive [OK]

Hint: False flag runs else block output [OK]

Common Mistakes:

• Assuming false flag runs if block
• Expecting error when flag is false
• Ignoring else branch output

4. A developer wrote this code to disable a feature using a feature flag:

if (featureFlags.isEnabled('dark_mode')) {
  disableDarkMode();
}

Why might this code not work as intended?

medium

A. It disables dark mode when the flag is enabled, which is opposite logic

B. The method disableDarkMode() does not exist

C. Feature flags cannot control UI features

D. The flag name should be 'enable_dark_mode'

Solution

1. Step 1: Analyze the condition logic

   The code disables dark mode if the flag is enabled, which is opposite of expected behavior (usually enabled flag means enable feature).

2. Step 2: Identify correct logic for disabling feature

   To disable dark mode when flag is false, the condition should check if flag is disabled or negate the check.

3. Final Answer:

   It disables dark mode when the flag is enabled, which is opposite logic -> Option A

4. Quick Check:

   Enabled flag should enable, not disable [OK]

Hint: Enabled flag usually means feature ON, not OFF [OK]

Common Mistakes:

• Confusing enable and disable logic
• Assuming flag controls only backend features
• Using wrong flag names without checking

5. You want to roll out a new payment feature gradually using feature flags in a microservices system. Which design approach is best to ensure minimal impact and easy rollback?

hard

A. Disable all other microservices during rollout to avoid conflicts

B. Deploy new code with feature always enabled and monitor logs manually

C. Hardcode feature flag values in each microservice and update code to change flags

D. Use a centralized feature flag service with percentage rollout and fallback to old payment service

Solution

1. Step 1: Understand gradual rollout with feature flags

   Gradual rollout means enabling feature for a small percentage of users first, then increasing over time.

2. Step 2: Identify scalable and safe design

   A centralized flag service allows dynamic control and percentage rollout. Fallback ensures quick rollback if issues arise.

3. Step 3: Evaluate other options

   Deploy new code with feature always enabled and monitor logs manually lacks control and rollback ease. Hardcode feature flag values in each microservice and update code to change flags requires code changes for flag updates, not scalable. Disable all other microservices during rollout to avoid conflicts is disruptive and unnecessary.

4. Final Answer:

   Use a centralized feature flag service with percentage rollout and fallback to old payment service -> Option D

5. Quick Check:

   Centralized flags + gradual rollout = Use a centralized feature flag service with percentage rollout and fallback to old payment service [OK]

Hint: Centralized flags + gradual rollout = safe deployment [OK]

Common Mistakes:

• Hardcoding flags causing frequent deployments
• Disabling services unnecessarily during rollout
• Ignoring rollback strategies