I started learning Argentine tango in the autumn of 2025.
At first, I approached it the same way most beginners do. I found a school, signed up for a weekly class, and occasionally attended practicas — informal sessions where dancers can practice outside of structured lessons.
That alone would have been enough.
But curiosity has a strange way of changing plans.
Every time there was a workshop, I attended. Through those workshops I met dancers and teachers from other schools. I discovered that the tango community, despite spanning multiple cities, is surprisingly interconnected. People know each other. If they haven't met personally, they have at least heard the names.
As my understanding of the ecosystem grew, I started exploring.
My primary school remained in Košice, but I occasionally attended classes in Prešov. Different teachers. Different students. Slightly different perspectives on the same dance.
Then I discovered another school.
And then another.
One teacher even taught in multiple cities, traveling regularly between Košice and Vranov nad Topľou. I found that level of dedication fascinating.
Before I realized what was happening, I wasn't learning from a single source anymore.
I was learning from an ecosystem.
The Accidental Architecture
The interesting part is that none of this was planned.
I never sat down with a notebook and designed a learning strategy.
I simply followed opportunities that looked interesting.
Yet when I stepped back, I noticed something familiar.
Without consciously intending to, I had built redundancy into my learning process.
My primary school remained my primary school.
But if there was a summer break, I could continue elsewhere.
If my schedule prevented me from attending one class, I had alternatives.
If I wanted a different explanation of a concept, I had access to multiple teachers.
If I traveled, I already knew who to contact and where to go.
From a software architecture perspective, I had eliminated most single points of failure.
And I hadn't done it because I was trying to be clever.
I had done it because the same principles I use professionally had quietly leaked into real life.
Engineers Don't Just Build Systems
Most people think architecture is something engineers do at work.
A diagram.
A server.
A database.
A deployment pipeline.
But after enough years, architecture becomes more than a professional skill.
It becomes a way of seeing the world.
You start noticing bottlenecks.
You notice dependencies.
You notice risks.
You notice what happens when everything relies on a single person, a single tool, a single supplier, or a single decision.
And then, often without realizing it, you begin designing around those weaknesses.
Not only in software.
In life.
You build backups.
You create alternatives.
You diversify your inputs.
You avoid becoming dependent on a single source whenever possible.
The principles stay the same even when the domain changes.
The Hidden Benefit of Communities
Another thing surprised me.
The tango schools did not behave like fierce competitors.
From the outside, one could assume that multiple schools in the same region would be fighting for students.
Instead, I observed something closer to cooperation.
The community is relatively small.
Teachers know each other.
Students move between events.
Workshops bring people together.
The ecosystem benefits when more people dance.
Especially when more leaders dance.
The schools remain independent, but they are also part of something larger.
And because of that, my exploration wasn't harming anyone.
If anything, it was strengthening my connection to the broader community.
The Pattern Appears Everywhere
When I first started tango, I thought I was learning how to dance.
And I was.
But looking back, I learned something else too.
I learned that the mental models we use professionally often follow us into unexpected places.
An architect designs resilient systems.
Eventually, that architect starts building resilient learning paths, resilient communities, and resilient relationships too.
The tools change.
The principles remain.
And sometimes you discover that you've built a robust architecture long before you realize you were designing one.
