In hyper-growth environments, code scales effortlessly, but teams often hit invisible walls. Charlotte de Jong Schouwenburg’s talk explores why human cooperation breaks down under communication overload and lost context, and how leaders can apply behavioral scalability tools—like communication architecture and 'engineering trust'—to sustain high-performing, autonomous teams without sacrificing speed or culture. The following Q&A unpacks these insights.
Why do teams fail to scale as smoothly as code does?
Code is deterministic: add more servers, it runs faster. Human teams, however, are nonlinear. As headcount grows, the number of communication channels explodes—from n to n(n-1)/2. This leads to information overload, decision bottlenecks, and context that gets lost in email threads or Slack channels. Charlotte explains that while systems are architected for scale, human cooperation is often left to chance. Without intentional design, the trust and shared understanding that worked in a small team dissolve. Leaders must recognize that scaling people requires behavioral infrastructure—not just hiring more talent.
What exactly is 'communication overload' and how does it hurt teams?
Communication overload happens when the volume and frequency of messages exceed what people can process effectively. In a 10-person team, everyone can stay aligned with a few daily conversations. In a 100-person team, the same approach creates noise: constant notifications, redundant updates, and fragmented discussions. Charlotte notes that this overload slows decision-making, increases stress, and causes context switching that kills deep work. The result is that teams spend more time coordinating than creating. To combat this, leaders must architect communication channels—for example, using asynchronous updates, topic-specific forums, and clear escalation paths—so information flows without drowning people.
How does lost context become a 'human bottleneck' in hyper-growth?
When teams grow quickly, institutional knowledge scatters. New hires lack the backstory of earlier decisions, and existing members assume shared context that no longer exists. Charlotte highlights that this lost context leads to duplicated work, misaligned priorities, and re-litigation of past decisions. It also erodes trust because people can’t rely on others’ understanding. For example, a developer might make a technical choice based on obsolete assumptions, causing rework. Solving this requires deliberate practices: maintaining decision logs, onboarding docs, and regular 'context refresh' sessions. Leaders must treat shared context as a first-class resource, just like code documentation.
What is behavioral scalability and how does it differ from technical scalability?
Technical scalability is about adding capacity (servers, storage) without degradation. Behavioral scalability, per Charlotte, is about adding people without degrading collaboration quality. While code can be replicated perfectly, human behaviors—like trust, communication patterns, and decision-making—don’t scale by default. Technical scalability relies on architecture (e.g., microservices, load balancers). Behavioral scalability requires communication architecture and engineering trust—that is, designing explicit norms, rituals, and tools that keep cooperation efficient. For instance, a team may adopt 'request-for-comment' templates to align decisions, or use trusted decision boards to empower autonomy. The goal is to preserve the culture of a small team even as numbers multiply.
What does 'engineering trust' mean in practice?
Trust is often seen as an intangible feeling, but Charlotte argues it can be engineered through systems. Practically, 'engineering trust' means creating structures that make reliability observable: clear role definitions, transparent progress tracking, and consistent accountability. For example, a team might use daily stand-ups that focus on blockers and commitments, not status updates, to build trust that everyone is aligned. Another practice is 'promise-based management'—when someone commits to a task, the system tracks completion and flags delays. This removes ambiguity and builds confidence. Trust also flourishes when leaders model vulnerability by admitting mistakes. By designing feedback loops and shared ownership, trust becomes a repeatable process, not a personality trait.
How can leaders maintain autonomous teams without losing speed?
Autonomy and speed often seem at odds—autonomous teams might slow down due to misalignment. Charlotte suggests using guardrails instead of command-and-control. Guardrails are clear boundaries (e.g., budget, timeline, security requirements) within which teams are free to decide. This preserves speed because teams don’t need permission for every move. Additionally, autonomous teams need a 'decision hierarchy' that clarifies who decides what. For example, product teams should decide features, but architecture boards approve infrastructure changes. To maintain speed, leaders must invest in asynchronous communication tools (like decision logs) that allow teams to proceed without waiting for meetings. The key is to balance alignment with empowerment: give teams clarity on 'why' and 'what restricts', then let them figure out 'how' fast.
What are the first steps to implement behavioral scalability tools?
Charlotte recommends starting with a communication audit: map all channels (email, Slack, meetings, docs) and identify where overload or lost context occur. Next, define a communication architecture: for instance, a 'channel taxonomy' where each type of message lives in a dedicated place (e.g., #help for urgent questions, RFC docs for proposals). Then, introduce one or two trust-building rituals: a weekly 'context sync' for cross-team awareness, or a decision log template. Leaders should also model the desired behavior—like clearly closing out decisions in writing. Finally, measure impact: track time spent in meetings vs. deep work, or survey team trust levels. The goal is to iterate: small experiments can quickly show whether a new norm reduces bottlenecks. As Charlotte emphasizes, human scaling requires the same intentional design as code scaling.