Every product team eventually meets the same uncomfortable chart: signups healthy, activation acceptable, and then a usage curve that decays week after week until only a stubborn minority remains. The instinct is to fight it with reminders — more emails, more notifications, a re-engagement campaign. It works for a week. Then the curve resumes its descent, because nothing changed inside the product; you just got louder outside it.
The Hook Model is a framework for changing what happens inside. Published by Nir Eyal in Hooked: How to Build Habit-Forming Products, it describes a four-phase loop — trigger → action → variable reward → investment — that a user passes through repeatedly, and argues that each completed pass makes the next one slightly more likely to start on its own. Run it enough times and the job of opening your product transfers from your notification system to the user's own recurring context. That is what a habit is, mechanically: a behavior that no longer needs a prompt from you.
This guide covers the whole model: what it is and who created it, each of the four phases in depth, how the loop honestly differs in B2B SaaS from the consumer apps it's usually illustrated with, worked hook examples, a step-by-step method for designing your product's loop, the Manipulation Matrix ethics test that decides whether you should build it at all, and the metrics that tell you whether a habit is genuinely forming or you're just looking at your loudest users.
Key Takeaways
- The Hook Model has four phases: trigger, action, variable reward, and investment — a loop the user runs repeatedly, not a funnel they exit.
- The goal is transferring the trigger. You start with external triggers (emails, notifications, in-app prompts); a habit exists when an internal trigger — a recurring situation or feeling — starts the loop instead.
- Rewards must vary to keep working. Identical payoffs stop registering; Eyal groups variability into rewards of the tribe, the hunt, and the self.
- Investment is the phase B2B wins on. Imported data, configured workflows, and invited teammates make the product better next time — and quietly load the next trigger.
- B2B loops run on work rhythms, not boredom. Weekly or per-sprint is an honest target; the consumer playbook of interruption and artificial scarcity actively backfires with buyers.
- The ethics test is not optional. The Manipulation Matrix asks whether the product improves users' lives and whether you use it yourself — a habit serves the user's goal, an addiction serves yours.
What Is the Hook Model? (Definition & Origin)
The Hook Model is a design framework for building products people use out of habit rather than obligation. Instead of treating engagement as a marketing problem solved from outside the product, it treats habit as something the product's own mechanics either manufacture or fail to. Its central claim is that habits are built by repetition through a specific four-phase sequence, and that each pass through the sequence strengthens the mental association between a user's recurring internal state and your product as the response to it.
The Hook Model, defined. A four-phase loop — trigger (what prompts the behavior), action (the simplest behavior performed in anticipation of a reward), variable reward (a payoff whose form varies enough to keep anticipation alive), and investment (something the user puts into the product that increases its future value to them and loads the next trigger) — designed to be run repeatedly, so that the product moves from being remembered to being reached for.
The model was published in 2014 by Nir Eyal, with Ryan Hoover, in Hooked: How to Build Habit-Forming Products. Eyal did not invent its ingredients; he assembled them. The action phase leans directly on B.J. Fogg's behavior model from the Stanford Behavior Design Lab — the observation that a behavior happens only when motivation, ability, and a prompt arrive at the same moment — and the reward phase draws on a long line of research into variable reinforcement schedules. What Hooked contributed was sequence and usability: four named phases a product team can hold a design review against.
It is worth being precise about what the model does and doesn't claim, because it is routinely overstated. The Hook Model does not make a bad product sticky, and it does not create demand. It is a framework for compounding value that already exists — for making sure a user who found something genuinely useful comes back to it without needing to be chased. If your users never reach their aha moment, no hook will save you; you have an activation problem, and building a loop around a reward nobody wants just automates the disappointment.
The Four Phases of the Hook Model
The loop, in one picture. Note that it is a circle, not a line: the investment phase is what feeds the next trigger, which is the entire reason the model describes habit rather than a single conversion.
The Hook Model: four phases run as a loop, where the user's investment in phase four is what makes phase one fire again — and each completed cycle makes the next one likelier to start without you.
1. The trigger — what starts the loop
Triggers come in two kinds, and the distance between them is the whole game. External triggers live outside the user and carry their instruction with them: a notification, an onboarding email, an in-app message, a link a colleague pasted into a channel, a button whose label tells you what will happen when you press it. New users need these, because they have no reason yet to think of you unprompted.
Internal triggers live inside the user, need no instruction, and are usually a recurring situation or emotion. In consumer products these are famously feelings — boredom, loneliness, uncertainty. In B2B they are far more often situations: the Monday morning before the pipeline review, the moment a customer asks a question you can't answer from memory, the pre-standup check on whether the deploy went out. The habit exists when that situation, all by itself, calls your product to mind. Everything else in the model is machinery for making that association form.
2. The action — the simplest behavior done in anticipation
The action is the smallest thing a user does expecting a reward: opening the dashboard, running the search, hitting refresh. Eyal takes his rule for this phase straight from B.J. Fogg: a behavior happens when motivation, ability, and a prompt converge at the same moment, and if any one is missing, the behavior doesn't. The practical consequence is that when a hook fails at this phase, the answer is almost never "add more motivation." Motivation is expensive and volatile; ability is something you control directly.
Motivation, ability, and a prompt have to arrive together. When the hook stalls, shortening the path to the reward moves the behavior across the action line far more reliably than trying to make users want it more.
3. The variable reward — the payoff that isn't identical every time
This is the phase most teams get wrong, usually by making the reward perfectly predictable. A predictable payoff stops registering: once the brain knows exactly what's coming, anticipation collapses and the behavior loses its pull. It's why a badge awarded for every single action is invisible within a week, and why a dashboard showing the same number every time gets checked less and less.
Eyal sorts variable rewards into three families, and knowing which one you're using is a genuinely useful design decision:
- Rewards of the tribe — social payoffs. Recognition, a teammate's reaction, a comment on your work, seeing where you stand among peers. In B2B this is real but narrow: collaboration notifications and shared-work visibility qualify; leaderboards usually don't.
- Rewards of the hunt — the search for a resource. Fresh data, new leads, a matching record, the answer to a question. This is the workhorse of B2B SaaS: an analytics view, an inbox, a search result, and a pipeline are all hunts, and they are variable for free because the underlying reality genuinely changes.
- Rewards of the self — mastery, competence, and completion. Finishing the task, clearing the queue, watching a skill develop, seeing a process you built run cleanly. This is the family that onboarding gamification tries to bottle, and the one that ages best in professional tools, because competence at your job doesn't get old.
4. The investment — what stores value and loads the next trigger
Investment is the phase that separates the Hook Model from an ordinary engagement loop, and it does two jobs at once. First, it makes the product better next time: the user contributes data, content, configuration, integrations, followers, or reputation, and that contribution has no value until they return to it. Second, it plants the next external trigger — inviting a teammate creates a future notification, setting an alert creates a future email, importing a data source creates a future report worth checking.
The order matters and is easy to get backwards. Investment is asked for after the reward, not before it, because a user who has just been paid is willing to contribute and a user who hasn't been paid yet is being taxed. This is exactly why a well-built onboarding checklist works and a wall of mandatory setup fields doesn't: the checklist sequences small investments, each following a visible payoff, instead of collecting them all up front from someone who still has no idea whether the product is worth it.
Fixed vs. Variable Reward: The Same Loop, Two Outcomes
Here is the reward phase built twice, live on this page. Both panels refresh at the same rate; the only difference is whether what arrives is the same thing every time.
The distinction is not decorative. On the left, the user learns after three visits that opening the product teaches them nothing they didn't already know, and each subsequent visit is a small withdrawal from their patience. On the right, the reward is uncertain in form while remaining reliable in value — which is the combination that keeps the loop running. And note that the right panel isn't a trick: the variability comes from the user's actual work changing. That's the sustainable kind. Manufactured variability — randomized rewards attached to nothing real — works briefly and then reads as noise, which is the fastest way to convert an engaged user into banner blindness.
The Hook Model in B2B SaaS: What Changes
Nearly every popular illustration of the Hook Model comes from a consumer app, which is unfortunate, because B2B teams then either dismiss the model as irrelevant or import consumer tactics that actively damage a business relationship. The loop transfers; the tactics mostly don't. What actually differs:
| Phase | Consumer pattern | B2B SaaS pattern |
|---|---|---|
| Internal trigger | An emotion — boredom, FOMO, loneliness | A recurring work situation — the weekly review, the customer question, the pre-standup check |
| Action | A reflexive tap, seconds long | A deliberate task inside a workflow, often minutes long and interrupted |
| Variable reward | Mostly tribe — likes, replies, social feedback | Mostly hunt and self — fresh data, a surfaced insight, a cleared queue, a finished workflow |
| Investment | Content, follows, profile-building | Imported data, configured workflows, integrations, invited teammates — high-value and hard to reproduce elsewhere |
| Honest cadence | Daily, often many times a day | Weekly or per-sprint for most tools; daily only where the job itself is daily |
| Who you're persuading | The user, who is also the buyer | Often several users plus a buyer who reads the invoice and the usage report |
Two of these deserve emphasis. The first is cadence: chasing daily usage for a tool whose underlying job is weekly is a self-inflicted wound. You will build notification pressure to hit a number that doesn't reflect value, annoy the exact people who renew, and end up reading a DAU/MAU ratio that was never the right measure — see the product stickiness guide for how to pick a denominator that matches your product's natural rhythm. The right target is the loop firing every time the job recurs, whatever that interval is.
The second is that B2B is structurally strong at investment, which is the phase consumer products struggle with most. A user who has imported their data, built three workflows, connected two integrations, and brought in four teammates has accumulated stored value that is genuinely painful to recreate. That is a durable moat and a legitimate one — provided it was built from value the user chose to store, not from an export button you quietly declined to ship.
The tactics that don't transfer. Interruption, artificial scarcity, streak guilt, and notification volume all measure well in consumer apps for a while. In B2B they collide with a professional who has a job to do and a manager who signs the renewal. A hook built on interruption in a work tool doesn't create a habit — it creates a support ticket, then a champion who stops defending you at renewal time. The B2B loop has to be built out of the work itself.
Hook Model Examples: Three Loops, Fully Mapped
The model only becomes useful when you can write your own loop out phase by phase. Three worked examples in familiar SaaS categories, each mapped across all four phases:
-
A product analytics tool
Trigger: external — a Monday morning digest email; internal — the recurring "did last week's release actually land?" question before the team meeting. Action: open the dashboard and look at one chart. Variable reward: the hunt — the numbers genuinely differ each week, and occasionally one of them is a surprise worth telling someone about. Investment: save the view, set a threshold alert, invite a teammate to the workspace — each one making next Monday's visit faster and more personal, and each one loading a future trigger.
-
A customer support platform
Trigger: external — a new-ticket notification; internal — the shift-start reflex of "what's waiting for me?" Action: open the queue and take the top ticket. Variable reward: the self — clearing the queue and the competence of a well-handled case; plus the tribe, when a colleague or customer responds well. Investment: write a macro, tag the conversation, improve a help article — work that makes tomorrow's queue faster to clear and turns the tool into an accumulating personal asset.
-
A user onboarding platform (Kompassify's own loop)
Trigger: external — a weekly flow-performance summary; internal — shipping a feature and wondering whether anyone will find it. Action: open the builder and check how the last product tour performed. Variable reward: the hunt — completion and drop-off numbers that change with every cohort; the self — a flow you tuned from 54% to 82% completion. Investment: build the next tour, segment it, add a checklist — each one raising the value of the analytics you'll come back to read.
The pattern across all three: the reward is variable because the user's real world is variable, and the investment is a piece of work the user wanted to do anyway. Neither is bolted on. When a hook feels manipulative in practice, it's almost always because one of those two things was manufactured — a randomized reward attached to nothing, or an "investment" that benefits only the vendor.
How to Design Your Product's Hook: A Step-by-Step Method
Six passes, in order. Each one is a question you should be able to answer in a sentence before moving to the next:
- Name the internal trigger — the recurring situation you want to own.
- Pick the one action, and make it the shortest path to a payoff.
- Choose the reward family, and find your genuine variability.
- Design the investment that follows the reward — never precedes it.
- Close the loop: make the investment create the next trigger.
- Instrument it, then run it against real users and fix the weakest phase.
1. Name the internal trigger you want to own
Write it as a specific recurring moment, not a category. "When a CSM is preparing for a renewal call and doesn't know if the account is healthy" is a trigger you can design against. "When users want insights" is not. The test is whether you can say when it happens, how often, and what the person is feeling or trying to accomplish. If you can't, you don't have a trigger yet — you have a positioning statement, and the fastest way to find the real one is to talk to the users who already come back without prompting and ask what was happening right before they opened the product. Your user personas and journey map are the right places to record what you find.
2. Pick the one action, and shorten the path to the reward
Name the single simplest behavior that leads to the payoff — one behavior, not a workflow. Then attack the distance between the trigger and that behavior, because that distance is where hooks die. Count the clicks, the loading states, the decisions, and the moments a user has to remember something. Every one you remove moves the behavior across the action line, and doing so is cheaper and more reliable than trying to raise motivation. This is ordinary friction work, and it pays here twice: once for the current loop, and again for every future one.
3. Choose the reward family and find real variability
Decide explicitly whether your payoff is a hunt, a tribe, or a self reward, then locate the variability already present in your users' reality — changing data, incoming work, evolving results, other people's activity. Surface it. If you genuinely cannot find any, that is important information: it usually means the product's value is a one-time setup rather than a recurring service, and no amount of loop design will change that. Manufacturing variability with random prizes is the wrong fix; finding a recurring job to serve is the right one.
4. Design the investment that follows the reward
List everything a user could contribute that makes their next visit better: data, configuration, content, a saved view, an invited colleague, a connected tool. Then place each request immediately after a moment of delivered value, never before it. Sequence the small ones first — the classic mistake is asking for the integration on day one, when the user has no evidence yet that the payoff is worth the effort, and the classic fix is a checklist that spaces those requests across the first sessions, each one following something the user just saw work.
5. Close the loop so the investment creates the next trigger
This is the step teams skip, and skipping it turns the model back into a funnel. For each investment, write down what future trigger it produces: the invited teammate generates a collaboration notification, the saved view generates a weekly digest worth opening, the configured alert generates a message that arrives exactly when it's relevant. If an investment produces no future trigger, it's storing value without compounding it — useful, but not a hook. And as the loop matures, deliberately retire the external triggers you no longer need: the goal is to hand the job of starting the loop to the user's own context, not to keep emailing someone who was already coming.
6. Instrument it, then fix the weakest phase
Measure each phase separately, because a loop fails at exactly one of them at a time and they need opposite responses. Trigger failure means users don't return at all; action failure means they return but don't do the thing; reward failure means they do the thing and don't come back; investment failure means they come back but nothing accumulates, so the loop never gets easier. Diagnose which one you have before you change anything — then change one phase, run it again, and measure the same four numbers.
Is the Hook Model Manipulative? The Manipulation Matrix
The Hook Model attracts the criticism that it is a manual for manufacturing compulsion, and the criticism is not baseless — the same four phases describe both a tool someone is glad to depend on and a product engineered to be hard to put down. Eyal's own answer is the Manipulation Matrix, a two-question test applied before you build the loop, not after you've shipped it.
The Manipulation Matrix asks two questions before you build a hook: does it materially improve the user's life, and do you use it yourself? Only one quadrant needs no further justification.
The matrix is useful precisely because it refuses the comfortable answer. Most product teams assume they're facilitators; the honest ones check. If nobody on the team uses the product for its stated purpose, you are at best a peddler and you owe yourself external evidence — research, outcomes, renewals for the right reasons — that the benefit users get is real rather than assumed.
Underneath the quadrants there is a simpler distinction worth carrying around: a habit serves the user's goal; an addiction serves yours at the user's expense. Both feel similar from inside the metrics, which is why the operational test matters more than the intention. Ask what your loop does when a user stops getting value. If the honest answer is that it works harder — more notifications, more streak pressure, more friction on the way out — the loop has stopped serving them, whatever your dashboard says.
Three practical guardrails. Ship the exit as carefully as the entrance: a visible cancel path and working data export cost you nothing if the product is good, and are the clearest signal that the value is real. Keep external triggers proportional and retiring — a prompt that fires after the habit exists is pure noise, which is why in-app guidance should retire per user once it's been consumed. And measure the outcome your users came for, not just the frequency they come at: usage that rises while their results don't is not a habit forming, it's a bill accumulating.
How to Measure Whether a Habit Is Actually Forming
The Hook Model is a hypothesis about your product, and like any hypothesis it needs numbers that can disprove it. Four signals, each answering a different question:
-
The flattening of the retention curve
The single most honest habit signal. Every product's usage decays after signup; the question is whether the curve eventually flattens into a stable plateau or keeps sliding to zero. A flattening retention curve means some cohort has formed a durable behavior — the loop is closing for them. A curve that never flattens means it isn't, no matter how good this month's engagement numbers look.
-
Usage frequency against your natural cadence
Compare how often users run the loop to how often the underlying job actually recurs. For a daily job, a DAU/MAU-style ratio is meaningful; for a weekly one, weekly active over monthly active is the honest measure. The stickiness question isn't "are they here every day" — it's "are they here every time the job comes around."
-
The share of sessions that start without an external trigger
The most direct measurement of the model's actual claim, and the one almost nobody instruments. Split sessions into those attributable to an email, notification, or campaign, and those that arrive unprompted. A rising share of unprompted sessions is a habit forming; a flat one means you're renting attention. If that number falls when a campaign pauses, you never had a hook — you had a reminder.
-
Accumulated investment per account
Count stored value directly: saved views, configured workflows, connected integrations, invited teammates, imported records. This is the leading indicator the others lag behind — accounts whose stored value grows retain, and accounts whose stored value stalls churn later regardless of how their session counts look today. It's also the earliest warning you'll get in your churn analysis.
Read together, these four localize the failure. Strong triggers and weak investment means people show up but nothing compounds — the loop resets every time. Strong investment and weak frequency means the value is real but the trigger hasn't gone internal yet, which is usually a positioning problem rather than a product one. And if none of them move, the problem is upstream of the hook entirely: users aren't reaching value in the first place, which is activation work, not habit work.
Building Hooks: Do vs. Don't
✅ Do
- Name one specific recurring situation as your internal trigger
- Shorten the path from trigger to reward before adding motivation
- Find variability in the user's real, changing work
- Ask for investment right after a delivered reward
- Make every investment produce a future trigger
- Retire external triggers as the internal one takes over
- Match your cadence target to the job's natural rhythm
- Run the Manipulation Matrix before you build the loop
❌ Don't
- Build a hook around a reward users don't actually want
- Deliver the identical payoff on every single visit
- Manufacture variability with prizes attached to nothing
- Collect setup work before the user has seen any value
- Chase daily usage for a weekly job
- Keep firing prompts at users who already return unprompted
- Use stored value as a hostage — always ship the export
- Mistake rising sessions for rising outcomes
Shipping the Loop Without a Release Cycle
Most of a hook is product work: the reward has to come from what your product genuinely does. But the phases that start and restart the loop — the external triggers, the first action, the visibility of the reward, and the prompts to invest — are guidance layers, and guidance layers are exactly what you want to change weekly without waiting on a release. That's the job Kompassify does:
- Make the action easy, in the moment. Product tours and tooltips shorten the path from trigger to reward at the exact step where users hesitate — ability work, applied where the action line is closest.
- Sequence the investments. An onboarding checklist spaces the contributions that make the product stickier — connect a source, save a view, invite a teammate — so each one lands after a visible payoff instead of before it.
- Keep surfacing the next reward. Hotspots and beacons cover feature discovery long after the tour is over, and retire per user once consumed — so a trigger never outlives its usefulness.
- Trigger the right people, not everyone. In-app announcements and segmentation put an external trigger in front of the users for whom it's still relevant, and leave the ones who already have the habit alone.
- See whether the loop closes. Built-in analytics show completion and drop-off per flow and per step, which is how you find the phase that's failing instead of guessing at it.
You design the loop; the guidance layer that starts it ships the same day you think of it. Kompassify is GDPR compliant and EU-hosted, free for under 100 monthly active users, with paid plans from $129/month.
Build the Loop, Not Just the Reminder
Kompassify puts product tours, onboarding checklists, hotspots, and in-app announcements on top of your existing product — no code, no release cycle — so you can make the first action effortless, sequence the investments that make users come back, and measure whether the loop actually closes. GDPR compliant, EU-hosted, and free for under 100 monthly active users.
Start for Free →Frequently Asked Questions
What is the Hook Model?
The Hook Model is a four-phase design framework for building habit-forming products, introduced by Nir Eyal in his book Hooked. The four phases are the trigger (what prompts the user to act), the action (the simplest behavior done in anticipation of a reward), the variable reward (a payoff whose exact form varies, which is what makes the loop compelling rather than boring), and the investment (something the user puts into the product — data, content, configuration, reputation — that both increases the product's value to them and loads the next trigger). Running a user through this loop repeatedly is how a product moves from something people must be reminded to open into something they reach for on their own, driven by an internal trigger such as a recurring situation or feeling rather than an email or notification.
What are the four phases of the Hook Model?
Trigger, action, variable reward, and investment. The trigger starts the loop and is either external (an email, a notification, an in-app prompt, a colleague sharing a link) or internal (a recurring feeling or situation that the product has become mentally associated with). The action is the simplest thing the user does expecting a payoff, and it happens only when motivation, ability, and a prompt converge at the same moment. The variable reward is the payoff itself, delivered with genuine variability so the loop stays interesting. The investment is the user's contribution back into the product — inviting a teammate, importing data, configuring a workflow — which makes the product better for them next time and plants the trigger for the following cycle. Each pass through the four phases strengthens the association between the internal trigger and the product.
Who created the Hook Model?
The Hook Model was created by Nir Eyal and published in 2014 in Hooked: How to Build Habit-Forming Products, co-authored with Ryan Hoover. It synthesizes existing behavioral science — notably B.J. Fogg's behavior model from the Stanford Behavior Design Lab, which holds that a behavior occurs when motivation, ability, and a prompt converge, and decades of research on variable reinforcement schedules — into a sequence product teams can actually design against. Eyal also authored the Manipulation Matrix, an ethics test for deciding whether a given hook should be built at all.
What is the difference between an external and an internal trigger?
An external trigger lives outside the user's head and tells them what to do next: a notification, an onboarding email, an in-app checklist, a link from a colleague, a button labeled with its own instruction. An internal trigger lives inside the user and needs no instruction — a recurring situation or emotion that automatically calls the product to mind, like feeling uncertain whether a release shipped, or needing to know how a campaign performed before a meeting. External triggers are how you start the loop with a new user; internal triggers are how the habit sustains itself once formed. The whole point of running the loop repeatedly is to transfer the job of starting it from your notification system to the user's own recurring context.
Why does the Hook Model use a variable reward instead of a fixed one?
Because predictable rewards stop registering. When the payoff is identical every time, the brain quickly learns exactly what to expect and the anticipation that drove the behavior fades — this is why a badge awarded for every action becomes invisible within a week. Variability keeps the reward system engaged, because the user knows a payoff is likely but not precisely what it will be. Nir Eyal groups variable rewards into three families: rewards of the tribe (social payoffs like recognition, comments, or a teammate's reaction), rewards of the hunt (searching for a resource — information, leads, answers), and rewards of the self (mastery, competence, completion, progress). Well-designed B2B products usually lean hardest on the hunt and the self, because the reward is real work value that genuinely differs each time.
Does the Hook Model work for B2B SaaS?
Yes, but the loop looks different than in consumer apps. B2B usage is bounded by work rhythms, so the honest target is often weekly or per-sprint rather than daily, and the internal trigger is usually a recurring job situation rather than boredom — the Monday pipeline review, the pre-standup check, the moment a customer asks a question. Variable rewards come mostly from the hunt and the self, not the tribe: fresh data, a surfaced insight, a completed workflow. And investment is where B2B is unusually strong, because imported data, configured workflows, connected integrations, and invited teammates make the product measurably more valuable with every cycle and are difficult to reproduce elsewhere. What does not transfer is the consumer playbook of interruption and artificial scarcity — in B2B those tactics burn trust with the exact person who renews the contract.
Is the Hook Model manipulative?
It can be, which is why its own author published a test for it. The Manipulation Matrix asks two questions: does the product materially improve the user's life, and does the maker use it themselves? A maker who uses the product and genuinely improves users' lives is a facilitator, and building a hook there is legitimate. A maker who does not use it but still improves lives is a peddler, and needs external evidence that the benefit is real. A maker who uses it while knowing it does not improve lives is an entertainer, and one who does neither is a dealer — a position with no ethical defense. The practical distinction is that a habit serves the user's goal while an addiction serves yours at the user's expense. The operational test is simple: if a user stops getting value, does your loop help them leave, or does it work harder to keep them?
How do you build a Hook Model loop without engineering time?
Most of the hook is product work, but the parts that start and restart the loop — the external triggers, the first action, the visible reward, and the prompts to invest — can be built without a release cycle using a no-code onboarding platform like Kompassify. Product tours and tooltips make the first action easy in exactly the moment it needs to be easy; onboarding checklists sequence the investments that make the product stickier and give each one a visible payoff; hotspots surface the next reward after the tour ends; and in-app announcements act as external triggers targeted at the right segment. Built-in analytics show where users complete or stall in each flow, which is what tells you whether the loop is actually closing. Kompassify is GDPR compliant and EU-hosted, free for under 100 monthly active users, with paid plans from $129/month.