What 2020 Taught Me About Resilient Software

December 2020. The year that nobody expected is ending. I've been reflecting on what building software in 2020 actually taught me about what matters and what's distraction.

The year started normally enough. Cloud ERP was the future. AI was overhyped. Mobile was becoming more important. All the normal trajectories. Then March happened and everything inverted.

Infrastructure Became Visible

In normal times, infrastructure is invisible. It works or it doesn't and you don't think about it. In 2020, infrastructure became the difference between thriving and collapse.

The companies running on proper cloud infrastructure adapted to remote work in days. The companies running on on-premise systems struggled for months. It wasn't that cloud is inherently better. It's that cloud was built assuming distributed access, and that assumption suddenly became reality.

This taught me something important: the technical infrastructure decisions you make in stable times become critical advantages or critical liabilities when conditions change. You can't predict what the change will be. But you can predict that change will come.

The infrastructure that survives disruption is the infrastructure built with flexibility as a first principle. Cloud native. Distributed. Designed for failure. Not because you're paranoid. Because when crisis comes, you want the system to adapt, not require crisis management to keep it running.

Operational Visibility Is Wealth

The companies that thrived in 2020 weren't the biggest or the most sophisticated. They were the ones that could see their business clearly.

They knew their cash position in real time. They understood their supply chain. They could model scenarios. They could make decisions based on data instead of guessing.

The ones that failed had operational data scattered across systems, locked in databases only certain people could access, or buried in spreadsheets that nobody trusted.

This seems obvious in retrospect. Everyone says you need good data and visibility. But implementing it and maintaining it is expensive and requires discipline. Most companies don't do it. In 2020, that became a liability.

What I learned: operational visibility isn't a luxury. It's not something you build after the business is running. It's something you build into every system from day one. Every transaction should be traceable. Every decision should be explainable. Every number should be verifiable.

The companies that could do this survived. The ones that couldn't struggled.

People Matter More Than Process

I watched a lot of software engineering in 2020. Remote teams, distributed teams, teams dealing with the stress of the world falling apart.

The biggest differentiator between teams that stayed productive and teams that burned out wasn't the process they used or the tools they had. It was whether they had psychological safety and clear communication.

Teams that trusted each other, communicated clearly, and had the space to not be productive kept shipping. Teams that had rigid processes, poor communication, or lack of trust fell apart faster than you'd expect.

This isn't a technology problem but it became a technology leadership problem. The teams I led that sustained were the ones where people felt supported. Where we adjusted expectations. Where we communicated uncertainty instead of hiding it.

The technology didn't change. The people did. The teams that adapted kept people as the center of the picture. The teams that didn't treated people as resources that should keep working the same way.

Hype Detaches from Reality Quickly

In January, everyone was excited about what 2020 would bring. New technologies. New opportunities. And then we all watched what actually mattered.

GPT-3 was genuinely impressive. No-code tools were genuinely useful. Flutter web was genuinely improving. But they mattered infinitely less than whether your business could survive a global shutdown.

The hype cycle didn't stop. There were still people claiming AI would solve all problems and no-code would replace developers and Flutter would replace native development. But the people who mattered—actual CTOs and technical leaders running actual businesses—got much more grounded about what technology actually solves versus what it claims to solve.

The lesson: when everything changes, hype becomes irrelevant very quickly. The technologies that matter are the ones that solve actual problems for actual people. The rest becomes noise.

By December, I cared much less about following technology trends and much more about understanding what problems my customers actually had.

Local First Became Interesting

Watching companies struggle to access remote systems during outages or when connectivity failed, local-first software became suddenly interesting.

I don't mean offline. I mean software that works locally first and syncs when connected. An app that works on your phone regardless of internet. A system where you can work offline and sync when you're back online.

Most software built in the last decade assumes constant connectivity. In 2020, that assumption broke repeatedly. The software that adapted was the software that could function locally and sync back to the cloud when connectivity returned.

This isn't new. It's actually old wisdom that got forgotten in the cloud era. But 2020 reminded people that resilient software works both connected and disconnected.

The Future Isn't What I Expected

In January 2020, I expected the next 12 months to be about scaling. Building bigger systems. More users. More features. More everything.

Instead, I learned that scaling isn't the opposite of resilience. It's often at odds with it. The systems that handled the rapid change of 2020 weren't the most complex. They were the simplest systems that could adapt quickly.

Complexity doesn't confer resilience. Simplicity does. The ability to change. The ability to understand the system. The ability to identify problems quickly.

By December, I was much more bullish on small, focused systems that do one thing well than on massive platforms that try to do everything.

What I'll Remember About 2020

This year will stick with me not because of the technology we built but because of what I learned about what matters in software.

What matters is whether your system works when things are weird. Whether your team can think clearly under pressure. Whether your data is trustworthy. Whether you can adapt when plans change. Whether you built with people as the center.

All of that is unglamorous. There's no trend cycle around it. It doesn't generate Twitter threads. But it's the difference between organizations that thrived and ones that didn't.

The Practical Changes I'm Making

Going forward, I'm applying what I learned:

Build for resilience first. Scalability matters less than adaptability. Assume things will change unexpectedly.

Make data visible. Invest in operational transparency early. It compounds.

Prioritize team stability. Burnout and psychological safety matter more than shipping velocity.

Keep things simple. Complexity that seems smart in stable times becomes a liability in unstable times.

Assume connectivity breaks. Build systems that work offline.

Question the hype. The technologies that survive scrutiny are the ones that solve actual problems.

Remember that software serves humans. The best code in the world doesn't matter if the people using it aren't supported.

What Comes Next

I don't know what 2021 will bring. 2020 taught me to expect that the thing I expect won't happen.

But I'm confident about this: the companies that built resilient infrastructure, that prioritized operational visibility, that took care of their people, and that stayed focused on actual problems are going to outpace everyone else.

Not because they got lucky. Because they built systems that could actually adapt when luck stopped being a factor.

The pandemic revealed a lot of weaknesses in software systems that were optimized for normal times. The companies that fix those weaknesses won't be the ones racing to implement the newest technology.

They'll be the ones that built right from the start.

2020 was extraordinary. But the lesson is simple: resilient software is built before you need it. The infrastructure, the visibility, the team health, the simplicity. All of it compounds over time.

Do that, and the next 2020 doesn't destroy your business. It just makes you stronger.