Mono-repo vs multi-repo in Microservices - Design Approaches Compared

Design: Code Repository Strategy for Microservices

Design the repository structure and management approach for microservices codebase. Exclude detailed CI/CD pipeline design and deployment infrastructure.

Functional Requirements

FR1: Support development of multiple microservices by different teams

FR2: Enable easy code sharing and reuse across services

FR3: Allow independent deployment and versioning of microservices

FR4: Maintain code quality and consistency across the organization

FR5: Support scalable CI/CD pipelines

FR6: Provide clear access control for different teams

Non-Functional Requirements

NFR1: Must handle up to 100 microservices

NFR2: Support up to 50 concurrent developers

NFR3: CI/CD pipeline latency should be under 15 minutes for builds

NFR4: Availability of repository access should be 99.9%

NFR5: Support branching and merging strategies without conflicts

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

Version control system (e.g., Git)

Build and CI/CD pipelines

Code sharing and dependency management

Access control and permissions

Branching and merging strategies

Code review and quality tools

Design Patterns

Monorepo pattern

Multirepo pattern

Feature branching

Trunk-based development

Dependency versioning

Access control models

Reference Architecture

                    +---------------------+
                    |    Developers       |
                    +----------+----------+
                               |
          +--------------------+--------------------+
          |                                         |
  +-------v-------+                         +-------v-------+
  |   Mono-repo   |                         |  Multi-repo   |
  | (Single repo) |                         | (Multiple repos) |
  +-------+-------+                         +-------+-------+
          |                                         |
  +-------v-------+                         +-------v-------+
  | CI/CD Pipeline|                         | CI/CD Pipeline|
  +---------------+                         +---------------+

Components

Version Control System

Git

Store and manage source code for microservices

Mono-repo

Single Git repository

All microservices code in one repository for easy code sharing and atomic changes

Multi-repo

Multiple Git repositories

Separate repository per microservice for independent versioning and deployment

CI/CD Pipeline

Jenkins/GitHub Actions/GitLab CI

Automate build, test, and deployment processes

Access Control

Git permissions and branch protections

Control who can read or write to repositories or branches

Dependency Management

Package managers (npm, Maven, etc.)

Manage shared libraries and versions across microservices

Request Flow

1. Developer clones the mono-repo or relevant microservice repo(s).

2. Developer makes code changes locally.

3. Developer pushes changes to the repository.

4. CI/CD pipeline triggers build and tests for affected microservices.

5. If tests pass, code is merged and deployed independently or together depending on repo strategy.

6. Shared code updates in mono-repo are immediately available to all microservices.

7. In multi-repo, shared code updates require version bumps and dependency updates in each microservice.

Database Schema

Not applicable as this design focuses on code repository structure and management.

Scaling Discussion

Bottlenecks

Mono-repo can become very large, slowing down cloning and CI builds.

Multi-repo can cause dependency version conflicts and harder code sharing.

CI/CD pipelines may become slow with many microservices in mono-repo.

Access control is more complex in mono-repo due to shared repository.

Coordination overhead increases in multi-repo when updating shared libraries.

Solutions

Use shallow clones and sparse checkouts to speed up mono-repo operations.

Implement incremental and parallel builds in CI/CD pipelines.

Use automated dependency versioning tools to manage multi-repo shared code.

Apply fine-grained access controls and branch protections in mono-repo.

Establish clear versioning and release policies for shared libraries in multi-repo.

Interview Tips

Time: Spend 10 minutes discussing requirements and constraints, 15 minutes comparing mono-repo and multi-repo approaches, 10 minutes on scaling challenges and solutions, and 10 minutes on trade-offs and recommendations.

Explain the trade-offs between mono-repo and multi-repo clearly.

Discuss how team structure and deployment frequency influence repo choice.

Highlight impact on CI/CD pipelines and developer productivity.

Mention strategies to mitigate scaling issues for each approach.

Show understanding of access control and dependency management challenges.