My mother became a licensed cook at the age of 70.
She studied, prepared for the exam, took it — and passed.
At the same time, she sometimes asks me questions about smartphones and the internet.
“How do I do this?”
“Is it okay to click this?”
That contrast made me question something we often assume when designing software:
Are older users really “bad at technology”?
I don't think that's a very useful way to think about it anymore.
Capability is not the same as familiarity
Getting a professional qualification at 70 isn't easy.
You have to learn new things, remember rules, understand procedures, and pass an exam.
Clearly, the ability to learn is still there.
But technology presents a different problem.
When cooking, experience helps you predict what will happen.
If you heat something too long, it burns.
If you add too much salt, you know what the result will be.
The relationship between an action and its consequence is relatively visible.
On the internet, it often isn't.
What happens if I click this link?
Who actually operates this website?
Is it okay to enter my phone number here?
What exactly am I agreeing to when I click “Allow”?
The action itself may be easy.
Understanding the consequence is the difficult part.
“Make it simpler” isn't always the answer
When we talk about designing software for older users, the discussion often goes in a predictable direction:
- Bigger text
- Larger buttons
- Fewer options
- Simpler navigation
These are important accessibility considerations.
But I think there's another problem that receives less attention.
A UI can be extremely easy to operate while still being difficult to judge.
A giant “Continue” button is easy to press.
The harder question is:
Should I press it?
That's a completely different design problem.
Maybe software should support judgment
This changed how I think about some of the small browser tools I've been building.
Originally, my instinct was straightforward:
Detect something dangerous and stop the user.
But that creates another problem.
The software starts deciding what is correct.
And real-world situations are rarely that clean.
So I've gradually moved toward a different model:
Don't make the decision for the user.
Give them a better moment to make the decision themselves.
For example:
Before sending personal information.
Before opening an unfamiliar link.
Before trusting a website.
Before submitting something that may contain sensitive information.
The software doesn't necessarily need to say:
“You cannot do this.”
Sometimes it only needs to say:
“You may want to check this once.”
That small difference matters.
Friction isn't always bad UX
Developers spend a lot of time removing friction.
Fewer clicks.
Faster checkout.
Automatic completion.
One-tap actions.
And most of the time, that's good engineering.
But I don't think friction is universally bad.
There are moments where a tiny amount of friction creates useful thinking time.
A confirmation before sending sensitive information isn't necessarily an obstacle.
It can be a decision boundary.
That has become one of the ideas behind my small project, Legacy Tools.
I'm experimenting with browser extensions that add small checks at these boundaries — without uploading the user's data somewhere else and without trying to replace their judgment.
The goal isn't to make the internet “simple enough for older people.”
It's something different.
Don't remove capability. Add context.
My mother doesn't need technology to treat her as incapable.
Someone who studies for and passes a professional exam at 70 clearly isn't incapable.
What she sometimes lacks online is the same thing many of us lack:
enough context to understand what an action will cause.
And that isn't really an “older people” problem.
Developers click suspicious links.
Employees accidentally paste confidential data.
Experienced users approve permissions they haven't really inspected.
We've all learned to operate software faster than we've learned to evaluate every consequence.
So perhaps the broader design principle is this:
Don't simplify users. Simplify the decision they need to make.
That is a very different way to think about accessibility, safety, and UX.
And watching my 70-year-old mother study for a new qualification was what finally made that obvious to me.
Top comments (1)
Hello Glad to see you, I am Kane Lim from Hong Kong. I have over 10 years of development experience. I am writing this because your post was interesting.
The distinction between operational simplicity and cognitive simplicity is excellent. Many accessibility systems optimize Fitts's Law, typography, and interaction cost while completely ignoring consequence visibility.
I would push this toward a context aware decision layer. Instead of generic confirmation dialogs, infer risk from the action graph: destination reputation, permission scope, data sensitivity, authentication state, irreversible mutations, and anomalous navigation patterns. Then surface concise contextual evidence exactly at the decision boundary.
For privacy, the architecture could remain entirely client side using local heuristics, lightweight classifiers, and deterministic policy evaluation. A confidence based intervention model could minimize alert fatigue while preserving user agency.
The principle I like most is simplifying the decision rather than simplifying the person. That applies far beyond older users and could become a powerful design philosophy for trustworthy interfaces. I would enjoy discussing the architecture behind Legacy Tools and exchanging ideas.