What Observing Systems Keeps Teaching Me
I don’t think of these principles as rules.
They are ideas that keep coming back.
I’ve learned them while working on different systems, in very different contexts.
Some of them may change.
Others have stayed with me for years.
Almost all of them began as an observation long before they became a solution.
1. Every Piece of Information Needs a Home
Before I ask how to automate a process, I try to understand where the information actually begins.
Many systems aren’t inefficient because they use the wrong tools.
They become inefficient when the same information is rewritten, copied, and updated in different places.
Emails.
Spreadsheets.
Documents.
Sticky notes.
Messages.
The problem is rarely technology.
It’s fragmentation.
The first step isn’t writing code.
It’s giving information a place to live.
Only then does it become natural to turn it into web pages, catalogues, QR codes, PDFs, reports, or anything else.
Every piece of information should have one home.
2. Technology Should Adapt to People
Whenever a new system forces everyone to change the way they work, I wonder whether it’s really a good system.
I prefer starting from habits that already work.
If the people managing a catalogue have been using the same spreadsheet for years, perhaps that’s where everything else should begin.
People shouldn’t have to learn a new tool simply because it exists.
Technology should adapt to people.
Not the other way around.
The best software is the one people almost forget they’re using.
3. Good Systems Leave Doors Open
One of the phrases I hear most often is:
“That will never happen.”
Or:
“We’ll only ever have three users.”
Assumptions are useful when you’re getting started.
They become dangerous when they turn into rules.
I prefer designing systems that remain flexible as the context changes.
Not because I want to predict every possible scenario.
Because I know the scenarios will change.
It’s the same reason why the most resilient ecosystems aren’t those perfectly optimized for a single condition.
They’re the ones that can adapt.
Assumptions grow old.
Good principles take much longer.
4. Simplicity Is a Form of Sustainability
To me, simplicity isn’t minimalism.
It’s the removal of waste.
Every unnecessary step consumes time.
Every duplicated piece of information requires maintenance.
Every exception added without a real need increases future complexity.
Natural ecosystems use energy with remarkable efficiency.
I like to think good information systems should do the same.
Efficiency doesn’t mean doing more.
It means achieving the same result with less friction.
5. Reuse Is Often More Creative Than Replacement
Whenever I can avoid replacing something that already works, I do.
That applies to materials.
To ideas.
And to software.
Building a new tool is often the most obvious solution.
Making existing tools work well together requires more observation, more creativity, and almost always leads to better systems.
Reuse isn’t a compromise.
It’s a design choice.
6. I Love Orchestras
I love music.
Maybe that’s why I keep seeing orchestras everywhere.
Every instrument has its own strengths.
None of them is enough on its own.
Google Sheets.
CSV.
WordPress.
Python.
Mapbox.
APIs.
To me, they aren’t technologies.
They’re musical instruments.
The interesting part isn’t choosing the best one.
It’s finding a way to make them play together.
Bridges are often more important than the tools they connect.
7. Curiosity Is a Better Starting Point Than Requirements
Many of the projects I remember most fondly didn’t begin with a request.
They began with a question.
“Isn’t there a better way?”
That question follows me even when I’m away from the computer.
While walking.
While swimming.
Listening to music.
Reading.
To me, designing has a lot in common with building with LEGO or solving a good puzzle.
The best answers almost always begin with a good question.
8. A Good System Should Outlive Its Designer
A good system shouldn’t work only as long as the person who built it is around.
It should remain understandable, adaptable, and capable of evolving even when the people around it change.
That’s why I prefer modular structures.
Simple data sources.
General rules.
Few dependencies.
More autonomy.
The goal isn’t to become indispensable.
It’s to make the system independent.
If a system depends on one person, it isn’t finished yet.