@forwardimpact/schema 0.3.0 → 0.6.0

package/examples/questions/behaviours/relentless_curiosity.yaml

@@ -1,50 +1,248 @@
 # yaml-language-server: $schema=https://www.forwardimpact.team/schema/json/behaviour-questions.schema.json
 
-emerging:
-  - id: cur_emerg_1
-    text: What new technology or concept have you learned recently?
-    lookingFor:
-      - Evidence of learning
-      - Interest beyond immediate work
-    expectedDurationMinutes: 5
-developing:
-  - id: cur_dev_1
-    text:
-      Tell me about a time when you went beyond the requirements to understand
-      something deeper.
-    lookingFor:
-      - Self-directed exploration
-      - Root cause thinking
-    expectedDurationMinutes: 5
-practicing:
-  - id: cur_pract_1
-    text: How do you stay current with developments in your field?
-    lookingFor:
-      - Systematic learning approach
-      - Breadth of interests
-    expectedDurationMinutes: 5
-role_modeling:
-  - id: cur_role_1
-    text: How do you foster a culture of curiosity in your team?
-    lookingFor:
-      - Creating learning environments
-      - Encouraging exploration
-    expectedDurationMinutes: 8
-exemplifying:
-  - id: cur_exemp_1
-    text:
-      How do you shape organizational culture around curiosity and continuous
-      learning at an enterprise level?
-    followUps:
-      - How do you sponsor experimental initiatives?
-    lookingFor:
-      - Enterprise learning culture leadership
-      - Sponsoring innovation and experimentation
-    expectedDurationMinutes: 10
-  - id: cur_exemp_2
-    text:
-      How do you influence industry practices around innovation and exploration?
-    lookingFor:
-      - External thought leadership
-      - Industry-level influence on learning culture
-    expectedDurationMinutes: 10
+professionalQuestions:
+  emerging:
+    - id: cur_pro_emerg_1
+      text:
+        You've been assigned to fix a bug in a service you've never worked on.
+        The fix is straightforward but you don't understand why the code is
+        structured the way it is.
+      context:
+        The service handles payment reconciliation. The bug is a simple
+        off-by-one error in a date filter. The codebase uses patterns you
+        haven't seen before — event sourcing with a custom projection layer.
+        Your team lead said "just fix the bug and move on."
+      simulationPrompts:
+        - Would you just fix the bug or try to understand the broader system?
+        - What questions would you ask about the codebase?
+        - How would you decide how deep to go given you were told to move on?
+        - What would you do if you found something else that looked wrong while
+          investigating?
+      lookingFor:
+        - Shows curiosity beyond the immediate task
+        - Asks meaningful questions about why, not just what
+        - Willing to explore unfamiliar territory
+        - Balances curiosity with practical delivery
+      expectedDurationMinutes: 20
+
+  developing:
+    - id: cur_pro_dev_1
+      text:
+        Your team's CI pipeline takes 45 minutes. Everyone accepts it as normal.
+        You suspect it could be much faster but nobody has investigated.
+      context:
+        The pipeline runs unit tests, integration tests, and two rounds of
+        linting. It was set up 2 years ago and has been added to but never
+        optimized. When you mentioned it might be slow, a senior engineer said
+        "it's fine, we're used to it." You have no pipeline expertise.
+      simulationPrompts:
+        - How would you investigate this despite not being a CI expert?
+        - What would your first experiment be?
+        - How would you approach learning about pipeline optimization?
+        - How do you handle the pushback from the senior engineer who thinks
+          it's fine?
+      lookingFor:
+        - Investigates root causes independently
+        - Experiments with unfamiliar technology without fear of failure
+        - Seeks to understand how things work rather than accepting the status
+          quo
+        - Shows self-directed exploration patterns
+      expectedDurationMinutes: 20
+
+  practicing:
+    - id: cur_pro_pract_1
+      text:
+        A new AI coding tool claims to reduce development time by 50%. Your
+        company is considering adopting it but wants someone to evaluate it
+        thoroughly.
+      context:
+        The tool is a code generation agent that can handle entire user stories.
+        Marketing materials are impressive but vague on limitations. Your
+        company has 60 engineers. You've been given 2 weeks to evaluate it and
+        make a recommendation. No one on your team has used AI agents beyond
+        basic copilot tools.
+      simulationPrompts:
+        - How would you design your evaluation? What would you test?
+        - How do you separate marketing claims from reality?
+        - What failure modes would you specifically look for?
+        - How would you structure your findings to help the organization decide?
+      lookingFor:
+        - Systematic approach to investigating new technology
+        - Treats the evaluation as discovery, not confirmation
+        - Protects time for thorough exploration
+        - Discovers requirements through immersion in the problem space
+      expectedDurationMinutes: 20
+
+  role_modeling:
+    - id: cur_pro_role_1
+      text:
+        Your team consistently delivers features on time but rarely questions
+        whether they're building the right things. Product requirements are
+        accepted at face value.
+      context:
+        Over the last 6 months, 2 features were shipped and then unused because
+        the underlying assumptions were wrong. The team is highly skilled at
+        execution but doesn't push back on requirements or explore the problem
+        space. When you've asked "why are we building this?" in planning, you
+        get polite but empty answers.
+      simulationPrompts:
+        - How would you shift the team culture toward questioning and discovery?
+        - How do you model curiosity without slowing delivery?
+        - What specific practices would you introduce?
+        - How do you create safety for engineers to challenge assumptions?
+      lookingFor:
+        - Drives curiosity through challenging questions
+        - Creates environments where exploration is encouraged
+        - Models problem discovery orientation
+        - Seeks out ambiguity rather than avoiding it
+      expectedDurationMinutes: 20
+
+  exemplifying:
+    - id: cur_pro_exemp_1
+      text:
+        Your organization wants to become "AI-native" but most teams treat AI
+        tools as autocomplete. There's no culture of experimentation with new AI
+        capabilities.
+      context:
+        The company has 200+ engineers. AI tool licenses are available to
+        everyone but usage data shows 80% of usage is basic code completion.
+        Only 3 teams have experimented with AI agents. The CTO has asked you to
+        lead a transformation toward deeper AI integration. Budget is available
+        but cultural resistance is strong.
+      simulationPrompts:
+        - How do you create a culture of experimentation at organizational
+          scale?
+        - How do you sponsor initiatives that might fail?
+        - How do you influence engineers who are skeptical or intimidated by AI?
+        - How would you share learnings across 200+ engineers effectively?
+      lookingFor:
+        - Shapes organizational culture around curiosity and learning
+        - Sponsors experimental initiatives across the organization
+        - Recognized as a thought leader in problem discovery
+        - Influences practices around innovation and exploration
+      expectedDurationMinutes: 20
+      followUps:
+        - How would you measure whether the organization is becoming more
+          curious?
+
+managementQuestions:
+  emerging:
+    - id: cur_mgmt_emerg_1
+      text:
+        A team member asks if they can spend a day investigating a new database
+        technology. Your sprint is fully committed and you're behind by 2 story
+        points.
+      context:
+        The team member is your most productive engineer. The database
+        technology could solve a scaling problem you'll face in 3 months. You've
+        never managed competing priorities between exploration and delivery
+        before. Your manager tracks sprint velocity closely.
+      simulationPrompts:
+        - How do you decide whether to approve the exploration time?
+        - How would you frame this to your manager?
+        - What boundaries would you set on the exploration?
+        - How do you make this a learning opportunity regardless of the outcome?
+      lookingFor:
+        - Supports team learning and exploration
+        - Shows awareness of balancing curiosity with delivery
+        - Creates space for investigation even under pressure
+        - Treats learning as valuable, not wasteful
+      expectedDurationMinutes: 20
+
+  developing:
+    - id: cur_mgmt_dev_1
+      text:
+        You notice your team only learns reactively — they pick up new skills
+        when forced by a project requirement but never explore proactively.
+      context:
+        The team of 7 engineers is competent and delivers well. But when a
+        project required Kubernetes knowledge, nobody had it and the team
+        scrambled. This has happened 3 times in the past year. Engineers say
+        they'd love to learn but "there's never time."
+      simulationPrompts:
+        - How would you create structured opportunities for exploration?
+        - How do you make learning feel safe, not like extra work?
+        - What would you do if an exploration produces no tangible outcome?
+        - How do you balance your delivery commitments with learning time?
+      lookingFor:
+        - Creates time and space for exploration
+        - Balances delivery with learning proactively
+        - Encourages experimentation without fear of failure
+        - Makes curiosity part of the team's rhythm, not an exception
+      expectedDurationMinutes: 20
+
+  practicing:
+    - id: cur_mgmt_pract_1
+      text:
+        Two of your teams have different approaches to adopting new technology.
+        One team experiments constantly but ships slowly. The other never
+        experiments but delivers predictably.
+      context:
+        You manage both teams. The experimental team has found valuable
+        innovations but missed deadlines 3 times. The predictable team delivers
+        on time but their tech stack is becoming outdated. Leadership is
+        starting to question the experimental team's reliability.
+      simulationPrompts:
+        - How do you calibrate the right level of exploration for each team?
+        - What would you take from each team's culture to improve the other?
+        - How do you protect the experimental team from leadership pressure?
+        - How do you encourage the predictable team to question their
+          assumptions?
+      lookingFor:
+        - Builds team culture that values questioning assumptions
+        - Calibrates exploration against delivery needs
+        - Protects space for curiosity while maintaining accountability
+        - Creates sustainable patterns for experimentation
+      expectedDurationMinutes: 20
+
+  role_modeling:
+    - id: cur_mgmt_role_1
+      text:
+        Your engineering function is solving the same problems repeatedly across
+        teams because there's no culture of sharing discoveries or asking "has
+        anyone solved this before?"
+      context:
+        You lead 3 teams with 25 engineers total. In the last quarter, two teams
+        independently built similar caching solutions. Another team
+        re-investigated a technology that was evaluated and rejected 6 months
+        ago. Engineers are curious individually but there's no collective
+        curiosity.
+      simulationPrompts:
+        - How do you create collective curiosity, not just individual curiosity?
+        - What structures would you put in place for sharing discoveries?
+        - How do you model curiosity visibly as a leader?
+        - How do you make "has anyone solved this?" the first question, not the
+          last?
+      lookingFor:
+        - Models curiosity visibly in leadership
+        - Creates environments where discoveries are shared
+        - Builds collective inquiry practices
+        - Drives curiosity as a cultural value across teams
+      expectedDurationMinutes: 20
+
+  exemplifying:
+    - id: cur_mgmt_exemp_1
+      text:
+        The organization wants to launch an internal innovation program but
+        previous attempts failed because they felt disconnected from real work.
+      context:
+        Two previous "hack week" programs were cancelled after low
+        participation. Engineers felt the initiatives were performative — good
+        ideas went nowhere after the event. Leadership still believes in the
+        concept but wants a different approach. You've been asked to design
+        something that creates genuine, sustainable curiosity.
+      simulationPrompts:
+        - Why did previous programs fail and how would yours be different?
+        - How do you build organizational systems that reward genuine curiosity?
+        - How do you ensure discoveries from the program feed back into real
+          work?
+        - How do you coach other managers to foster curiosity in their teams?
+      lookingFor:
+        - Builds organizational systems that reward curiosity
+        - Creates sustainable exploration programs, not performative ones
+        - Coaches other managers on fostering curiosity
+        - Balances predictable delivery with organizational learning
+      expectedDurationMinutes: 20
+      followUps:
+        - How do you handle the inevitable pushback from delivery-focused
+          managers?

package/examples/questions/behaviours/systems_thinking.yaml

@@ -1,52 +1,238 @@
 # yaml-language-server: $schema=https://www.forwardimpact.team/schema/json/behaviour-questions.schema.json
 
-emerging:
-  - id: sys_emerg_1
-    text:
-      How do you consider the impact of your code changes on other parts of the
-      system?
-    lookingFor:
-      - Awareness of dependencies
-      - Basic impact thinking
-    expectedDurationMinutes: 5
-developing:
-  - id: sys_dev_1
-    text:
-      Describe a time when you identified an unintended consequence of a change.
-    lookingFor:
-      - Systemic awareness
-      - Proactive identification
-    expectedDurationMinutes: 5
-practicing:
-  - id: sys_pract_1
-    text: How do you approach understanding a complex system you're new to?
-    lookingFor:
-      - Systematic exploration
-      - Mapping approaches
-    expectedDurationMinutes: 8
-role_modeling:
-  - id: sys_role_1
-    text: How do you help others develop systems thinking capabilities?
-    lookingFor:
-      - Teaching approaches
-      - Creating visibility
-    expectedDurationMinutes: 8
-exemplifying:
-  - id: sys_exemp_1
-    text:
-      How do you define enterprise-wide systems architecture principles and
-      influence organizational thinking?
-    followUps:
-      - How do you advise executive leadership on complex systems?
-    lookingFor:
-      - Enterprise systems thinking leadership
-      - Executive advisory on complexity
-    expectedDurationMinutes: 10
-  - id: sys_exemp_2
-    text:
-      How do you bridge technical systems with business processes at an
-      organizational scale?
-    lookingFor:
-      - Business-technical systems integration
-      - Enterprise complexity management
-    expectedDurationMinutes: 10
+professionalQuestions:
+  emerging:
+    - id: sys_pro_emerg_1
+      text:
+        You are asked to add a caching layer to a frequently called API
+        endpoint. The change seems straightforward but the endpoint is used by
+        three other services.
+      context:
+        The endpoint currently handles 500 requests per second. Two of the
+        consuming services expect real-time data, while the third can tolerate
+        staleness. Your team owns the endpoint but not the consuming services.
+      simulationPrompts:
+        - What would you check before implementing the cache?
+        - How would you find out who depends on this endpoint?
+        - What could go wrong with adding caching here?
+        - How would you communicate the change to the other teams?
+      lookingFor:
+        - Considers immediate dependencies before making changes
+        - Recognizes that systems have interconnected parts
+        - Asks about downstream impact rather than assuming it's safe
+        - Shows basic cause-and-effect thinking
+      expectedDurationMinutes: 20
+
+  developing:
+    - id: sys_pro_dev_1
+      text:
+        After deploying a database migration, response times on an unrelated
+        service have increased by 300%. There is no obvious connection between
+        the two.
+      context:
+        The migration added an index to a high-traffic table. The affected
+        service shares the same database cluster but uses different tables.
+        Monitoring shows increased lock contention during peak hours.
+      simulationPrompts:
+        - How would you investigate the connection between these two events?
+        - What tools would you use to trace the impact?
+        - How would you map the dependencies that led to this?
+        - What would you do to resolve it while the investigation continues?
+      lookingFor:
+        - Identifies upstream and downstream impacts methodically
+        - Uses observability tools to trace cross-service effects
+        - Maps dependencies before proposing a fix
+        - Understands feedback loops in shared infrastructure
+      expectedDurationMinutes: 20
+
+  practicing:
+    - id: sys_pro_pract_1
+      text:
+        Your team is proposing to replace a synchronous API with an event-driven
+        architecture. The change would affect 6 consuming services across 3
+        teams.
+      context:
+        The current API handles order processing. Moving to events would improve
+        throughput but change data consistency guarantees. Two of the consuming
+        services have SLAs that depend on synchronous confirmation. Business
+        stakeholders want the throughput improvement for peak season.
+      simulationPrompts:
+        - How would you map the full system impact of this architectural change?
+        - How do you handle the teams whose SLAs depend on synchronous
+          behaviour?
+        - What would your migration approach look like?
+        - How would you help business stakeholders understand the trade-offs?
+      lookingFor:
+        - Maps complex interactions across technical and business domains
+        - Anticipates cascading effects of architectural changes
+        - Designs migration that degrades gracefully during transition
+        - Understands how technology changes impact business operations
+      expectedDurationMinutes: 20
+
+  role_modeling:
+    - id: sys_pro_role_1
+      text:
+        A major outage was caused by a cascading failure across 4 services. The
+        post-mortem reveals that no single team understood the full dependency
+        chain.
+      context:
+        The cascade started with a memory leak in Service A, which caused
+        timeouts in Service B, which triggered retries that overwhelmed Service
+        C, which failed over incorrectly to Service D. Each team had local
+        monitoring but no one had end-to-end visibility. This is the second
+        cascading failure this quarter.
+      simulationPrompts:
+        - How would you lead the cross-team investigation?
+        - What systemic changes would you propose to prevent cascading failures?
+        - How would you create shared visibility across these teams?
+        - How do you make the case for investing in system-wide resilience?
+      lookingFor:
+        - Shapes systems design practices across the function
+        - Bridges technical systems thinking with business process impact
+        - Creates clarity from complexity for multiple stakeholder groups
+        - Influences cross-team architecture decisions
+      expectedDurationMinutes: 20
+
+  exemplifying:
+    - id: sys_pro_exemp_1
+      text:
+        The organisation is scaling from 20 to 80 microservices. Complexity is
+        growing faster than the team's ability to reason about the system.
+      context:
+        Incident frequency has tripled in 6 months. Teams operate in silos with
+        no shared architectural principles. Executive leadership is concerned
+        about reliability but doesn't want to slow feature delivery. You've been
+        asked to define the systems architecture strategy.
+      simulationPrompts:
+        - How would you define organizational systems architecture principles?
+        - How do you balance team autonomy with system-wide coherence?
+        - How would you advise executive leadership on the systemic risks?
+        - What governance structures would you put in place?
+      lookingFor:
+        - Defines organizational systems architecture principles
+        - Advises executive leadership on systemic risks and opportunities
+        - Creates frameworks that scale with organizational growth
+        - Takes an approach recognized as industry-leading
+      expectedDurationMinutes: 20
+      followUps:
+        - How would you measure whether systems thinking is improving?
+
+managementQuestions:
+  emerging:
+    - id: sys_mgmt_emerg_1
+      text:
+        A team member made a change to your service that broke a downstream
+        consumer. They didn't realize the dependency existed.
+      context:
+        The downstream team is upset and your team member feels terrible. The
+        dependency wasn't documented and there's no integration test covering
+        it. Your team has 6 members, most of whom are unfamiliar with the
+        broader system context.
+      simulationPrompts:
+        - How do you help the team member understand what happened?
+        - What do you say to the downstream team?
+        - How do you help your team understand the broader system context?
+        - What would you put in place to prevent similar blind spots?
+      lookingFor:
+        - Helps team members see how their work fits the broader system
+        - Creates context awareness without blame
+        - Shows basic understanding of system dependencies
+        - Takes steps to improve visibility
+      expectedDurationMinutes: 20
+
+  developing:
+    - id: sys_mgmt_dev_1
+      text:
+        Your team is about to ship a major refactor. Another team's manager
+        warns you it might affect their service, but your team can't see how.
+      context:
+        The refactor changes internal data structures but the API contract
+        should remain the same. The other team's concern is based on past
+        experience where "internal changes" leaked through. You need to decide
+        whether to delay the release to investigate.
+      simulationPrompts:
+        - How do you assess the risk the other manager is raising?
+        - How do you help your team think about second-order effects?
+        - What would you do if your team disagrees with the delay?
+        - How do you build a collaborative relationship with the other team?
+      lookingFor:
+        - Teaches team to think about downstream impacts
+        - Takes cross-team concerns seriously even without proof
+        - Facilitates systems thinking in planning decisions
+        - Builds collaborative relationships across team boundaries
+      expectedDurationMinutes: 20
+
+  practicing:
+    - id: sys_mgmt_pract_1
+      text:
+        Your team needs to plan a quarter of work but keeps getting interrupted
+        by production issues caused by other teams' changes affecting your
+        service.
+      context:
+        Your service is a critical dependency for 5 other teams. In the last
+        quarter, 40% of your team's time was spent on reactive work caused by
+        upstream changes. Your team is frustrated and wants to "build a wall"
+        with strict API contracts.
+      simulationPrompts:
+        - How do you structure your team's work to account for cross-system
+          dependencies?
+        - How would you work with the other teams rather than building walls?
+        - What systemic improvements would you propose?
+        - How do you protect your team while maintaining collaborative system
+          stewardship?
+      lookingFor:
+        - Embeds systems thinking into team planning processes
+        - Coordinates cross-team to address systemic issues
+        - Balances team protection with broader system health
+        - Proposes structural improvements, not just coping mechanisms
+      expectedDurationMinutes: 20
+
+  role_modeling:
+    - id: sys_mgmt_role_1
+      text:
+        You want to invest in chaos engineering but your leadership sees it as
+        unnecessary risk. Meanwhile, cascading failures are becoming more
+        frequent.
+      context:
+        Your function has had 5 cascading failures in 6 months. Each post-mortem
+        identifies systemic issues but fixes are always local. Leadership wants
+        predictable delivery and sees intentional failure injection as
+        dangerous. You manage 3 teams that own core platform services.
+      simulationPrompts:
+        - How do you make the case for chaos engineering to sceptical
+          leadership?
+        - How would you implement it safely to build confidence?
+        - How do you develop systems thinking capabilities across your teams?
+        - What metrics would you use to demonstrate value?
+      lookingFor:
+        - Models systems thinking in leadership decisions
+        - Develops team capabilities for understanding complex systems
+        - Makes reasoning visible and transparent to stakeholders
+        - Proposes incremental approaches that build trust
+      expectedDurationMinutes: 20
+
+  exemplifying:
+    - id: sys_mgmt_exemp_1
+      text:
+        You are leading an organizational initiative to improve system
+        reliability, but teams have no shared language or practices for systems
+        thinking.
+      context:
+        You are responsible for a function of 50+ engineers across 8 teams.
+        Incident reviews reveal that most outages are caused by teams not
+        understanding cross-system impacts. There is no architectural governance
+        and teams have conflicting approaches to resilience.
+      simulationPrompts:
+        - How do you create organizational structures that promote systems
+          thinking?
+        - How do you balance local team optimization with broader system health?
+        - How do you develop a shared language for discussing system complexity?
+        - How do you handle complexity that spans multiple team boundaries?
+      lookingFor:
+        - Creates organizational structures for systems thinking
+        - Balances local and global optimization at scale
+        - Builds shared understanding of system complexity
+        - Takes a strategic, long-term approach to systemic improvement
+      expectedDurationMinutes: 20
+      followUps:
+        - How would you know if systems thinking maturity is improving?