Designing with Psychology to Make Products Stick

1. Delighters: we remember the small, unexpected delights

We remember the small surprises more than we realise, for instance, a Google Doodle that changes on the homepage or the reactions on iMessage. None of these changes the core product, but they leave an impression.

Although the catch here is that these work only if the basics are already in place. If the main flow is not a good enough experience, it’ll fall flat.

And these moments don’t quite stay novel forever; over time, they become a part of people’s expectations, which makes them lose their slight edge.

How can you use this?

1. Get the basics right first: never add delight on top of a broken flow. Nail the core experience before layering extras.
2. Make it context-aware: surprises should feel natural to the moment (like a progress bar that celebrates completion).
3. Use them sparingly: too many “delight” elements can feel forced or exhausting. Reserve them for key moments.
4. Evolve over time: what delights today becomes expected tomorrow. Keep refreshing or rotating to maintain impact.

Asana has a mythical creature flying across your screen whenever you complete a task on your board. It works because completing a task isn’t something you do every few seconds, so the delight doesn’t feel overdone.

2. Internal triggers: we form habits when triggers come from within, and not external cues

Think about how most apps get your attention in the beginning: it’s a ping on your phone, a badge icon on the app, or an email. These are external triggers from the outside designed to pull you in.

Those work at first, but the real turning point is when you don’t need those nudges anymore. For instance, you feel hungry, and a popular food delivery service pops into your head. You’re standing in line, and before you know it, you’re scrolling Instagram. You’re stressed, and your instinct is to open Spotify. No one had to remind you; the habit has already taken root.

That’s an internal trigger. The product has connected itself to a feeling or a situation in your day, and now the action feels automatic.

How can you use this?

1. Map the real triggers, don’t guess them: watch when users naturally reach for your product. Is it when they wake up? When they feel anxious about missing something? Design around those moments instead of forcing fake ones.
2. Make the first external trigger worth it: if you do send a notification, make sure the payoff is immediate and it’s not buried somewhere in the product. If the notification says “your order is arriving,” the tap should land straight on the live map, not the homepage.
3. Design the bridge from external to internal: the goal is to help the user internalise a loop. For example, Headspace starts with nudges at bedtime, but eventually, you don’t need a ping; the act of getting into bed becomes the trigger to open the app.
4. Be ruthless about when not to trigger: more reminders ≠ , more engagement. If the moment doesn’t align with a real user need, don’t send it.
5. Check the ethics of the loop: judge if your external triggers are meant to develop a positive habit.

OLIPOP positioned itself in a very real human moment: the 3 pm slump. It’s that time of day when you’re bored and running low on energy, but it feels too late for another coffee and too early for a cocktail. OLIPOP stepped right into that gap, positioning itself as the fun, guilt-free drink you can reach for mid-day. By tying the brand to a recurring emotional and situational trigger, they made sure that whenever people hit that slump, OLIPOP is the first thing that comes to mind.

3. False consensus effect: we overestimate how much others share our views

We tend to assume other people think like us. If you prefer the dark mode, you’ll believe most people do. If you find a flow intuitive, you’ll assume it’s obvious to everyone else. That’s the false consensus effect, the bias where we overestimate how much others agree with us.

In design, this is not fruitful. When you project your own habits, preferences, or shortcuts onto users, you start building for yourself, not for them.

How can you avoid this?

1. Start with real user research: assume nothing is obvious. ****Talk to people, watch them, gather patterns. Even rough interviews or quick surveys give you better assumptions than your own hunches.
2. Always validate those assumptions: research gives you clues, but testing tells you the truth. Run usability sessions, A/B tests, or simple prototypes and see what actually holds up.
3. Get feedback from a diverse user group: don’t just test with people like you. Find someone from a completely different context, that’s where hidden flaws show up.
4. Pay attention to behaviour, not words: users will tell you one thing and do another. What they click, skip, or struggle with matters more than what they say.

Juicero (a company that offered packets of diced fruits and vegetables, which users plugged into their $400 machines) shut down after their product failed in the market. Juicero assumed everyone cared about ultra-fresh cold-pressed juice and would happily buy a $400 machine to squeeze $7 packet, forgetting most people were fine with cheaper juice.

4. Tesler’s Law: we can’t reduce the complexity of a system, only shift it

Every product is going to be a little complicated. You can’t delete that complexity; you can only decide who deals with it.

Tesler’s Law (the law of conservation of complexity) says that if you simplify too much, you’ll transfer some complexity to the users. If you keep the hard work inside the product, the user’s job becomes easier.

How can you use this?

1. Don’t equate fewer clicks with less complexity: judge ease by cognitive effort, not just by screen count.
2. Design smart defaults: your job is to reduce user memory and manual input. Most people stick with what you pre-select. A well-chosen default (autofilled addresses, delivery option, suggested passwords, calculated totals, etc) can eliminate dozens of unnecessary decisions.
3. Use progressive disclosure: start simple, then reveal advanced settings or details only when the user wants to access them. For instance, a camera app that shows basic controls upfront but lets you open manual settings if you want finer control.
4. Design for layers of expertise: new users want less to think about. Experts want full control. Don’t flatten both into the same watered-down experience.

People sometimes struggle to save because they have to put aside a chunk of money, which is difficult for them. Acorns fixes that by rounding up users’ everyday purchases and automatically saving the spare change. It’s all automatic, happens in the background, and the user never has to think about it.

5. Hawthorne effect: we behave differently when we’re being observed

Back in the 1920s, a group of researchers ran an experiment at the Hawthorne Plant. They wanted to see if better lighting would make workers more productive. Turns out, the results had less to do with the light bulbs and more to do with the fact that workers knew they were part of an experiment. The simple awareness of being observed made them change how they worked.

That’s the Hawthorne effect in action: people behave differently when they know someone is watching.

Now, think about usability testing. If you sit next to a user and ask them to try out your app, chances are they’ll act more carefully than they would at home, alone on their couch. They’ll pay extra attention, and they might even avoid making “silly mistakes” because they don’t want to look clumsy in front of you. In other words, the behavior you’re seeing may not be their natural one.

For instance, when a researcher sits beside a user during onboarding, the user may read every instruction carefully, double-check details, and proceed slowly. But at home, they might rush, skip the fine print, or abandon the flow halfway. This gives a skewed observation of how complex or how easy your flow is.

How can you use this?

1. Create comfort, not pressure: start by reminding participants that there are no right or wrong answers. It’s the product being tested, not them.
2. Test in their natural setting: if possible, let people use the product in their own environment, on their own phone, at home, without you hovering. Remote testing often gives more honest results than lab testing.
3. Don’t lead the witness: even small cues like saying “this should be easy” or nodding when they click can nudge behaviour.
4. Observe the unspoken: notice body language: frowns, pauses, repeated back-and-forth clicks. These often reveal more than the words users say out loud.
5. Run multiple tests: a single session can be skewed by the Hawthorne effect. Patterns across many sessions are what reveal the truth.

Tools like Hotjar offer solutions like click recordings, heatmaps, etc, to remotely observe users’ behaviour whenever they’re using the product.

These are just a few of the many psychology principles that are used in product design. There’s a lot more depth to read more about psychology principles. Check out our other pieces:

• Psychological principles for every product designer
• More psychological principles for product designers
• How framing affects your decisions

Closing thoughts

All in all, these design principles are like lenses that help you see patterns in how people think, act, and make choices. What matters isn’t remembering the names of the laws, but noticing the trade-offs they reveal: simplicity vs. complexity, freedom vs. overwhelm, observation vs. natural behaviour.

The article originally appeared on Medium.

Featured image courtesy: Canvs.in.