Category: DevOps Journey

You know, something I think about a lot—especially now that I’m doing more development and security work—is the value of sharing information.

Back in the day, I used to post a lot online. Not funny videos, not memes—actual educational content. And honestly, I helped way more people than I ever realized at the time. People run into problems constantly, and when you share your knowledge publicly, you suddenly become part of thousands of invisible conversations where you’re helping someone fix something they couldn’t figure out on their own.

It’s wild how far that goes.

And the truth is, people remember you for that. You start to build a name for yourself. Ask yourself this:

Would you rather be known as the guy who causes problems, or the guy who solves them?
Well, okay—maybe it is kind of fun to cause problems sometimes. But still, you want to be known as someone who can solve interesting challenges, someone people can count on.

---

Most Problems Aren’t Really New

What I’ve learned over time is that almost every difficult problem—whether it’s programming, security, or math—comes from extensions of simple, foundational concepts.

Take math, for example.
Right now, you’re learning about systems of equations, balancing expressions, doing substitution. But the truth is, all these concepts are built on very basic operations:

• Addition
• Subtraction
• The idea of equality
• Commutative properties
• Transitive properties
• Substitution

Everything big is built on something small.

And it’s the same in engineering: most “complex” bugs are just simple rules applied in the wrong place or forgotten entirely.

---

Sharing Helps Everyone (Including You)

When you share knowledge—whether it’s a solution, a walkthrough, or even a mistake you learned from—you give people access to these foundational ideas. You help remove confusion for someone who might’ve spent hours trying to fix it.

You also help yourself.
Sharing makes you:

• Understand the topic more deeply
• Become part of a community
• Build credibility
• Create opportunities for yourself
• Gain confidence in your abilities

Honestly, you help 10× more people than you realize.

That’s why I think about creating tools, sharing solutions, and explaining how things work—not just because I enjoy it, but because it’s meaningful. Helping others understand problems makes you a better problem-solver yourself.

---

The Bigger Picture

Sharing isn’t just about putting something on the internet. It’s about:

• Reducing barriers
• Spreading foundational ideas
• Helping people grow
• Building a good reputation
• Making the world (and the internet) a little less confusing

If you can make something complicated feel simple for someone else, you’ve done something genuinely valuable.

That’s the kind of person I want to be—and the kind of example I want to set.

Hey, my name is Quentin Mayo, and in today’s blog I want to talk about deployments, Gen-AI, and how both shape the way I think about development. I’ll start with a story—because that’s how my brain usually connects everything.

---

Why I “Never Look Back” in Development

There’s a moment in The Incredibles where Edna Mode says she never looks back. That mindset stuck with me. I treat my devices and development setups the same way. Every so often, I’ll do a full hard reset on my phone or laptop. I back up what I know I’ll need… and if I didn’t grab it, it’s gone forever. No regrets.

I apply that same philosophy to my development environments. Throughout my home lab and even in professional work, there have been countless times where I built something—a pipeline, an application, or a deployment setup—then realized I could build it better with the constraints I have today. Reset. Rebuild. Improve.

That’s really what this vlog is about.

---

My Deployment Evolution

When I first started building websites, apps, and just tinkering with entrepreneurial ideas, I followed the same path a lot of organizations take:

1. EC2 for basic servers
2. Then Dockerized containers
3. Then ECS as services needed to talk to one another
4. And exploring equivalents in other clouds

ECS was… complicated. Still fun, but definitely not simple.

Recently, I discovered tools like Coolify and Dockify—platforms that let you deploy multiple services on a single instance, with a clean UI. This changed everything.

Migrating WordPress

I moved all my WordPress sites:

• From EC2
• To Lightsail
• And finally to Coolify

Lightsail was convenient… until it wasn’t. It wasn’t as cheap as advertised, had limitations, and I hit some scaling pain.

So I figured: why not run Coolify on-prem? I even got AT&T to give me a static IP (which they were not excited about), and it worked… until it didn’t.

Because I have a baby.
And that baby loves unplugging my servers.

One unplug → and boom → all my sites go down.

So now I’m moving toward a hybrid approach.

---

Designing a Hybrid Deployment Architecture

Here’s the concept:

• Route 53 manages my DNS.
• The primary A record points to my home network running Coolify.
• If the home IP becomes unreachable, Route 53 fails over to:
  → an EC2 instance also running Coolify in the cloud.

This setup gives:

• the low cost and flexibility of on-prem
• the reliability of AWS
• automatic DNS-level failover

Database Strategy

If I’m splitting workloads between home and cloud:

• For small projects that don’t really matter → I’ll keep them on-prem.
• For anything that needs reliability → the database cannot be on-prem.

That leaves two good options:

1. A database running on an EC2 instance (cheap, small projects)
2. RDS for anything larger, or anything requiring scaling or stability

A Common Mistake (AI Included)

One thing I’ve noticed—and AI models repeat this mistake constantly—is the advice to always put your database in a private subnet. Sounds good… until you realize your application might need direct access from outside, depending on your architecture.

Databases in a private subnet with no plan for safe exposure leads to:

• misconfigurations
• exposed IPs
• unnecessary risks

You need a solid access pattern—not just “put it in private and pray.”

---

Gen-AI and Development Speed

Now for the Gen-AI side.

There are things I’m doing right now that would take some organizations weeks or months, maybe even a year or more. I built them in a weekend with Gen-AI assisting me:

Examples:

• Setting up GitHub Actions with PATs and a GitHub App
• Creating an autoscaling group of self-hosted GitHub runners
• Reducing GitHub Actions billing by using my own metal before cloud minutes

It’s wild how much faster development is when you combine:

• solid engineering fundamentals
• strong problem-solving skills
• and modern AI tooling

Gen-AI doesn’t replace thinking—it accelerates people who already know how to think.

Those who rely on AI without understanding fundamentals will struggle. But those who use AI to extend their reach will outperform by a mile.

---

Wrapping Up

I’m almost at my destination, so I’ll close here. Today’s thoughts were really about:

• Why I rebuild systems instead of clinging to them
• Why hybrid deployments make sense for my home lab
• The realities of cloud cost vs on-prem cost
• How Gen-AI lets engineers ship insanely fast—if they know what they’re doing

More to come soon.