[Session Report][AP-05]Breaking down monoliths into microservices with LaunchDarkly #AWS Summit



This is Pooja from the Alliance Department. This blog is an overview about the session that was presented by LaunchDarkly, with Mr Roderick Clemente as the keynote speaker during the AWS Summit Tokyo held on the 20th of April 2023.

What's LaunchDarkly

LaunchDarkly is a software-as-a-service (SaaS) solution that provides developers with a platform to effectively manage feature flags. By separating feature rollouts from code deployments, LaunchDarkly empowers developers to test their code in real-time in a production environment, gradually release features to specific user groups, and effectively manage feature flags at every stage of their lifecycle. This approach enables developers to release high-quality software with reduced risks.

LaunchDarkly: Feature Flag & Toggle Management

Session contents

The session was about "Breaking down monoliths into microservices", that was accompanied by an interactive demo that had the following key points that were talked about:

  • Kill Switch
  • User Targeting
  • Deconstruction of Monolithic architecture.

Kill Switch

A kill switch is a button that allows a designated user to deactivate a specific feature as needed. This provides the ability to disable a feature quickly and easily with a simple button press or click, and it doesn't necessarily require technical expertise, making it convenient for non-engineers or non-programmers to use in urgent situations where a feature needs to be turned off promptly.


Feature flags, also known as feature toggles, release toggles, or feature flippers, are a software development concept that provides the ability to enable or disable a feature without making changes to the source code or requiring a redeployment.

Your first feature flag

Feature flags can serve as effective kill switches, whether they are permanent or temporary. By encapsulating a specific feature with a feature flag, it becomes possible to quickly deactivate the feature if it is causing problems or underperforming.


User Targeting

User targeting, in the context of software development and product management, refers to the practice of selectively delivering specific features, content, or experiences to different groups of users based on predefined criteria or characteristics. This can be achieved through the use of feature flags, A/B testing, personalized content, or other techniques. User targeting allows product teams to tailor the user experience based on factors such as user behavior, demographics, preferences, or past interactions with the product. It enables more personalized and relevant experiences for different segments of users, improving user satisfaction and engagement.

Targeting Users with Feature Flags | by LaunchDarkly | launchdarkly | Medium

Deconstruction of Monolithic architecture

A monolithic software application is one where multiple features and responsibilities are tightly interconnected. The ability of the application to evolve quickly is closely tied to its overall performance. However, monoliths are complex and tightly coupled, which presents numerous challenges in maintenance, prompting many to consider migrating to a more manageable architecture.

Guide: What to Know Before Migrating Legacy, Monolithic, or Existing Applications to Microservices | LaunchDarkly
Microservice architecture offers a compelling option for decoupling monolithic applications, providing notable enhancements in maintenance, deployment, and scalability. When facing challenges in introducing new features, upgrading existing ones, or frequently releasing updates in a monolithic setup, transitioning to a microservices approach may be a viable solution.
Hence the steps involved in deconstructing a monolithic architecture to a microservice architecture are as follows:
  1. Understand the existing monolithic architecture.
  2. Define microservices boundaries and responsibilities.
  3. Design the architecture of microservices, including APIs, data models, and communication patterns.
  4. Refactor monolithic code to extract functionalities for microservices.
  5. Implement microservices individually, using appropriate technologies.
  6. Set up communication and coordination mechanisms between microservices.
  7. Test and validate the microservices architecture.
  8. Iterate and improve based on feedback and performance metrics.


In conclusion, transitioning from a monolithic architecture to a microservices architecture can bring significant benefits to software development, including improved scalability, maintainability, and flexibility. Careful planning, design, and implementation are essential for a successful transition. With proper execution, the move to microservices can result in more agile, adaptable, and scalable software systems.

I hope this blog was able to capture and summarise the session. Thank you for your time.

Happy Learning!!!