Backend Handbook
Leapwise
  • 👋Introduction
  • Software Design Principles & Clean Code
    • Atomicity
    • Modularity
    • Hierarchy
    • Loose coupling
    • Asynchronous programming
  • Development Practices
    • JavaDocs
    • Technical Debt
    • Testing Guidelines
      • The Importance of Test Automation
      • The Testing Pyramid
        • Unit Tests
        • Integration Tests
        • End-to-End Tests
      • Mutation Testing
      • Contract Tests
        • REST Controller Contract testing
        • OpenAPI Contract testing
      • Testing Frameworks
        • JUnit 5
        • Testcontainers
        • Mockito
      • Writing Clean Tests - Best Practices
    • Common library
    • Generic CRUD
    • Update Facade
  • Development Tools & Environment
    • Monitoring
    • Performance tuning
    • Multi-tenancy & Configuration Management
    • Git practices
    • CI/CD
    • Maven
  • Project Management
    • Jira
    • Confluence documentation
    • SCRUM
    • Our ways of working
  • LIFE AT LEAPWISE
    • Introduction
    • Who are we?
    • What do we do?
    • Our values
    • Hiring process
      • Hiring: A Mid Frontend Developer's Point of View
    • Benefits we offer
    • Onboarding process
      • Onboarding: A Senior Digital Marketing Specialist's perspective
    • Mentorship program
    • Career development
      • Trainings & certificates we offer
      • Career development: A Senior Software Developer's Insight
    • Community building
    • Juniorship
    • First-hand info from our first team member
    • Join our team
Powered by GitBook
LogoLogo

Company

  • About
  • Culture
  • Services

Insights

  • Leapwise Newsletter
  • Blog

© Leapwise

On this page
  • Introduction
  • Custom solution

Was this helpful?

  1. Development Tools & Environment

Multi-tenancy & Configuration Management

Introduction

In our development process, a crucial question arises: Should developers create packages tailored specifically for the testing phase, or should they produce the latest version of the application with changes in implementation for the QA team to test? Opting for the latter approach necessitates manual configuration of all parameters each time, which proves to be time-consuming and tedious for the QA team, hindering their ability to effectively test, reproduce, and report any issues.

Therefore, the former solution, where we build a version of the application tailored for the specific environment, emerges as the optimal choice. It's important to note that achieving this can be facilitated through various methods and integration with tools like Jenkins. For instance, configuration management can be handled using tools such as Ansible, Terraform, or Attune. While building packages individually for each environment version may require more storage space and slightly longer build times, it ultimately ensures thorough testing and deployment across all desired versions of the software.

Custom solution

To address this challenge, we've implemented a project-level solution focused on defining the packaging of various software versions. Much like crafting different editions of a product to suit diverse markets, we've customized our software to precisely match the requirements of each deployment environment.

Within this project-level setup, we've developed a streamlined methodology for packaging our software versions. This approach ensures that our deployment process is not only smooth but also maximizes performance and reliability across different environments.

With our tailored packaging strategy firmly in place, we've established a robust framework for deploying our software efficiently and effectively, regardless of the target environment.

PreviousPerformance tuningNextGit practices

Last updated 1 year ago

Was this helpful?

Page cover image