Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsOne Go repository can run four separate long-lived processes without turning every application into the same service: this team gives site, shops, admin and worker separate entry points, then shares the code and data contracts that connect them. Antonio Towami describes the arrangement as a modular monolith: process boundaries are real, but the applications remain coordinated in one codebase.
What the four processes do
Each executable has a distinct role. The repository also contains an importer command, but Towami describes it as a CLI utility rather than a fifth long-running service.
As an Amazon Associate I earn from qualifying purchases.
| Entry point | Responsibility | Runs an HTTP server? |
|---|---|---|
site |
Marketplace portal and country catalogs, served on the main domain and country subdomains. | Yes |
shops |
Merchant storefronts on platform subdomains and custom domains. | Yes |
admin |
Back-office panel. | Yes |
worker |
Background tasks handled through Redis queues, including email, Telegram and imports. | No |
Separate entry points let the team run and manage these roles as separate processes. That does not mean each process has its own repository, model layer or versioned API.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →How shared code stays organized
All four binaries use a common internal/ package tree. The described application flow runs from router and middleware to handler, service, repository, and model/database, with templates and DTOs alongside those layers. Application-specific paths such as handler/site/, handler/shops/ and handler/admin/ keep the web applications distinct within that shared tree.
#1 Best Overall
Each binary imports the packages it needs rather than loading every application layer. In particular, worker does not import HTTP handlers or templates. That keeps its dependency set aligned with its background-job role, even though it shares other code with the web processes.
What Go enforces—and what it does not
Go’s internal directory rule is enforced by the toolchain: code outside the permitted parent tree cannot import those packages. It does not enforce the team’s proposed layer order. Keeping handlers, services and repositories in their intended roles is a convention supported by review and tests, not a restriction that internal/ itself provides.
Why keep the applications in one repository?
Towami gives three reasons for the shared repository. First, the applications use common product, shop and user models. Second, a change that crosses layers—such as updating a database column—can be made together in one commit. Third, the binaries can be deployed as independent service units without requiring an orchestration platform, service mesh or versioned APIs between these cooperating applications.
These are the author’s reasons for the design, not measured savings or a comparison against a tested alternative. A concise summary from Towami’s article is: “A Go monorepo with one cmd/ entry point per service gives us process-level separation while keeping atomic refactors and one go.mod.”
The key distinction is that independent processes do not automatically make an architecture microservices. Here, the executables are separate, while code and data contracts remain shared; Towami calls that a modular monolith.
How development avoids rebuilding every service
The article says the four builds use CGO_ENABLED=0 and produce self-contained binaries managed as independent service units. During development, each service runs in Docker with Air hot reload. A broad watcher can cause a shared-code change to trigger rebuilds for services that do not use the changed area.
Rank #4
The team’s fix is to scope file watching to each service. The examples describe exclusions rather than a universal configuration: the worker excludes templates, handlers, routers, assets and storage; admin excludes the site and shops handlers. The point is to avoid treating every repository change as relevant to every running process. The article does not provide configuration syntax or establish a quantified build-time improvement.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
When this boundary fits—and when to revisit it
In Towami’s account, the approach fits while the applications share a schema and are maintained by one team. It keeps related changes together while preserving separate process responsibilities. The author identifies independent ownership or a need for independent deployment as reasons to reconsider the boundary, but gives no threshold at which a split becomes preferable.
Best Value
For another team evaluating the same choice, the useful questions are about the shape of its dependencies and ownership—not the number of executables alone:
- Shared schema: Do the applications depend on common models and coordinated data contracts?
- Cross-layer changes: Is it valuable to make a database or model change across applications in one atomic commit?
- Ownership: Are the applications maintained by one team, or do they need independent ownership?
- Deployment: Is it enough to run separate binaries as service units, or is independent release and deployment a stronger requirement?
- Operational burden: Would separate repositories and API contracts solve a real coordination problem, or add overhead to applications that still change together?
These are decision axes implied by the author’s rationale, not measured results. The account describes one implementation, not a universal rule that a monorepo or a split repository is best.
What the account establishes
Towami’s article, published September 24, 2026, documents the team’s stated structure and rationale. It is a first-person implementation account, not an independent operational review: it does not report comparative performance, deployment-time measurements, or a quantified productivity gain. The practical takeaways are the separate responsibilities, selective imports from shared packages, and service-specific watch scopes—not a claim that this architecture is always faster or cheaper.
Recommended Free Tools
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
