AIOps That Actually Helps: Start with Telemetry, Correlation, and Safe Automation

Black and white operations dashboard

AIOps That Actually Helps: Start with Telemetry, Correlation, and Safe Automation

Most teams do not need an “AI for ops” demo. They need fewer junk alerts, faster root cause analysis, and a safer path from detection to action.

That is why I think the best way to approach AIOps is not as a shiny product category, but as an operating model:

  1. collect better telemetry
  2. correlate signals into incident context
  3. automate only the fixes that are low risk and high confidence

That framing matters because a lot of AIOps conversations skip straight to autonomous remediation. Lowkey, that is the fastest way to lose trust. If your telemetry is fragmented and your alerts are noisy, adding AI on top just gives you faster confusion.

Google Cloud describes AIOps as a flow of observe, engage, and act across metrics, logs, traces, and events. IBM explains a similar loop: ingest data, separate signal from noise, identify root cause, and automate the response where appropriate. That is the practical core. Not magic. Just better operations with stronger data and better automation.

Black and white operations dashboard

AIOps starts with observability, not prompts

If your system cannot explain itself, your AIOps layer will guess.

That is why OpenTelemetry matters so much here. The OpenTelemetry docs define it as a vendor-neutral observability framework for generating, collecting, and exporting telemetry like traces, metrics, and logs. In practice, that means you can stop treating each signal as an isolated artifact and start building shared context around real requests, services, dependencies, and failures.

A lot of “AIOps” pain is really observability debt:

  • logs without request context
  • metrics without deployment context
  • traces missing key spans
  • alerts that page based on internal symptoms instead of user impact

Google’s incident management guidance is pretty blunt on this point: alerts should be timely, actionable, and based on symptoms that matter to users. If your on-call gets paged by ten downstream threshold alerts for one customer-facing issue, that is not operational maturity. That is alert spam with enterprise branding.

AIOps cannot fix bad source data. It can only amplify whatever quality you feed into it.

The highest-value AIOps use case is alert noise reduction

Ngl, the fastest AIOps win is usually not “self-healing infra.” It is reducing the amount of useless work humans do before they can even begin real debugging.

PagerDuty’s AIOps material highlights noise reduction, triage, RCA, automation, and visibility as core capabilities. Riverbed also points to event management and automated remediation as major use cases. That lines up with what most ops teams actually feel every week: too many alerts, too little context, too much manual routing.

A simple example:

  • service A latency spikes
  • service B starts timing out
  • retries increase queue depth
  • customer checkout errors rise
  • five tools emit fifteen alerts

Without correlation, an engineer sees fifteen problems.
With decent AIOps, they should see one incident with a likely blast radius and a ranked list of contributing signals.

That is already a huge win.

incident:
  primary_symptom: checkout error rate > 5%
  related_signals:
    - service-a latency p95 increased 4x
    - service-b timeout count increased 7x
    - queue depth above baseline
    - deployment marker detected 12 minutes earlier
  suggested_owner: payments-platform
  suggested_runbook: runbooks/payments/checkout-latency.md

Notice what makes this useful. The value is not in the word “AI.” The value is in turning scattered telemetry into an actionable incident object.

Root cause analysis gets better when telemetry shares context

AIOps gets way more reliable when traces, logs, metrics, and deployment markers can be linked together.

This is where teams should think less about dashboards and more about data shape. If a spike in latency cannot be tied to a deployment, a downstream dependency, or a specific service version, then your RCA workflow is still mostly manual.

A practical baseline looks like this:

telemetry_context = {
    "service": "checkout-api",
    "environment": "prod",
    "version": "2026.05.17.3",
    "trace_id": trace_id,
    "error_rate": error_rate,
    "p95_latency_ms": p95_latency,
    "recent_deploy": deploy_sha,
    "top_dependency": "payment-gateway",
}

Once that context is consistent, AIOps can do something useful:

  • group related alerts into one incident
  • point to the most likely dependency path
  • suggest the right runbook
  • rank possible causes based on recent changes and correlated failures

IBM calls out root cause analysis, anomaly detection, performance monitoring, and cloud migration support as strong AIOps use cases. That makes sense because modern systems are too distributed for manual stitching to scale well. If your architecture is microservices, queues, managed databases, and a couple of SaaS dependencies, the old “grep logs and pray” loop is not enough anymore.

Safe automation beats ambitious automation

This is the part people rush.

The real question is not, “Can AI take action?”
The real question is, “What action is safe enough to automate repeatedly?”

Google Cloud’s AIOps guidance talks about the “act” layer as triggering remediation workflows like restarting services, scaling resources, or rolling back recent changes. That is useful, but only when the guardrails are real.

My rule: automate the response only after you can explain the trigger, the blast radius, the rollback path, and the audit trail.

Good candidates for automation:

  • restart a stateless worker after a known failure signature
  • scale a queue consumer group within approved limits
  • open the right incident ticket with enriched context
  • attach logs, traces, and deploy metadata to the incident automatically
  • route the incident to the correct team based on service ownership

Bad candidates for early automation:

  • mutating databases
  • changing network policy on the fly
  • disabling alerts broadly
  • restarting stateful systems without dependency checks
  • taking any action nobody has tested during daylight hours

AIOps should remove toil first. Autonomy comes later.

What actually trips teams up

Three things show up again and again.

First, teams buy the AIOps story before fixing data quality. If logs are unstructured, traces are partial, and ownership metadata is stale, the platform will still produce output, but the output will be weak.

Second, teams measure success in demo terms instead of reliability terms. The better scorecard is boring on purpose:

  • fewer duplicate alerts per incident
  • lower MTTA and MTTR
  • fewer manual triage steps
  • fewer false escalations
  • more incidents routed correctly on the first try

Third, teams automate around symptoms instead of SLO impact. The Google SRE guidance is right here: alerts should be actionable and tied to meaningful service behavior. If the AIOps pipeline is optimizing for internal noise instead of user-facing pain, it will waste engineer attention.

A practical rollout path

If I were starting AIOps in a real platform team, I would do it in this order:

  1. standardize telemetry with OpenTelemetry or an equivalent baseline
  2. add ownership, service, environment, and deployment metadata everywhere
  3. fix noisy alerts until one incident mostly maps to one paging event
  4. build incident correlation before autonomous remediation
  5. automate one or two safe runbook steps for a narrow incident class
  6. review every automated action like production code

That path is less flashy, but fr it is how trust gets built.

AIOps is valuable when it makes your on-call calmer, your incidents shorter, and your systems easier to understand. If it cannot do that, it is probably just another layer of operational theater.

Start small: pick one alert family, wire in better telemetry, correlate it with deploy context, and automate one safe response. If that reduces toil for the team this month, you are doing real AIOps.

References

  1. Google Cloud, What is AIOps? Benefits & use cases
    https://cloud.google.com/discover/what-is-aiops
  2. IBM, What is AIOps?
    https://www.ibm.com/think/topics/aiops
  3. PagerDuty, Understanding AIOps (Artificial Intelligence for IT Operations)
    https://www.pagerduty.com/resources/aiops/learn/what-is-aiops/
  4. Riverbed, What Is AIOps? Big Data & Machine Learning in IT Operations
    https://www.riverbed.com/faq/what-aiops/
  5. OpenTelemetry, What is OpenTelemetry?
    https://opentelemetry.io/docs/what-is-opentelemetry/
  6. Google SRE, Incident Management Guide
    https://sre.google/resources/practices-and-processes/incident-management-guide/

Psychological Capital

Components of Positive Psychological Capital (PsyCap). Source: Luthans, F., & Youssef, C. M. (2007). Emerging positive organizational behavior. Journal of management, 33(3), 321–349.

Psychological capital is not about being positive all the time. It’s about having the inner resources to function well under pressure.
It consists of four components:
Hope - believing there are pathways forward
Self-efficacy - confidence in your ability to act
Resilience - the capacity to recover from setbacks
Optimism - a realistic belief that effort can lead to improvement

When these are strong, people adapt, learn, and act.
When they’re depleted, even high performers stall.
When organizations start to fail, leaders often reach for the same explanations.
People are disengaged.
 The culture is weak.
 We need better incentives.
But what if none of those are the real problem?
In a recent talk, Karsten Drath - engineer, MBA, entrepreneur, executive coach, and Managing Partner at Leadership Choices - offered a more honest diagnosis:
Many organizations today aren’t underperforming because they lack talent or strategy.
 They’re underperforming because they’re psychologically depleted.
And you can’t spreadsheet your way out of exhaustion.
The Symptoms Leaders Keep Missing
Karsten described a pattern they sees across industries:
Business models that no longer work
Rising sick days and burnout
Slow or avoided decision-making
Leaders who know something is wrong but can’t name it

These are non-linear problems. They don’t respond well to traditional fixes like restructuring, new KPIs, or motivational speeches.
What’s actually eroding performance is something more fundamental: psychological capital and organizational energy.
You Can Measure This (And It Changes Everything)
One reason psychological capital is ignored is that leaders assume it’s too “soft” to measure.
It’s not.
Karsten shared the Executive Fire Index (EFI), a tool used to assess psychological capital over time. In one example, an executive named John showed significant improvement across all four dimensions over six months - without changing roles - through coaching and mindfulness practices.
The takeaway was simple but powerful:
When you invest in inner capacity, outer performance follows
Organizational Energy: Why the Same Strategy Thrives in One Company and Dies in Another
To understand why whole organizations feel stuck or volatile, Karsten introduced the concept of organizational energy, developed by Professor Heike Bruch.
Organizational energy falls into four states:

  1. Comfortable Energy
    Things feel fine - but nothing changes.
     The risk? Complacency.
  2. Resigned Energy
    People show up, but they’ve emotionally checked out.
     This is bore-out, not burnout.
  3. Corrosive Energy
    Conflict, blame, and distrust dominate.
     Performance collapses under emotional friction.
  4. Productive Energy
    High focus, healthy intensity, and shared purpose.
     This is where resilience and results coexist.
    Here’s the uncomfortable truth:
     Most struggling organizations aren’t failing because of strategy. They’re stuck in the wrong energy state.
    How to Move an Organization Back to Productive Energy
    Karsten outlined targeted strategies based on energy type:
    Comfortable → Productive:
     Slay the dragon. Name the real threat or challenge everyone is avoiding.
    Resigned → Productive:
     Create a compelling vision that gives people a reason to care again.
    Corrosive → Productive:
     Address conflict directly. Suppressed emotion doesn’t disappear - it poisons.
    Acceleration Trap (too much intensity):
     Declutter priorities. Focus beats frenzy.

The key insight: You can’t motivate your way out of depleted energy. You have to work with it.
Why Individual Coaching Isn’t Enough
One of Karsten’s strongest points challenged a common leadership reflex:
“We keep sending individuals to coaching… while leaving the system untouched.”
Her approach to organizational coaching works on two levels at once:
Individual patterns - beliefs, behaviors, emotional responses
Systemic dynamics - norms, incentives, decision flows, unspoken rules

Transformation sticks only when both change together.
This is where concepts like a North Star matter - not as a slogan, but as a shared behavioral compass that answers:
What matters now?
How do we act when it’s hard?

After Layoffs, You Can’t Just “Move On”
During the Q&A, participants asked about generational differences, bottom-up vs. top-down change, and post-layoff recovery.
Karsten was clear on one thing:
Organizations that don’t process loss don’t regain trust.
After layoffs or major disruption, leaders often rush to the future. Employees are still grieving - security, identity, colleagues.
Ignoring that emotional reality doesn’t create resilience.
 It creates resigned or corrosive energy.
Healing is not a soft extra. It’s a performance requirement.
The Leadership Shift This Moment Demands
The organizations that will thrive next aren’t the ones with the loudest vision decks or most aggressive targets.
They’re the ones that understand this:
Energy is a strategic asset
Psychological capital is renewable - but not infinite
Performance follows meaning, not pressure

How to organize high impact workshops and events

Workshops bring people together. How do you make the most of them?

They remember the sticky notes, the energy in the room, and the long list of “great ideas”… followed by silence. No execution. No impact. Just another meeting that felt productive without producing results.

High-impact events and workshops are different. They are designed not for participation, but for measurable progress - delivering meaningful outcomes for a relatively small investment of time and money.
Here’s a practical framework for running workshops that leaders actually value, teams enjoy, and organizations act on.

First: What a Workshop Isn’t
A workshop is not a presentation with breakout rooms.
Presentations are about transmitting information. Workshops are about creating outcomes together. They are structured, facilitated experiences where participants actively do the thinking, make decisions, and leave with something concrete that didn’t exist before.

When workshops fail, it’s usually because:
The agenda is overloaded with too many topics
The session generates ideas but no ownership
There’s no follow-through after the room clears
Leaders become skeptical because nothing changes

If you’ve ever heard “That was a great workshop” followed by zero progress, you’ve seen this failure mode firsthand.
The Four Types of Workshops (and Why Only One Delivers ROI)
Not all workshops are meant to deliver hard value - and that’s okay. But confusion about which type you’re running is where problems begin.
You can roughly divide workshops into four categories:
Learning workshops - building knowledge or skills
Exploratory workshops - discovering problems or opportunities
Soft workshops - team building, trust, alignment
Hard workshops - producing a solution that gets implemented

High-ROI workshops are hard workshops.
That doesn’t mean they’re boring or rigid. It means they are explicitly designed to:
Solve a specific, high-value challenge
Produce a clear decision or solution
Enable real execution afterward

If you’re aiming for ROI, be honest: you’re not there to “explore”, you’re there to decide and move.
Why the Best Workshops Are Genuinely Fun
“Fun” doesn’t come from icebreakers or forced games.
It comes from removing friction so smart people can work on meaningful problems together.
When participants:
Know what they’re solving
Feel their thinking matters
See progress happening in real time

…the work itself becomes enjoyable. Engagement is a byproduct of clarity and momentum, not entertainment.
The 3 Elements That Make Workshops Actually Work
High-ROI workshops consistently succeed because they get three things right:
They focus on the Most Valuable Challenge (MVC)
They enable optimal thinking - not chaos or overanalysis
They produce alignment plans, not just action lists

Let’s break each down.

  1. Identify the Most Valuable Challenge (MVC)
    The biggest mistake in workshops is trying to solve too much.
    High-ROI workshops focus on one challenge, chosen deliberately for its impact.
    To identify the MVC:
    Get the right people in the room (those closest to the problem and the authority to act)
    Be ambitiously focused, solve something that actually matters
    Explore creative and comprehensive solution spaces
    Climb the goal chain to address root causes, not symptoms

Then assign a value score to the challenge based on:
Emotional impact (does anyone actually care?)
Ecosystem impact (who else is affected?)
Monetary or strategic value

Importantly, this score is about the value of solving the challenge, not how easy or cheap the solution might be. Feasibility comes later.
If you don’t choose the right problem, no facilitation technique will save you.

  1. Enable Optimal Thinking
    Most workshops suffer from either:
    Underthinking: jumping to the first idea
    Overthinking: endless discussion with no convergence

Optimal thinking sits between those extremes.
A reliable way to achieve this is the double diamond model:
Diverge first: generate many ideas, perspectives, and options
Converge second: narrow down using clear criteria and comparison

Equally important:
Structure time intentionally
Design activities so quieter voices are heard
Treat the group as a system of collective intelligence, not a debate stage

A Note on Decision-Making
Popular voting feels democratic but often produces mediocre outcomes.
Better options include:
A clearly designated decider, informed by the group
The auctioneer method, where the facilitator guides structured comparison between shortlisted ideas until the group reaches clarity

The goal isn’t consensus. It’s commitment to a strong decision.

  1. Create Alignment Plans (Not Just Action Plans)
    Most workshops fail after the room empties.
    Why? Because action plans assume alignment already exists.
    In reality, execution stalls when:
    Stakeholders don’t understand the “why”
    Messages get diluted as they travel
    Teams feel the decision was imposed, not earned

Alignment plans solve this by focusing on:
Clear narrative: why this solution, why now
Empathy: what different stakeholders care about
Simplicity: a single, memorable summary (often one slide)

If people can’t clearly explain the decision to others, it won’t survive contact with the organization.
How to Allocate Workshop Time (Yes, This Matters)
A practical rule of thumb for high-ROI workshops:
10% - Define the MVC
50% - Do the optimal thinking
40% - Build alignment plans

Most teams radically underinvest in alignment and then wonder why nothing happens afterward.
Practical Questions, Answered
What if participants have different challenges?
 Guide each person to identify their own MVC within a shared theme.
Should solution complexity factor into the value score?
 No. Value first. Feasibility comes later using tools like impact/effort matrices.
How fast should implementation start?
 As fast as possible. Momentum decays quickly, aim for visible progress or small wins soon after the workshop.
Should we even call it a “workshop”?
 If the word scares your audience, don’t use it. Try “off-site,” “solutions sprint,” “session,” or “retreat.”
Do virtual workshops actually work?
 Yes, when designed intentionally. Digital whiteboards, strong facilitation, and clear engagement rules make remote workshops just as effective (and often easier to scale).
The Bottom Line
High-ROI workshops aren’t about better icebreakers or prettier canvases.
They’re about:
Choosing the right challenge
Structuring thinking so decisions emerge
Designing alignment so execution happens

When you do those three things well, workshops stop being a cost and start becoming one of the highest-leverage tools leaders have.
And that’s when people stop rolling their eyes… and start asking for the next one.

I Built a Web3 Threat Intelligence Oracle Powered by Gemma 4

OCTIO Dashboard

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

OCTIO (On-Chain Threat Intelligence Oracle) is a system that monitors live phishing and malware feeds, runs each threat indicator through Gemma 4 for analysis and classification, and stores verified intelligence in a format that blockchain protocols can query before executing sensitive operations.
The problem it solves is real. Around 80% of funds stolen from Web3 projects come not from smart contract exploits but from attacks on surrounding Web2 infrastructure such as phishing campaigns, DNS hijacking, frontend supply chain compromise, and cloud misconfiguration. The Ronin Network hack ($625 million) started with a phishing email. The Ledger Connect Kit attack ($600,000) came from a poisoned npm package. The Curve Finance DNS hijack redirected legitimate users to a malicious server for hours.
In every case, observable signals existed before significant losses occurred. OCTIO is the infrastructure to collect, analyse, and distribute those signals with Gemma 4 at the core of the intelligence layer.

Demo

DemoGitHub: github.com/James-Kabingu/octio

Running the full system takes five commands:
python3 monitor.py # fetch and classify live phishing URLs
python3 registry.py # submit validated indicators to registry
python3 oracle.py # run protocol query interface
python3 correlation.py # correlate against documented incidents
python3 dashboard.py # display full system dashboard

OCTIO Dashboard

Sample oracle output:
[BLOCK ] [CRITICAL ] http://www.dpdlocoqu.cyou/com
[PROCEED] [SAFE ] https://uniswap.org
[CAUTION] [SUSPICIOUS] http://metamask-security-alert.com/connect
[PROCEED] [SAFE ] https://aave.com
[BLOCK ] [CRITICAL ] http://instagram.com.universal-api.org/

Code

GitHub: github.com/James-Kabingu/octio
The repository includes:

monitor.py: Live phishing feed monitoring with Gemma 4 threat classification.
registry.py: On-chain registry simulation with keccak256 hash storage.
oracle.py: DeFi protocol query interface with Gemma 4 risk assessment.
correlation.py: Incident correlation against documented real-world hacks.
dashboard.py: Terminal dashboard for live threat visibility
contracts/ThreatRegistry.sol. Solidity contract for Sepolia testnet deployment.

The smart contract implements the full indicator submission, validation, and query interface described in the system architecture. Target domains are stored as keccak256 hashes rather than plaintex, reducing storage costs by 60 to 90% and preventing the registry from being used as a phishing directory.

How I Used Gemma 4

I chose the Gemma 3 27B Instruct model (google/gemma-3-27b-it) via OpenRouter. The 27B model has the reasoning depth needed to make nuanced security judgements, not just pattern matching.
Gemma 4 powers three distinct functions inside OCTIO:

  1. Threat Classification (monitor.py):
    OCTIO pulls live URLs from OpenPhish, a real phishing feed updated continuously. Each URL is sent to Gemma 4 with a structured prompt asking it to classify the threat, assess severity, identify the impersonation target, and explain its reasoning.
    Given the URL http://www.dpdlocoqu.cyou/com, Gemma 4 returned:

{
“is_threat”: true,
“threat_type”: “PHISHING”,
“severity”: “HIGH”,
“target”: “DPD (Delivery Service)”,
“reasoning”: “The URL uses a misspelling of DPD and a suspicious domain extension to impersonate the legitimate delivery service, likely to steal credentials potentially leading to crypto access.”
}

This is not keyword matching. Gemma 4 understood the typosquatting pattern, identified the impersonated brand, and connected it to the crypto threat context from the URL alone.

  1. Risk Assessment (oracle.py):
    When a protocol queries the oracle, Gemma 4 produces a final risk assessment combining registry data with its own domain pattern analysis. For http://metamask-security-alert.com/connect, which was not in the registry, Gemma 4 returned SUSPICIOUS/CAUTION based on the domain pattern alone. A rule-based system would have returned CLEAN. Gemma 4 understood the social engineering intent from the URL structure.

  2. Incident Correlation (correlation.py):
    Gemma 4 analyses the current indicator set against a database of documented real-world Web3 hacks. Given five live phishing URLs, it correctly correlated them with the Ronin Network hack ($625M), Curve Finance DNS hijack ($570K), and MyEtherWallet BGP attack ($17M), and produced actionable recommendations for DeFi protocols.

Why the 27B model:
The 27B model was necessary for this task. Smaller models returned surface-level classifications without the reasoning depth needed to distinguish between a legitimate security alert and a phishing site designed to look like one. What Gemma 4 unlocked was a system that gets smarter as the threat landscape evolves, without retraining or updating rule sets.

Limitations and Next Steps

This is a working prototype, not a production system. The current limitations are worth being clear about:
The on-chain registry is simulated in Python. The Solidity contract (ThreatRegistry.sol) is written and ready but not yet deployed to Sepolia testnet. A live deployment requires testnet ETH and a Foundry deployment script.
The monitoring layer currently pulls from OpenPhish only. The full architecture specifies Certstream for certificate transparency monitoring, PassiveDNS for DNS change detection, SecurityTrails, and npm audit feeds. These are the next integrations.
The prototype auto-validates every indicator Gemma 4 flags. The whitepaper describes a multi-party validation mechanism where registered researchers vote on submitted indicators before they reach the active registry. That governance layer is not yet implemented.
Gemma 4 can produce false positives. The model occasionally flags legitimate domains as suspicious. Human review before on-chain submission is essential in a production deployment.
The oracle interface simulates Chainlink integration. A real deployment requires a running Chainlink node and a registered External Adapter.
Despite these limitations, the core thesis is demonstrated: Gemma 4 can perform nuanced threat classification, catch suspicious domains not yet in any registry, and correlate current indicators against historical incidents, all in real time. The prototype shows the system works. The remaining work is engineering, not concept validation.

Your ICP Is a Trap

Hook

You spend six weeks building an AI agent that automates invoice processing for small businesses. You launch. Crickets. You posted in three Discord servers, sent 40 cold DMs, ran $200 in ads. Zero paying customers. The product works. The demos are smooth. Sales stay at zero.

The problem stared you in the face the whole time. Your ICP was “small business owners who need automation.” That describes 30 million people and excites exactly zero of them. You defined your ideal customer by demographics, by role, by company size. You listed who they are. You failed to ask whether they care, whether they spend, whether you can reach them, and whether you have any right to win.

The Idea (60 Seconds)

Your Ideal Customer Profile is a trap when it answers the wrong question. Most builders define ICP by demographics: age, income, job title, company size. Those attributes describe a person. They fail to predict behavior.

A strong ICP answers one question: Who is actively trying to solve this problem right now, has the ability to pay, and can be reached?

Urgency and situation beat demographics every time. A 42-year-old CFO at a logistics company drowning in manual reconciliation is your ICP. “CFOs at mid-market companies” is a demographic label that includes thousands of people perfectly happy with their spreadsheets.

The 4-Filter Test screens your ICP before you invest a single build hour. Pain. Market. Access. Fit. Each filter eliminates weak assumptions. Pass all four, and you have a target worth building for.

Two complementary question sequences sharpen the result. The Narrowing Funnel, derived from Alex Hormozi’s framework, starts broad and drills to urgency. The Lighthouse Client Method, created by Rmosh, grounds your ICP in a real human being instead of an abstract persona.

Why This Matters

Every AI builder hits the same wall. You learn prompt engineering. You master agent frameworks. You ship something that works. Then you realize you built it for everybody, which means you built it for an audience of zero.

Generic ICPs produce generic messaging. Generic messaging produces low conversion and high churn. You attract people who kind of sort of need your thing. They sign up, poke around, and leave. Your retention numbers look like a cliff.

The cost compounds fast. Six weeks of building for the wrong audience means six weeks of code you may need to rewrite, six weeks of positioning you need to undo, and six weeks of motivation burned on a product zero people wanted.

The antidote is simple and ruthless: filter before you build. The 4-Filter Test takes 30 minutes and saves months.

Walkthrough

The 4-Filter Test

Run your ICP through these four filters in order. Fail any single one, and you stop. Revisit your assumptions. Pick a different target. Do it all before writing a single line of code.

Filter 1: Pain. Are real people experiencing this problem and actively seeking solutions?

This is the urgency filter. People complain about many things. People seek solutions for far fewer. Your ICP must have a problem painful enough that they are already looking for help, googling alternatives, posting in forums, asking colleagues.

Test: Search for the problem in Reddit, Twitter, industry Slack channels. If people are posting about it and asking for recommendations, pain is real. If you find only vague complaints, the pain is too low to drive purchase behavior.

Example: “Bookkeeping is tedious” is a complaint. “I spent 12 hours last weekend reconciling invoices and I am still behind” is a pain signal. The second person buys. The first person scrolls past your ad.

Filter 2: Market. Is there a group spending money on solutions already?

Existing spend proves willingness to pay. If zero people are spending money to solve this problem, you are fighting human inertia and budget allocation at the same time. That is a losing battle.

Test: Search for existing products, agencies, consultants, or freelancers serving this problem. Check their pricing pages. Look for G2 or Capterra listings. Paid competitors validate the market. Zero competitors usually signals zero market, and first-mover advantage is a myth for solo builders.

Example: Automation tools for real estate agents exist everywhere, and agents pay for them. That signals a market. A tool for “people who want to journal more creatively” faces a market of free alternatives and low willingness to pay.

Filter 3: Access. Can you reach these people through channels you can actually use?

A perfect ICP locked behind an unreachable channel is useless. If your target is Fortune 500 CTOs and your only channel is a Twitter account with 200 followers, you lack access. Access means you can put your message in front of your ICP repeatedly, at low cost, starting this week.

Test: List every channel where your ICP spends time. Then honestly assess whether you can show up there. Do you have followers there? Do you know someone who does? Can you write content they read? Can you cold-email them effectively?

Example: React developers are reachable through Twitter, Dev.to, Discord, GitHub, and conference communities. Mid-market hospital administrators are reachable through expensive trade shows and closed networks. Pick the ICP you can actually reach.

Filter 4: Fit. Does your skill or experience give you an edge with this group?

You need earned advantage. Domain knowledge, professional network, technical expertise, or lived experience that lets you build something better or faster than a random competitor. Fit is your moat at the earliest stage.

Test: Ask yourself what you know about this ICP that most people lack. If the answer is “zero,” you are competing on execution alone against people who have both execution and insight.

Example: A former tax accountant building automation for tax firms has massive fit. A career developer building automation for dental practices has zero fit. Both can build the product. The former builds the right product faster.

The Narrowing Funnel (Hormozi-Derived)

Once your ICP passes all four filters, sharpen it with this question sequence. Each question narrows the field.

  1. Who specifically? Start broad: “Business owners.” Narrow: “E-commerce business owners.” Narrower: “E-commerce business owners doing $1M to $10M in revenue.” Each level removes people who dilute your message.

  2. What is their situation? Describe the context that creates the problem. “E-commerce owners managing inventory across three warehouses with a team of five and lacking a dedicated operations person.”

  3. What is the painful version? Find the acute symptom. “SKU mismatches causing stockouts on best-selling items during peak season.” This is what keeps them up at night.

  4. What triggers them to seek help right now? Identify the event that converts latent frustration into active purchasing. “Black Friday inventory errors cost them $50K in lost sales last year, and Q4 is eight weeks away.” That is urgency.

  5. What is the outcome they would pay for? State the result in their language. “Eliminate SKU mismatches so every order ships correct and on time.” The outcome, the result, rather than the feature.

The Lighthouse Client Method (Rmosh)

The Narrowing Funnel gives you a precise segment. The Lighthouse Client Method grounds it in a real human being.

  1. Identify one person you would love to help. A specific individual. A former colleague, a client you worked with, a person from a community you belong to. Someone you can picture clearly.

  2. Map their entire day. From morning to evening, what do they do? Where do they spend time? What tools do they open? What meetings drain them? What tasks feel like wasted effort?

  3. Find the friction point they complain about most. The thing they mention unprompted. The task that makes them groan. The process they describe as “the worst part of my week.”

  4. Build for that person, then generalize. Create the solution that eliminates their specific friction. Then ask: who else has this same friction in this same context? Those people are your ICP.

This method works because it anchors your product in observed behavior instead of imagined needs. You solve a real problem for a real person. Other people with the same problem recognize themselves in your messaging because it describes their actual experience.

The Two Big Beginner Mistakes

Mistake 1: “My ICP is everyone who might pay.” This feels safe. It is the opposite of safe. Broad targeting produces generic messaging. Generic messaging converts at a fraction of specific messaging. You attract marginal customers who churn fast because the product serves everyone poorly instead of serving someone exceptionally.

Fix: Define your ICP by best-fit criteria and disqualifiers. Write down who you serve and who you deliberately exclude. Disqualifiers sharpen your positioning as much as qualifiers. “We help e-commerce operators doing $1M to $10M. Enterprise teams and solopreneurs fall outside our focus.”

Mistake 2: Choosing a niche based on passion or identity, assuming the market rewards authenticity. Passion is a starting point. It falls short as a standalone strategy. The market rewards value, and value requires craft. Building for a niche you love where you lack skill and produces mediocre products competing against people with genuine expertise.

Fix: Replace passion-first with craft plus pull. Craft means your skill gives you an edge. Pull means the market signals demand. When craft and pull align, you have a sustainable position. When they misalign, you have a hobby.

The Prompt Toolkit

ICP Extraction Prompt

Copy the prompt below, replace the placeholder with your business idea, and paste it into any LLM.

<role>You are a ruthless ICP analyst. You eliminate weak assumptions and surface the truth about whether a business idea has a viable target customer.</role>

<task>Run the 4-Filter Test on the business idea below. Score each filter from 1 to 10. For each filter, provide the score, the reasoning, and the specific evidence a builder should gather to validate or invalidate the score. Be brutally honest. Affirmative evidence only; discard wishful thinking.</task>

<filters>
 <filter name="Pain">
 <question>Are real people experiencing this problem and actively seeking solutions right now?</question>
 <scoring_guide>10 = People post daily in public forums begging for a fix. 5 = People complain occasionally. 1 = You assume the pain exists based on logic alone.</scoring_guide>
 </filter>
 <filter name="Market">
 <question>Is there a group already spending money to solve this problem?</question>
 <scoring_guide>10 = Multiple paid products with pricing pages and reviews. 5 = One or two niche tools exist. 1 = Zero paid solutions exist.</scoring_guide>
 </filter>
 <filter name="Access">
 <question>Can you reach these people through channels you can actually use this week?</question>
 <scoring_guide>10 = You already have an audience or direct connection. 5 = You can reach them through public communities. 1 = They hide behind gatekeepers and enterprise sales cycles.</scoring_guide>
 </filter>
 <filter name="Fit">
 <question>Does your skill or experience give you an edge with this group?</question>
 <scoring_guide>10 = You have years of domain expertise and a network. 5 = You have adjacent skills. 1 = You have zero connection to this world.</scoring_guide>
 </filter>
</filters>

<output_format>
Return your response in this exact structure:
<result>
 <idea_summary>One-sentence restatement of the idea</idea_summary>
 <filter name="Pain" score="X">Reasoning and evidence to gather</filter>
 <filter name="Market" score="X">Reasoning and evidence to gather</filter>
 <filter name="Access" score="X">Reasoning and evidence to gather</filter>
 <filter name="Fit" score="X">Reasoning and evidence to gather</filter>
 <total_score>X/40</total_score>
 <verdict>PASS if total >= 28, CONDITIONAL if 20-27, FAIL if below 20</verdict>
 <next_action>One specific thing the builder should do next</next_action>
</result>
</output_format>

<business_idea>
[PASTE YOUR BUSINESS IDEA HERE]
</business_idea>

Lighthouse Client Prompt

Copy the prompt below, answer the questions honestly, and paste it into any LLM.

<role>You are a product strategist who specializes in grounding abstract customer profiles in real human behavior. Your method is the Lighthouse Client Method: find one real person, observe their actual day, and surface the friction that drives purchasing.</role>

<task>Walk me through the Lighthouse Client Method step by step. Ask me one question at a time. Wait for my answer before proceeding to the next step. Complete all four steps.</task>

<steps>
 <step number="1" name="Identify">
 <instruction>Ask me to name one specific person I would love to help. This must be a real individual I can picture clearly: a former colleague, a past client, someone from a community I belong to. Ask for their first name (or alias), their role, and their industry.</instruction>
 </step>
 <step number="2" name="Map the Day">
 <instruction>Ask me to describe this person's typical workday from morning to evening. Prompt me to include: what tools they open, what meetings they attend, what tasks consume their time, and what feels like wasted effort. Probe for specifics.</instruction>
 </step>
 <step number="3" name="Find the Friction">
 <instruction>Ask me to identify the single task this person complains about most. The thing they mention unprompted. The process that makes them groan. Ask what they have tried to fix it and why those attempts fell short.</instruction>
 </step>
 <step number="4" name="Generalize">
 <instruction>Based on everything I shared, produce a one-paragraph ICP statement in this format: "People like [name], who are [role] at [type of company], who struggle with [specific friction] because [root cause], and who would pay for [outcome]."</instruction>
 </step>
</steps>

<output_format>
After I complete all four steps, output:
<lighthouse_result>
 <client_profile>Summary of the person I described</client_profile>
 <friction_point>The specific pain you identified</friction_point>
 <icp_statement>The one-paragraph ICP statement from Step 4</icp_statement>
 <validation_checklist>Three specific actions I should take this week to confirm this friction exists for five more people</validation_checklist>
</lighthouse_result>
</output_format>

ICP Validation CLI

Save the script below as icp_check.py, set your OPENROUTER_API_KEY environment variable, and run it.

import argparse, os, json, urllib.request

def main():
 p = argparse.ArgumentParser(description="4-Filter ICP Assessment via OpenRouter")
 p.add_argument("idea", help="Your business idea description")
 p.add_argument("--model", default="google/gemini-2.0-flash-001")
 args = p.parse_args()
 key = os.environ.get("OPENROUTER_API_KEY", "")
 assert key, "Set OPENROUTER_API_KEY env var"
 prompt = f"""Score this business idea on the 4-Filter ICP Test. Each filter gets 1-10.
Filters: Pain (active problem seekers?), Market (existing spend?), Access (reachable channels?), Fit (your edge?).
Idea: {args.idea}
Return JSON only: {{"pain": int, "market": int, "access": int, "fit": int, "total": int, "verdict": "PASS|CONDITIONAL|FAIL"}}"""
 body = json.dumps({"model": args.model, "messages": [{"role": "user", "content": prompt}]}).encode()
 req = urllib.request.Request("https://openrouter.ai/api/v1/chat/completions", data=body,
 headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
 resp = json.loads(urllib.request.urlopen(req).read())
 r = json.loads(resp["choices"][0]["message"]["content"])
 print(f"Pain: {r['pain']}/10 | Market: {r['market']}/10 | Access: {r['access']}/10 | Fit: {r['fit']}/10")
 print(f"Total: {r['total']}/40 | Verdict: {r['verdict']}")

if __name__ == "__main__":
 main()

Caveats

The 4-Filter Test eliminates bad ICPs fast. It can also create false confidence if you lie to yourself on any filter. Confirmation bias is the enemy. Run each filter assuming your ICP fails, and look for evidence that it passes. The opposite approach, seeking evidence that confirms your hope, leads to the same wasted months the test is designed to prevent.

The Lighthouse Client Method risks overfitting to one person. Your lighthouse client may have idiosyncratic needs that diverge from the broader market. After building for them, validate that the problem generalizes. Talk to five more people in the same segment. If three of five describe the same friction, you have product-market signal. If only one of five does, you have a consulting client.

Markets shift. An ICP that passes all four filters today may fail in six months as conditions change. Revisit the test quarterly. Treat your ICP as a hypothesis, and treat revenue as the experiment result.

Philosophy

The best product strategy starts with ruthless selection, and selection means elimination. Every person you exclude from your ICP makes your messaging sharper for the people who remain. Every filter you apply removes a possible path to wasted effort.

Building AI tools is easier than ever. The moat has moved from technical execution to problem selection. The builders who win are the ones who chose the right problem before they wrote a single function. The 4-Filter Test is how you choose correctly.

Specificity is generosity. A vague ICP leaves every reader uncertain whether this product serves them. A precise ICP tells the right people, “this was built for you, and you can see it.” That clarity converts.

This is the first entry in the Caliber Series, a paid column on building and selling AI tools. The next article breaks down how to validate your ICP in 48 hours using zero but free tools and five conversations. Upgrade to access the full series.

Open VSX vs VS Code Marketplace — where should you publish your extension first?

I built Dusk Office for myself.

No seriously — I was the only user. Ever. It was just my personal theme that I used every single day while working on my projects. I liked how it looked, it felt premium, and it made my long coding sessions easier on the eyes.

One day I thought: why not just publish it? like all the cool kids do 😄

So I did. I pushed it to Open VSX and the VS Code Marketplace at the same time, mostly out of curiosity. I didn’t expect much — there are already thousands of color themes out there.

Then I started seeing devs install it. Sometimes 200 downloads in a single day. That motivated me to push updates regularly. With my new AI colleague I could even ship two updates in the same day.

6 weeks later:

  • Open VSX → 5 200+ downloads
  • VS Code Marketplace → 56 downloads

Same extension. Same period. Zero promotion. No Reddit, no Twitter, nowhere.

I was just as surprised as you are right now.

Wait… what is Open VSX?

If you only use VS Code, you might not know Open VSX exists.

It’s an open-source extension registry used by editors that can’t access the official Microsoft Marketplace — think Cursor, VSCodium, Windsurf, Gitpod, Theia…

These editors have millions of users. And they all pull from Open VSX.

Honestly, I had no idea this registry even existed before I published.

Why the gap?

My theory:

Cursor and Windsurf users care more about themes.

They’re the kind of devs who customize everything — their editor, their terminal, their workflow. When they look for a theme, they actually browse and try things.

VS Code users? A lot of them just stick with the default or grab the first popular theme they find (One Dark Pro, Dracula, etc.). The market is more saturated and harder to break into.

On Open VSX, there’s less competition. A quality theme stands out faster.

What this means if you’re building an extension

If your extension targets developer tools, themes, or productivity — publish on Open VSX first. The audience is smaller but more engaged.

If your extension is more mainstream or targets beginners — the VS Code Marketplace is still the bigger pond.

Ideally? Publish on both. It takes 5 minutes extra and the upside is real.

My next move

Now that I know Open VSX is where my audience lives, I’m doubling down — better screenshots, better description, more variants.

The VS Code Marketplace is still an untapped opportunity for me. 56 downloads means almost nobody has seen it there yet. Same product, fresh audience.

That’s basically free growth waiting to happen. 🚀

Im a Nvidia Developer Champion!

I’m excited to share that I’ve been selected as an NVIDIA Developer Champion.

Over the past few years, a large part of my work has revolved around developers, AI, cloud infrastructure, and technical communities. From working on Power BI and Microsoft Fabric at Microsoft, to machine learning observability projects, hackathons, developer programs, student communities, and technical speaking, I’ve always been drawn to spaces where people are actively building and sharing ideas.

The NVIDIA Developer Champion program feels aligned with that.

What I appreciate about the developer ecosystem around NVIDIA is how practical and builder-focused it is. A lot of the conversations are grounded in real systems, real experimentation, and real technical challenges. Whether people are working on AI infrastructure, robotics, accelerated computing, computer vision, simulation, or open-source tooling, there is a strong culture of people sharing what they are learning as they go.

My background has crossed several areas of technology. I studied computer science at Western University and have worked across product management, cloud infrastructure, and engineering roles. I previously worked on ML and LLM observability at Datadog, and today I work in Azure Engineering Operations at Microsoft. Alongside work, I’ve also spent a lot of time organizing developer events, mentoring students, speaking at conferences, and helping early-career engineers navigate careers in tech.

Some of the most meaningful opportunities in my career started through communities like these. A hackathon conversation, a meetup, a technical demo, or someone sharing what they were building often opened doors that formal processes never could.

That’s one reason why I still care deeply about technical communities, even as the industry changes quickly around AI. We are entering a period where the gap between ideas and execution is shrinking fast. Individual developers can now build systems that previously required much larger teams. Open-source projects move quickly. AI tooling is changing how people prototype, research, write code, and learn new domains. Infrastructure and compute are becoming part of everyday developer conversations in a way that felt much more specialized a few years ago.

I think communities matter even more in environments like this.

People learn faster when knowledge is shared openly. Developers improve faster when they can see how others approach problems. Early-career engineers benefit tremendously from spaces where experimentation is encouraged and where technical curiosity is taken seriously.

As part of the NVIDIA Developer Champion community, I’m looking forward to contributing more through technical writing, developer education, projects, demos, events, and community collaboration. I’m especially interested in areas involving AI infrastructure, developer tooling, reliability engineering, machine learning systems, and practical applications of AI in real workflows.

I’m also excited to learn from other people in the community. One of the best parts of technology is that there is always another domain, system, or perspective to explore.

Grateful for the opportunity and excited for what’s ahead.

OpenAI GPT 5.5 Event

Last week I flew from Seattle to San Francisco for the OpenAI GPT-5.5 Event and had a great experience meeting people working across AI infrastructure, research, developer tooling, and startups.

One of the best parts of the event was getting the chance to talk directly with Members of Technical Staff and engineers about the technical challenges behind building and deploying large-scale AI systems. A lot of the conversations were very practical. People discussed reliability, inference, agents, developer workflows, evaluation, and what they are seeing from builders using these models in production.

I also enjoyed meeting developers and founders from the broader AI community. There were a lot of interesting side conversations about projects people are building, where the tooling ecosystem is heading, and how quickly the space is moving right now. It was one of those events where you could walk into almost any conversation and learn something useful.

As someone working in cloud reliability engineering at Microsoft and interested in AI systems and infrastructure, I appreciated hearing different perspectives from people building at different layers of the stack.

Thanks to the OpenAI team for organizing the event and bringing together such a strong builder community. I left San Francisco with a lot of new ideas and a better understanding of where the ecosystem is heading.


Image generated with 5.5

Build a Type-Safe Next.js 15 + Strapi v5 Blog in 10 Minutes

Next.js + Strapi is one of the best stacks for content-driven sites in 2026. Server Components, ISR, app router, and Strapi v5’s clean REST API just click together.

But there’s one part that still hurts: typing the data.

You ship your Strapi schema, then sit down in Next.js and… you’re back to writing interfaces by hand. Then you forget to populate a relation and your category.name access blows up at runtime in a Server Component, which means a full page error instead of a clean TS warning.

Today we’ll fix all of that — end to end — with a small open-source package called strapi-typed-client. By the end of this tutorial you’ll have:

  • A typed Strapi client with full autocomplete
  • Types that regenerate automatically on next dev and next build
  • Populate calls where TypeScript knows exactly which nested fields are available
  • A real working Next.js 15 app reading from Strapi v5

No manual interfaces. No as any. No GraphQL.

Let’s build it.

What we’ll build

A tiny blog. Two content types in Strapi:

  • Article — title, slug, body (rich text), cover (media), category (relation), author (relation)
  • Category — name, slug

And two pages in Next.js:

  • / — list of latest articles with cover image and category
  • /articles/[slug] — full article with author bio

Standard stuff. The interesting part is everything in between.

Step 1 — Install the plugin on the Strapi side

In your Strapi v5 project:

npm install strapi-typed-client

Then enable it in config/plugins.ts:

// config/plugins.ts
export default {
  'strapi-typed-client': {
    enabled: true,
  },
}

Restart Strapi. The plugin exposes your schema at GET /api/strapi-typed-client/schema plus a live /schema-watch SSE endpoint we’ll use later.

That’s the whole server side.

Step 2 — Install the same package in your Next.js app

npm install strapi-typed-client

Yes, the same package. It contains both the Strapi plugin and the Next.js client — the right entry point gets used depending on where you import from.

Step 3 — Hook it into next.config.ts

This is the part that does the magic:

// next.config.ts
import type { NextConfig } from 'next'
import { withStrapiTypes } from 'strapi-typed-client/next'

const nextConfig: NextConfig = {
  // your existing Next.js config
}

export default withStrapiTypes({
  strapiUrl: process.env.NEXT_PUBLIC_STRAPI_URL ?? 'http://localhost:1337',
  token: process.env.STRAPI_TOKEN, // optional, only if your plugin requires auth
})(nextConfig)

What this does:

  • On next dev — connects to Strapi via SSE and regenerates types the moment your schema changes. Add a field in Strapi admin → TS knows about it before you tab back to your editor.
  • On next build — runs a one-time sync generation before the build kicks off.
  • On next start — does nothing (types are already in place).

No separate watcher process. No concurrently. No predev script. It just works as part of your normal Next.js lifecycle.

Step 4 — Generate types for the first time

You can let next dev do it automatically, or trigger it manually:

npx strapi-types generate --url http://localhost:1337

Generated files land in node_modules/strapi-typed-client/dist. (If you’d rather commit the generated files into your repo, use --format ts --output ./src/strapi — handy for monorepos.)

Step 5 — Build the home page

Here’s the entire app/page.tsx:

// app/page.tsx
import Image from 'next/image'
import Link from 'next/link'
import { StrapiClient } from 'strapi-typed-client'

const strapi = new StrapiClient({
  baseURL: process.env.NEXT_PUBLIC_STRAPI_URL ?? 'http://localhost:1337',
})

export default async function HomePage() {
  const { data: articles } = await strapi.articles.find({
    sort: ['publishedAt:desc'],
    pagination: { page: 1, pageSize: 10 },
    populate: {
      cover: true,
      category: true,
    },
  })

  return (
    <main>
      <h1>Latest articles</h1>
      <ul>
        {articles.map((article) => (
          <li key={article.documentId}>
            <Link href={`/articles/${article.slug}`}>
              {article.cover && (
                <Image
                  src={article.cover.url}
                  alt={article.cover.alternativeText ?? ''}
                  width={400}
                  height={200}
                />
              )}
              <h2>{article.title}</h2>
              <span>{article.category.name}</span>
            </Link>
          </li>
        ))}
      </ul>
    </main>
  )
}

Pause and look at article.category.name. Try it in your editor. Hover over category — TypeScript knows it’s the populated Category entity, not number | Category | undefined. Hover over cover — typed as Media, with url and alternativeText.

Now delete category: true from the populate object. TypeScript immediately marks article.category.name as an error: Property 'name' does not exist on type 'number'.

This is the part nobody else does. The whole point of Strapi’s populate API is that the response shape depends on what you asked for. Most clients just type it as a union and shrug. This one infers the actual returned shape from your populate input.

Step 6 — Build the article detail page

// app/articles/[slug]/page.tsx
import { notFound } from 'next/navigation'
import { StrapiClient } from 'strapi-typed-client'

const strapi = new StrapiClient({
  baseURL: process.env.NEXT_PUBLIC_STRAPI_URL ?? 'http://localhost:1337',
})

export default async function ArticlePage({
  params,
}: {
  params: Promise<{ slug: string }>
}) {
  const { slug } = await params

  const { data: articles } = await strapi.articles.find({
    filters: { slug: { $eq: slug } },
    populate: {
      cover: true,
      category: true,
      author: {
        populate: { avatar: true },
      },
    },
  })

  const article = articles[0]
  if (!article) notFound()

  return (
    <article>
      <h1>{article.title}</h1>
      <div>
        <img src={article.author.avatar.url} alt={article.author.name} />
        <span>by {article.author.name}</span>
      </div>
      <p>{article.body}</p>
    </article>
  )
}

Note the nested populate for author.avatar. The returned type is inferred all the way down — article.author.avatar.url is fully typed, but if you remove the inner populate: { avatar: true }, accessing .url becomes a TS error.

Step 7 — Filters and operators (also typed)

Strapi’s filter operators ($eq, $contains, $gte, $or, etc.) are typed per field:

const { data } = await strapi.articles.find({
  filters: {
    title: { $contains: 'typescript' },
    publishedAt: { $gte: '2026-01-01' },
    $or: [
      { featured: { $eq: true } },
      { category: { slug: { $eq: 'editors-pick' } } },
    ],
  },
})

Try writing views: { $contains: 'foo' } on a numeric field — TypeScript stops you. No more Invalid filter operator runtime errors from Strapi.

Step 8 — Caching and revalidation

Since the client uses the global fetch, all of Next.js’s caching mechanics apply automatically. Pass a second argument to opt in:

// Always fresh
await strapi.articles.find({ /* params */ }, { cache: 'no-store' })

// ISR — revalidate every 60 seconds
await strapi.articles.find({ /* params */ }, { next: { revalidate: 60 } })

// Tag-based revalidation
await strapi.articles.find(
  { /* params */ },
  { next: { tags: ['articles'] } },
)

// Then somewhere in a Server Action:
import { revalidateTag } from 'next/cache'
revalidateTag('articles')

These options are fully typed — same shape Next.js’s fetch accepts.

Step 9 — The “rename a field” moment

This is the moment that sells the whole thing.

  1. Keep next dev running.
  2. Open Strapi admin in another tab. Rename title to headline on the Article content type. Save.
  3. Tab back to VS Code.

Within a second or two, every article.title in your codebase lights up red. The watcher caught the schema change, regenerated types, and TypeScript re-checked your project.

No restart. No manual command. No “wait, what did the field used to be called?” archaeology.

This is what withStrapiTypes buys you, and it’s the single biggest DX win in the whole package.

Step 10 — Handling errors properly

Server Components fail loudly when fetches throw. The client exports typed errors so you can handle them gracefully:

import { StrapiClient, StrapiError, StrapiConnectionError } from 'strapi-typed-client'

try {
  const { data } = await strapi.articles.find()
  return <ArticleList articles={data} />
} catch (error) {
  if (error instanceof StrapiConnectionError) {
    // Strapi is down — show a friendly fallback
    return <BackendOffline />
  }
  if (error instanceof StrapiError && error.status === 401) {
    // Token expired
    return <NeedAuth />
  }
  throw error
}

Quick gotcha: as const for populate objects

If you extract a populate object to a variable, annotate it with as const — otherwise TS widens the literal trues to boolean, and the inference breaks:

// ❌ Wrong — inference breaks
const populate = { category: true, cover: true }

// ✅ Correct
const populate = { category: true, cover: true } as const

await strapi.articles.find({ populate })

Same pattern as satisfies for config objects. Once you know it, it’s invisible.

What you got

Recap of what this 10-step tutorial set up:

  • One package, two install points (Strapi + Next.js)
  • Zero-config type generation tied to next dev and next build
  • Live regeneration on schema changes via SSE
  • Populate calls where the returned type follows the populate input
  • Typed filters, sorting, pagination
  • First-class Next.js caching options
  • Typed error classes for failure handling

No manual interfaces. No GraphQL. No second watcher process. Your Strapi schema is the single source of truth, and your Next.js code knows about it without you doing anything.

Try it

npm install strapi-typed-client

That’s the only command you need on either side — the same package powers both the Strapi plugin and the Next.js client.

Full docs live at boxlab-ltd.github.io/strapi-typed-client, source is on GitHub. If you run into anything weird, open an issue — I read all of them.

Now go rename a field in Strapi and watch TypeScript catch it. That part doesn’t get old.

Session Control Update

Inspired by this https://towardsdatascience.com/how-i-continually-improve-my-claude-code/ I added @session-control /analyze and /implement commands to my Session Control VSCode extension that analyzes the chats saved in the .chat folder for things that could be added to your AGENTS.md, .github/copilot-instructions.md, CLAUDE.md etc. to make future chats run smoother.

https://marketplace.visualstudio.com/items?itemName=darrenjmcleod.session-control