Optimal Go Directory Structure in a Large Polyglot Monorepo

Posted on in programming

cover image for article


When managing a large polyglot monorepo containing Go code alongside other languages, structuring directories appropriately is crucial for maintainability, scalability, and developer productivity. Go, or Golang, with its unique perspectives on dependency management and package structuring, requires thoughtful consideration to fit seamlessly within a broader, heterogeneous codebase. This blog post explores the best practices for structuring directories for Go code within a large polyglot monorepo.

Core Principles of Go Project Structuring

Before diving into specifics, let's highlight some core principles specific to Go:

  1. Package-centric Design: Go emphasizes the importance of packages as the unit of code sharing and reuse. Proper packaging can significantly ease dependency management and improve compile times.
  2. Clarity and Simplicity: The Go philosophy nurtures simplicity; this should reflect in the directory structure, making it intuitive and straightforward.
  3. Reproducible Builds: Environment consistency and the ability to reproduce builds are paramount in Go. The use of Go Modules aids in achieving this by handling dependencies explicitly.

Recommended Directory Structure for Go in a Monorepo

Given these principles, the following structure is recommended for incorporating Go into a polyglot monorepo:

    /docs          # Documentation for the repo at large
    /tools         # Tools and scripts for the entire monorepo
    /services      # Where individual services or projects reside
        /service-a # Service A (could be in a different language)
        /service-b # Service B, a Go-based service
                /service-b   # Main application for the service
                    main.go  # Entry point of the service
            /internal        # Private application and library code
                /api         # Internal API specific logic
                /dal         // Data access layer
            /pkg             # Library code usable by external applications
                /db          # Database related operations
                /util        # Utilities and helpers
            go.mod           # Go module file
            go.sum           # Go checksum file
        /service-c # Service C (could be in a different language)
    /libraries     # Shared libraries used across services
        /go         # Go specific libraries
            /netlib # Example: a network library
/assets          # Other assets like images, logos, etc used across projects


  • CMD Directory: This contains executables or main applications. Each main application that can be built into an executable should be kept in its subdirectory under cmd, with the directory name matching the executable name.
  • Internal vs. PKG: internal directory hosts private code that should not be used by external applications, helping encapsulate service-specific implementations. In contrast, pkg directory is intended for code that can safely be imported by other services within the monorepo without compromising the integrity of the service internals.
  • Modularity with go.mod: Each service or library that requires dependencies should maintain its own go.mod and go.sum files. This modular approach ensures that updates or changes in one service’s dependencies do not interfere with others.

Advantages of This Structure

  1. Isolation: Changes in one service or library are less likely to accidentally impact others.
  2. Scalability: New services can be added smoothly without the need to adjust existing directory layouts.
  3. Flexibility: Easily accommodate services in different programming languages or frameworks without disrupting the Go codebases.
  4. Simplification of CI/CD Pipelines: Build and test scripts can target specific subdirectories, optimizing build times and resource utilization.


Adopting a strategic directory structure in a monorepo when working with Go is crucial to ensuring robust, scalable, and maintainable systems. By adhering to Go's design philosophies and organizing directories as recommended, you can foster a productive development environment conducive to both small-scale and enterprise-grade software engineering.

Implementing such structure will facilitate not just ongoing development but also onboarding new developers, scaling up your development teams, and managing dependencies in an efficient and controlled manner.


Slaptijack's Koding Kraken