Moving the Needles: Oblique Strategies for System Transformation🔗

When faced with complex data and information systems, most teams focus on what to build. But the harder question is how to transform what already exists.

This is where Oblique Strategies comes in—an evidence-based approach to understanding the latent space between where your system is and where it needs to be.

Instead of attacking problems head-on, Oblique Strategies suggests examining seven key needles that determine system behaviour. Move these needles deliberately, and transformation follows naturally.

Listen to the Podcast🔗

Prefer to listen? Here's a podcast discussion exploring the Seven Needles framework:

Podcast

Wise Jnrs

Watch the Video Explainer🔗

Get a visual overview of the Seven Needles approach:

The Seven Needles🔗

Viscosity – How freely data moves to the right place at the right time. AI reduces viscosity through intelligent routing, adaptive caching, and context-aware orchestration.

Friction – How easy it is to participate or transact. Reducing barriers so data, people, and systems flow naturally — from tap-on transport cards to conversational interfaces.

Automation – From rules to signals. Systems interpret intent, act autonomously, and self-correct through AI-driven feedback loops.

Immediacy – Completing transactions now. No waiting, no red tape. AI anticipates needs and executes decisions at the moment of intent.

Niche – Focus and specificity. AI systems excel when they specialise — interconnecting through APIs and models that know their purpose.

Governance – Situational awareness. Not bureaucracy, but intelligent control — knowing what's happening, where, and why through automated trust.

Learning – Continuous improvement. Systems evolve from feedback, retrain models, and grow organisational intelligence over time.

These needles describe all meaningful movement in transformation. Shift one, and you influence them all.

Interactions Between Needles🔗

The seven needles interact dynamically:

Increasing automation can lower friction and raise immediacy.
Strengthening governance improves learning through clear feedback.
Focusing niche reduces viscosity by simplifying data movement.

AI amplifies these relationships — creating systems that adjust themselves in real time.

Let's explore each needle in depth.

1. Viscosity: Reducing Resistance to Change🔗

Viscosity in data systems refers to how hard it is to change data flows and processes. High viscosity looks like:

Multiple layers of data silos
Lack of standardization in data management
Legacy systems with hardcoded transformations
Changes requiring weeks of coordination across teams

Why It Matters🔗

High viscosity kills agility. When a simple schema change requires updating 15 systems and coordinating 6 teams, you're stuck.

How to Move the Needle🔗

Reduce viscosity by:

Implementing a data governance framework with clear ownership
Standardizing data formats and APIs
Creating abstraction layers (data meshes, service layers)
Documenting data lineage so changes are predictable
Adopting schema-on-read approaches where appropriate

Example: Instead of rigid ETL pipelines, use event-driven architectures where consumers adapt to schema evolution.

2. Friction: Aligning Stakeholders🔗

Friction is the organizational resistance to change. It happens when:

Different departments have conflicting priorities
Communication breaks down between teams
No one owns the "between spaces" of the system
Politics trump evidence

Why It Matters🔗

You can have the perfect technical solution, but if Finance, Engineering, and Operations can't agree, nothing ships.

How to Move the Needle🔗

Reduce friction by:

Establishing clear communication channels (not more meetings—clearer channels)
Aligning incentives across stakeholders
Creating shared value metrics everyone cares about
Using oblique strategies to reframe conflicts (ask "What problem are we really solving?")
Building trust through transparency and small wins

Example: Instead of debating tool choices, align on outcomes first. "We all want faster insights—how do we measure that?"

3. Automation: Eliminating Toil🔗

Automation is the degree to which repetitive tasks are handled by machines instead of humans.

High automation looks like:

Automated data pipelines with self-healing
CI/CD deployments with zero manual steps
Monitoring that auto-scales infrastructure
ML models that retrain themselves

Low automation looks like:

Manual data entry and reconciliation
Excel spreadsheets emailed between teams
Copy-paste deployments
Analysts re-running the same queries daily

Why It Matters🔗

Humans are terrible at repetitive tasks. We introduce errors, get bored, and can't scale.

How to Move the Needle🔗

Increase automation by:

Identifying the highest-friction manual tasks (not the easiest ones)
Automating pipelines before dashboards
Using infrastructure-as-code (IaC)
Implementing self-service data access
Applying RPA (Robotic Process Automation) to legacy systems you can't replace

Example: Automate data quality checks in pipelines rather than having analysts validate data weekly.

4. Immediacy: Accelerating Decision Cycles🔗

Immediacy is the time between data generation and data availability for decision-making.

High immediacy: Real-time dashboards, streaming analytics, event-driven systems Low immediacy: Batch jobs, overnight ETL, monthly reports

Why It Matters🔗

Stale data = stale decisions. In fast-moving industries, yesterday's data might be worthless.

How to Move the Needle🔗

Increase immediacy by:

Adopting streaming platforms (Kafka, Pulsar, Kinesis)
Using in-memory databases for hot data
Implementing change data capture (CDC) for real-time sync
Building event-driven microservices
Caching strategically with TTLs

Example: Instead of nightly batch jobs, use CDC to stream database changes into a real-time analytics layer.

Caution: Not everything needs real-time. Match immediacy to decision velocity.

5. Niche: Optimizing for Specificity🔗

Niche is the degree to which your system is optimized for a specific function versus being general-purpose.

Highly niched: Custom-built systems for one domain Highly general: Generic platforms trying to do everything

Why It Matters🔗

General systems are flexible but mediocre at everything. Niche systems excel at one thing but resist change.

How to Move the Needle🔗

Find the right balance by:

Building domain-specific data models within general platforms
Using composable architectures (best-of-breed tools)
Applying bounded contexts (DDD) to segment complexity
Optimizing the 20% of features used 80% of the time

Example: Instead of one massive ERP, build specialized systems (finance, HR, operations) that integrate via APIs.

6. Governance: Balancing Control and Agility🔗

Governance is the policies, procedures, and standards ensuring security, integrity, and compliance.

Strong governance: Clear policies, audit trails, access controls, compliance frameworks Weak governance: Ad-hoc permissions, no audit trails, "we'll fix compliance later"

Why It Matters🔗

Without governance, you get data breaches, compliance failures, and chaos. With too much governance, you get bureaucracy and stagnation.

How to Move the Needle🔗

Strengthen governance without stifling agility:

Implement policy-as-code (automated compliance checks)
Use role-based access control (RBAC) with least privilege
Establish data ownership with clear accountability
Build audit trails into the system, not bolted on later
Adopt privacy-by-design principles

Example: Instead of manual approval workflows, use automated policy engines that allow/deny access based on rules.

7. Learning: Building Adaptive Systems🔗

Learning is the system's ability to improve over time without manual intervention.

High learning: ML models retrain on new data, systems auto-tune, anomaly detection improves Low learning: Static rules, manual tuning, no feedback loops

Why It Matters🔗

Static systems decay. Learning systems get better with use.

How to Move the Needle🔗

Increase learning by:

Implementing feedback loops from users and data
Using machine learning for pattern recognition and optimization
Building experimentation frameworks (A/B testing, feature flags)
Capturing metadata and lineage for continuous improvement
Adopting reinforcement learning for optimization tasks

Example: Instead of hardcoded business rules, use ML models that learn from historical decisions and adapt.

The Oblique Approach: Non-Linear Thinking🔗

These seven needles don't move independently. Moving one affects the others:

Increasing automation often reduces friction (fewer manual handoffs)
Improving governance can increase viscosity if not implemented carefully
Adding immediacy requires more automation to handle real-time scale
Narrowing niche can reduce viscosity within that domain
Enabling learning helps systems adapt to friction over time

This is where Oblique Strategies shines. Instead of tackling problems directly ("How do we migrate this legacy system?"), ask oblique questions:

What if we left the legacy system alone and built around it?
What would happen if we doubled the batch frequency?
Who benefits from the current viscosity?
What if governance was automated, not manual?

These questions reveal hidden constraints and opportunities.

Applying the Framework: A Case Study🔗

Problem: A healthcare system has 48-hour lag between patient events and analytics. Analysts manually reconcile data from 5 sources daily.

Analysis using the seven needles:

Viscosity (High): Data silos in EMR, billing, lab, pharmacy, admissions—no unified schema
Friction (High): Each department owns its data; no one owns integration
Automation (Low): Manual ETL scripts run nightly; analysts fix breaks daily
Immediacy (Low): 48-hour lag unacceptable for operational decisions
Niche (Too General): Trying to serve clinical, financial, and operational use cases with one pipeline
Governance (Weak): No clear data ownership or access policies
Learning (None): Static rules; no adaptation to data changes

Oblique Strategy: Instead of building one massive real-time pipeline, what if we:

Reduce Viscosity: Implement a data mesh with domain-specific data products
Reduce Friction: Assign domain data owners with clear SLAs
Increase Automation: Use CDC to stream changes from source systems
Increase Immediacy: Build a real-time operational layer for critical metrics
Optimize Niche: Separate pipelines for clinical (real-time) vs. financial (batch)
Strengthen Governance: Policy-as-code for HIPAA compliance, automated audit trails
Enable Learning: ML anomaly detection to flag data quality issues early

Result: Move from 48-hour lag to sub-minute latency for operational data, while keeping batch processing for complex analytics. Friction drops because domains own their data. Automation eliminates 80% of manual reconciliation.

Your Cheat Sheet: The Oblique Strategies Wiki🔗

Before diving into transformation, grab your Oblique Strategies Cheat Sheet.

This comprehensive reference includes:

Critical Evaluation Questions:

Volume, Frequency, Effect, Trend analysis frameworks
Aggregation, Experimentation, Prediction techniques
The 6 V's of Big Data (Volume, Velocity, Variety, Variability, Veracity, Value)

Problem-Solving Frameworks:

RISA Framework for resolving disagreements (Reduce, Isolate, Solve, Act)
Evidence-based approaches to latent space analysis
Stakeholder alignment and communication patterns

Technology Integration:

AI/ML model selection and deployment strategies
Data architecture patterns (meshes, lakes, warehouses)
Analytics tools and platforms (Spark, BigQuery, Snowflake)

Skills Hierarchy:

Internal leadership and emotional intelligence
Communication and learning skills development
Behavioral change frameworks

Think of it as your field manual when you're stuck. The diagnostic questions and frameworks help you reframe problems and spot non-obvious solutions you might otherwise miss.

Practical Steps: Where to Start🔗

You don't move all seven needles at once. Start with diagnosis:

Map current state: Where are your needles today? (Use 1-10 scales)
Identify pain points: Which needle causes the most friction?
Choose one needle to move: Pick the highest-impact, lowest-effort change
Measure: Define metrics for that needle (e.g., "reduce manual hours by 30%")
Iterate: Small moves, frequent adjustments

Pro tip: Use the Oblique Strategies cheat sheet to generate diagnostic questions for your specific context.

Example metrics:

Viscosity: Time to deploy schema change
Friction: Stakeholder alignment score (survey)
Automation: % of processes automated
Immediacy: Data freshness (p95 latency)
Niche: Feature usage concentration (80/20 rule)
Governance: Policy compliance % (automated checks)
Learning: Model drift detection, retraining frequency

Connection to Push Manifesto🔗

The seven needles align perfectly with Push Manifesto principles:

Waypoints over milestones: Move needles incrementally, not in big-bang transformations
Shared value: Align needles with outcomes all stakeholders care about
Evidence-based: Measure needle positions; don't guess
Journey over destination: Continuous adjustment, not one-time fixes

Push says: "Focus on the waypoints that matter." The seven needles are those waypoints for system transformation.

Final Thought🔗

System transformation isn't about grand redesigns. It's about moving the right needles in the right sequence.

Oblique Strategies teaches us to approach problems indirectly: examine viscosity, friction, automation, immediacy, niche, governance, and learning. Understand their current state. Choose which to move. Measure the impact. Iterate.

Most systems fail not because the architecture is wrong, but because the needles are stuck.

Move the needles. The system will follow.

What needles are stuck in your system? Which one should you move first? Let me know your thoughts.