Hidden Cost of Developing Software

Key Concepts

Mono Repo, Poly Repo, Frontend Development, Local Environment, QA (Quality Assurance) Environment, Production Environment, Deployment Time, Development Time, Authentication, UI (User Interface), Firebase Emulator, Access Levels (Level 1, Level 2, Level 3), Scalability, Security.

Hidden Cost of Poly Repo Architecture in Software Development

This video discusses a hidden cost associated with transitioning from a monorepo to a polyrepo architecture as a software company scales. The speaker, co-founder of Bump Ups, shares his real-world experience and provides insights into the implications of this architectural shift on frontend development workflows.

Monorepo vs. Polyrepo: A Quick Recap

• Monorepo: All code (frontend, backend, etc.) resides in a single repository.
• Polyrepo: Code is fragmented into multiple repositories (e.g., UI in one repo, purchase backend logic in another).

The video references another video (linked in the description) explaining why scaling companies often need to move from a monorepo to a polyrepo for reasons like security and scalability.

The Hidden Cost: Frontend Development Workflow Changes

The core of the video focuses on how the polyrepo architecture impacts frontend development, specifically introducing three levels of access and a shift in the development environment.

Access Levels in Polyrepo Frontend Development

1. Level 1: UI Repository Access (Unauthenticated Pages)
   • Developers only have access to the UI repository, allowing them to edit code for unauthenticated pages (e.g., landing pages, pricing pages).
   • Workflow is similar to monorepo development: npm start, Localhost 3000, instantaneous changes.
   • Example: Editing the "Go to Pricing" section on the landing page.
2. Level 2: UI + Authentication Repository Access
   • Developers have access to the UI repository and an authentication repository (e.g., "auth repo").
   • Enables login/sign-in functionality in the local environment.
   • Still allows for instantaneous changes in Localhost 3000.
   • Example: Making changes to the login popup or the links page after logging in.
3. Level 3: UI Repository Access (QA Environment)
   • Developers only have access to the UI repository.
   • Authentication is not relevant in the local environment.
   • Workflow shifts from Localhost 3000 to a QA (Quality Assurance) environment.
   • This is where the hidden cost manifests.

The QA Environment and Development Delay

• Local (L): Local development environment (Localhost 3000), no internet required.
• QA: Staging environment for testing code changes before pushing to production.
• Production (Prod): Live website (e.g., bumpups.com).

In a polyrepo setup, Level 3 developers (those working on authenticated features) must push their changes to the QA environment to see them reflected in the frontend. This introduces a delay (7-12 seconds, according to the speaker) compared to the instantaneous changes in a monorepo.

• Example: Changing "bump shortcuts" to "bump short" would instantly reflect in a monorepo's Localhost 3000. In a polyrepo, this change requires pushing to QA, causing a delay.

The speaker emphasizes that this delay, while seemingly small, accumulates over time and slows down the overall development process.

Why Polyrepo Despite the Drawbacks?

The speaker reiterates that the move to a polyrepo is driven by factors like security, scalability, and managing a growing team, as explained in the linked video.

Technical Challenges and Port Conflicts

The speaker explains that running multiple code repositories on the same local machine can lead to port conflicts. For example, the Firebase emulator uses Localhost 4000, and functions might use ports like 5001 or 5005. Simultaneously running multiple repos with overlapping port configurations becomes nearly impossible.

This limitation is a key reason why Level 3 developers must rely on the QA environment for testing their changes.

Notable Quotes

• "monor repo faster development poly repo slower development" - This summarizes the core trade-off discussed in the video.

Synthesis/Conclusion

While a polyrepo architecture offers advantages in terms of security and scalability for growing software companies, it introduces a hidden cost in the form of slower frontend development times. This is primarily due to the shift from instantaneous local changes to a QA-based workflow for developers working on authenticated features. The speaker highlights the importance of understanding this trade-off when making architectural decisions for a software company.