A data-driven study of a large-scale micro component architecture. Live Q&A With Niklas Gustavsson

Welcome to this live Q&A session with Niklas Gustavsson! Niklas, Chief Architect at Spotify, will be sharing insights into the intriguing world of a large-scale micro component architecture. We'll also be addressing questions left unanswered from GSAS. Feel free to drop your questions in the YouTube chat during the live broadcast, and Niklas will be addressing them in real-time
Let's dive into the world of Software Architecture and innovation together!
--
The Global Software Architecture Summit (GSAS) is a 3-day event that aims to attract and connect software architecture experts from all over the world as well as all those interested in building working software to improve their skills, share knowledge, and connect.

The event features two days of talks by industry experts, and one day of workshops. It is focused on software architecture topics as backend & frontend development, DDD, mobile development techniques, software architecture models & beyond.

--
GSAS website: https://gsas.io/
Organizer site: https://apiumhub.com/
--
0:00 Introduction
2:53 CD/CI Pipeline. (Does each component possess its own CD/CI pipeline?)
5:00 Substituting Kubernetes Components. (If you were to initiate Spotify now, would you contemplate substituting Kubernetes components with cloud-based microservices (lambda, ECS, step functions, etc.)?
8:12 Architectural Decisions and Technical Debt. (How do you handle architectural decisions made by teams that could introduce technical debt? What safeguards do you have in place?)
10:33 Metric-Triggered Changes and Organizational Response. (Could you share an instance where a metric (fitness function) triggered a change and how the organization addressed it at a broader level?)
13:28 Compatibility Across Dependent Components. (How do you ensure compatibility across dependent components? Is it through contract testing or versioning?)
15:35 Codebase Organization in a Substantial Codebase. (With a substantial codebase, are you using a super repo, or are component codebases segregated in some manner? If so, how?)
17:40 What tools do you use to build diagrams?
19:18 How often do you need to version API?
23:00 Detecting Dependencies for Coupling. (When detecting dependencies for coupling, what mechanisms do you employ? Is it restricted to static code, API calls, or perhaps even dependency injection?)
24:37 How to handle authorization in a microservices environment.
25:15 Pull Request Reviews and Handling Dependencies. (How do you manage pull request reviews to handle the significant number of dependencies between squads and components?)
28:50 Updating Contracts and Component Versions. (When updating a contract, what approach do you adopt? Does a new version imply a new component?)
29:35 Unhelpful Metrics or Approaches and Lessons Learned. (Have you encountered any metrics or approaches that proved unhelpful? Any lessons learned?)
31:44 Number of Services Owned by a Squad. (Approximately how many services are owned by a squad?)
33:30 From an Architectural point of view what's your biggest pain point at spotify?
35:09 Automated Whole Component Generation. (How do you automatically generate a whole component? Could you describe the process in detail?)
38:26 Coordinating Releases and GitOps. (How do you coordinate releases of different components? Do you employ the GitOps methodology?)
40:50 Maintaining High-Performance for Synchronous Communication. (Considering the number of components connected during a request, how do you maintain high-performance rates for synchronous communication?)
43:40 Monorepos and Atomic Commits. (What is your perspective on monorepos, particularly concerning atomic commits and ensuring all dependencies work together?)
47:51 Smooth Handover of Component Ownership. (When changing ownership of components, how do you ensure a smooth handover? You mentioned that a team should own the full lifecycle).
49:50 Preventing Components from Becoming Outdated. (How do you ensure that components do not become outdated?)
50:59 Managing Overhead of Creating New Components. (How do you manage the overhead of creating new components, including new pipelines, storage clusters, configs, etc.?)
53:12 Do you employ consumer-driven contract testing?
53:25 Chaos Testing with Numerous Components. (With numerous components, do you conduct chaos testing?)
54:53 Correspondence Between Backend and Mobile Components. (Do you maintain a 1:1 correspondence between backend and mobile components?)
56:05 How do you introduce innovation in your teams?
58:40 Addressing Latency Issues and Designing for Functionality. (With this infrastructure, how do you address latency issues for user-facing or time-sensitive operations? Do you actively design to limit the length of a service call chain when designing functionalities?)
59:00 Closure