What architectural problems appear only at scale?

1. Massive View Controllers / God Objects become load-bearing, not just ugly

The cost of touching shared code scales with team size, not app size.

2. Build time and modularization become a first-class architectural constraint

Drives splitting into multiple SPM modules for parallel compilation, and dependency graph discipline to avoid rebuild cascades.

3. Shared mutable state and singletons become genuinely dangerous

Dozens of features touch the same singleton, written by people who’ve never met.

4. Navigation/deep-linking complexity explodes combinatorially

Deep links, push notifications, universal links, state restoration, multiple entry points into the same screen.

5. Feature flag / experimentation infrastructure becomes architecturally load-bearing

Dozens of concurrent A/B tests running simultaneously.

6. Dependency injection and testability friction compounds nonlinearly

Without early investment in constructor injection, testing deep in the graph becomes so painful people stop doing it.

7. Database/persistence migration and schema evolution becomes a one-way door

A bad migration on millions of devices can be irreversible and silent.

8. Memory pressure and cold-launch performance become measured, competitive constraints

Launch time gets instrumented and tied to business metrics.

9. API/backend contract drift and versioning become a coordination problem

Users can run app versions from a year ago simultaneously with the latest backend.

10. Cross-team ownership boundaries force architecture to encode organizational structure

Conway’s Law stops being an observation and becomes a real design constraint.

The unifying theme

Small-scale problems are almost always about getting something built correctly and quickly. Large-scale problems are almost always about coordination cost — between people, time periods, and build/test feedback loops.

One-liner if pressed: “Small-scale problems are almost always about writing correct code quickly; large-scale problems are almost always about coordination cost — between engineers touching shared state or files, between build/test feedback loops that no longer fit in a lunch break, and between release cohorts running different app and backend versions simultaneously.”