Amaro Than Thinks Different.

The night Cloudflare went quiet did not start with drama. It started with something small and familiar: an upload bar that refused to move.

Someone in Kosovo tapped “post” on a video. On our dashboards, we saw the request come in, the file start to stream… and then the line went flat. A tiny freeze. A tiny pause. The kind of thing you blame on Wi-Fi and forget.

Except it wasn’t just one upload.

Another user tried. And another. Timelines stopped refreshing. Notifications didn’t arrive. The charts that usually danced with life began to draw straight, uncomfortable lines. Amaro Than felt like a room where everyone started talking at once and then, suddenly, fell silent.

At first, I assumed it was our fault.

When something breaks, I never blame the internet. I blame our code. That’s how Amaro Than has been built from the beginning: if something feels wrong, we look in the mirror first.

So I did what I always do.

I opened logs. Traced requests. Looked at error rates. The origin servers were healthy. CPU was calm. Disk IO was fine. The database — the same MySQL that had survived every migration and late-night schema tweak — was not even sweating.

But the traffic patterns were wrong.

Requests were reaching Cloudflare, but fewer of them were coming back home. It was like shouting into a tunnel and hearing less and less of your own echo.

Then the messages started.

“Is Amaro Than down?”

“I can’t upload anything.”

“Did you push an update?”

This is the moment every builder knows: the second when it stops being “a bug” and becomes “my responsibility”. It doesn’t matter whose logo is in the middle of the incident. The people who trust you don’t wake up thinking about infrastructure providers. They think about you.

So we widened the view.

Driton pulled up external monitors. Elvis checked other services that shared the same infrastructure. I refreshed status pages that usually read like a sleepy heartbeat. Tonight, they were starting to flicker.

And then it was clear: it wasn’t just us.

Cloudflare — the quiet layer that sits between our servers and the world — was stumbling. Routes were failing. Edges were timing out. For many apps, it was a bad night. For us, it was something else too: a loud wake-up call.

Because if one company going quiet could make Amaro Than feel quiet, then we still had work to do.

Before that night, Cloudflare was a kind of comfort.

It made our origin faster, safer, more resilient. It smoothed out traffic spikes, hid our servers behind smart edges, and gave us bandwidth we could never afford on our own. It helped us keep costs in check so we could give more of the platform away to people who needed it most.

But the same thing that made it powerful also made it dangerous: we trusted it too much.

It’s easy, when you have a strong partner, to forget that your job is not to build a beautiful dependency. Your job is to build a path that stays open, even when one bridge collapses.

That night, looking at stalled uploads and frozen feeds, I heard Steve Jobs’ line in the back of my mind: design is not just what it looks like and feels like. Design is how it works.

And then the more honest version of that sentence: design is how it works when things break.

On paper, we had good architecture. On paper, we had redundancy. But reality is not lived on diagrams. It is lived in the moment when a teenager tries to upload a story about their day and sees a spinning wheel that never stops.

So we made a decision.

Amaro Than would never again depend on a single path to reach the people it serves. Not for logins. Not for media. Not for the heartbeat of the app.

That promise did not fit on a landing page. It lived in shell commands, config files, and the tired eyes of three people staring at terminals deep into the night.

We didn’t fix the internet. We fixed our part of it.

First, we mapped the blast radius.

What exactly died when Cloudflare stumbled? DNS resolution? HTTP proxies? Tunnels? Which parts of our stack were truly offline, and which just felt offline because the most convenient door was blocked?

We discovered something important: a surprising amount of our pain came from convenience.

We had leaned on a single DNS layer because it was fast and simple. We had funneled most traffic through one tunnel system because it was elegant. We had allowed a single provider to become the main road while our side streets and back-up routes were still under construction.

So we rolled up our sleeves and started building those side streets.

We stood up alternate DNS paths — more than one, in different places, with different failure modes. We designed a way for critical traffic to reach the origin directly when the edge layer misbehaved, without exposing things that should never be public.

We changed how the app thought about “home”.

Instead of assuming everything would always go through Cloudflare, the client began to understand that there might be multiple ways to reach the same heartbeat: a primary route, a quiet backup, and a last-resort path meant only for emergencies.

It wasn’t about abandoning Cloudflare. It was about refusing to let one logo define whether Roma youth could talk to each other on a random Tuesday night.

While we sketched routes and tested fallbacks, something else was happening in the background: a quiet conversation about responsibility.

Because Amaro Than is not a generic social app. It’s a promise to a community that is used to doors closing without explanation.

If you grew up Roma, you know that feeling: systems built without you in mind, places where your voice arrives last or not at all. If we were going to build a digital home for Roma people, we couldn’t copy the old patterns. We couldn’t say “sorry, our provider is down, see you tomorrow”.

We had to be better.

That’s why, even as we battled timeouts and retried uploads, the discussion never left the human side.

What happens to trust when an app just stops responding?

How many outages until “this is still new” becomes “I can’t rely on this”?

How do we design in a way that respects people’s time, their data, their stories — especially when something goes wrong?

The answers didn’t come in one night. But that night gave us a direction: resilience is not a feature. It’s a value. It has to be baked in as deeply as encryption or safety.

So we wrote it into our culture:

If there is a single point of failure, we treat it as a bug.

If a provider can bring us down, we assume it eventually will.

If an outage happens, we don’t just restore service. We also ask: how can this same exact failure hurt less next time?

The next days were full of the kind of work no one sees.

We tested DNS failovers not in theory, but in practice — by deliberately shifting traffic, watching how the app behaved, making sure people could still log in, scroll, and post without even noticing the change.

We rehearsed scenarios.

What happens if Cloudflare is fine, but a region has trouble? What if DNS resolves, but the tunnel layer fails? What if only uploads are affected? How does the app degrade in a way that feels honest, not broken?

We added health checks that didn’t just ask, “Is the server alive?” but, “Is this path still the best way to reach us right now?”

We monitored not just errors, but experience: time-to-first-post, time-to-play, how quickly the feed recovered after a blip. Because while dashboards speak in graphs, people speak in feelings: “it just works” or “I don’t trust it”.

Piece by piece, the system became less fragile.

Uploads gained smarter retries and clearer feedback. If a path started failing, the app could change routes instead of leaving the user staring at a stuck progress bar. The backend could temporarily stop accepting heavy operations if a provider looked unstable, keeping the core experience alive instead of letting everything crash together.

What changed was invisible, but real: the distance between “something went wrong out there” and “Amaro Than is down” became longer.

At some point, Cloudflare recovered. Status pages turned green again. The wider internet sighed in relief and moved on.

We didn’t.

Because for us, that night wasn’t about one outage. It was about the story we want to tell, years from now, when people ask, “Why does this app feel so steady? Why does it feel like it’s on our side, even when the network isn’t?”

The honest answer we want to give is: because we earned it. Because we treated every failure as a teacher and every dependency as a relationship, not a guarantee.

When I think back to that night now, I don’t remember the error codes. I remember the feeling of staring at a quiet dashboard and realizing how fragile trust can be.

I remember Driton saying, “If we’re serious about being ‘our place’, we can’t disappear just because someone else does.”

I remember Elvis walking through cost charts and saying, “We’ll find a way to make redundancy affordable. If we have to sacrifice some comfort on our side to keep them online, we do it.”

And I remember that small, stubborn thought in my own mind: design is not just how it works when everything is perfect. Design is how it behaves when the world breaks in all the boring, predictable ways.

Today, when Cloudflare is healthy and everything hums along, most people will never know what changed that night. They won’t see the extra DNS provider, the backup routes, the smarter health checks. They won’t feel the relief of a fallback kicking in before a spinner appears.

And that’s exactly the point.

Good resilience feels like nothing. No drama, no fireworks, just a calm, steady “still here” when the rest of the internet starts shaking.

But inside the code, that night is recorded everywhere.

In the way we open connections.

In the way we store media.

In the way we test for failure first, not last.

In the way we design new features around the idea that some part of the world will always be a little bit broken.

“The Night When Cloudflare Went Quiet” won’t be a feature tile in the app. No one will scroll past it on a home screen. But it lives underneath every post that gets through in a storm, every video that finishes uploading when another service might have given up.

It’s the quiet story behind the louder stories people will share on Amaro Than — stories about identity, love, friendship, and pride.

Because in the end, that’s what this was really about.

Not about infrastructure.

Not about status pages.

About making sure that when someone decides to share something real, the app doesn’t disappear at the exact moment their courage shows up.

The night Cloudflare went quiet, Amaro Than learned to speak a little more softly, and stand a lot more firmly.

And that’s how a bad night turned into a promise: no matter who goes down around us, we will do everything we can to stay up for you.