How do you think about a platform organisation and multi-year technical bets: charter, paved road, build versus buy versus Apple, sequencing and measuring success?
Predict first
Which is the best sign that an internal platform is succeeding?
// A: it has the most code
// B: product teams choose it by default, ship faster with it, and report that it saves them time
// C: it blocks all other approaches
- A
- B
- C
Mental model. Running a platform is running a road network for other drivers. Build the main highways everyone uses, keep them in repair, publish the rules, and do not close a road without opening a better one first.
At organisation level the question is how a hundred engineers ship quality faster over years. A platform team is justified when several product teams solve the same problem, and its customers are those engineers: it should have a written charter (what it owns and does not), a paved road (the default, supported way to do networking, persistence, analytics, navigation, design system, build and release that is easier than going alone) rather than mandates, product management of its own roadmap (user research with consuming teams, adoption and satisfaction as metrics), clear versioning and support (Q360, Q362), and a policy for exceptions. Without these a platform becomes either an ignored library or a bottleneck that product teams route around. Keep the layering honest (Q362), and measure outcomes the business feels: lead time from merge to users, deployment frequency, change failure rate and time to restore (the delivery-performance measures many organisations track), build and test times, crash-free sessions, app size and launch budgets, and accessibility and quality gates (Q432, Q453, Q477).
Multi-year bets in the Apple ecosystem include adopting Swift 6 concurrency across a large codebase (Q204), moving from UIKit to SwiftUI feature by feature, modularising the monolith, consolidating several apps or platforms onto a shared core (Q416, multi-brand), replacing a home-grown stack with a system framework as it matures, and building the observability and quality systems that make the others safe. Treat each as a portfolio decision. Write the hypothesis and kill criteria (“if build times have not fallen by a third after two modules, we stop”), sequence by risk and dependency (see the estimation question), deliver incremental value every quarter so the bet is not an all-or-nothing wager, fund maintenance as well as new work, and keep a deliberately small number of strategic bets. Prefer system APIs for commodity capabilities because Apple maintains them for the long term, buy for undifferentiated complexity with an exit plan, and build only for real differentiation. Plan for the platform’s own calendar: each year brings new OS releases, deprecations and privacy rules, so budget a standing slice of capacity for them. The L13 signal is judgement about what not to do, the ability to align several teams on one direction without command authority, and a track record of bets that were measured and, when wrong, stopped early.
A paved road wins by being the easier, better-supported path, and its success is measured by adoption and the speed and quality of the teams using it.
Common traps
- A platform that mandates but does not serve. Teams route around it, and the duplication it was meant to prevent returns.
- A multi-year bet with no checkpoints or kill criteria. It consumes years before anyone learns it was wrong.
They might follow up with
- How do you know the platform is working? Adoption by choice, delivery-performance and quality metrics, and satisfaction of the product teams.
- How many strategic bets at once? Few, each with a clear owner, hypothesis and review points.
Related questions
- 26.4.1 How do you write and run an RFC, record decisions as ADRs, set technical strategy, and decide between build…
- 26.3.1 How do you architect several brands or white-label apps from one codebase: configuration, theming, build…
- 26.3.2 How do you design an SDK or shared module for other teams: surface area, configuration, errors, concurrency…
- 5.7.1 What is the difference between the Swift 6 compiler and Swift 6 language mode?
- 15.6.2 How do you run a shared mobile platform for many apps and teams: layering, ownership, versioning and…
- 20.1.3 How do you run one shared core with several UI leaves on a single release train?
- 21.3.2 How do you build a performance culture on a team: budgets, regression gates, ownership and release guardrails?
- 22.7.2 How do you design a quality system for a large team: test tiers, ownership, coverage, flake budgets and…
- 24.5.2 How do you ship accessibility as a bar, not a backlog: a definition of done, accessible-by-default…
← How do you run an engineering incident, hold a blameless review, and…