Marketing as an Engineer: My Mental Shift as a Founder

I've been coding since I was eight years old.

For most of my life, code has felt like home. The market? More like a stage where I'm expected to perform and strangers get to decide if I'm any good.

No wonder I've spent years avoiding marketing.

But something clicked recently. A way of thinking about it that sounds almost too simple. And yet it's actually changed how I approach the stuff I used to dread.

The reframe: The market is just a compiler.

The trap I kept falling into

Here's what I mean.

When I write code and the compiler throws an error, I don't take it personally. I don't sit there thinking, "The compiler hates me" or "Maybe I'm just not cut out for this."

I think: "Ah, syntax error on line 40. Let me fix that."

It's just feedback. Information. Something to act on.

But when I put something out into the world - a feature, a landing page, a Product Hunt launch - and it flops? That hits different.

Suddenly it's not "The messaging didn't land." It's "They don't like me." It's personal.

I've been stuck in that loop for years.

Why we hide in code

If you're a technical founder, you probably know what I'm talking about.

Code gives you clear feedback. It works or it doesn't. You can measure progress. There's something satisfying about solving a technical problem that you just don't get from writing copy for a landing page.

Marketing is messy. You write something, put it out there, and... who knows? Maybe it works. Maybe it doesn't. The feedback takes forever and even then you're not sure what it means.

So we do what feels safe. We hide in the codebase.

I built Glitter for eight months before showing it to anyone. I told myself the product needed more work. That I was being thorough. That I cared about quality.

Really? I was scared.

Every feature I added was another excuse to put off the moment when actual humans would look at my work and decide if it was worth anything.

The shift

Here's what finally helped: Stop treating marketing like a performance. Treat it like debugging.

When a compiler throws an error, you don't feel judged. You feel informed.

A customer saying "no" works the same way. It's a bug report. Something's not matching up - your product, your message, whatever - with what they actually need.

It's not: "You're not good enough."

It's: "Expected X, got Y."

That's data. Not a verdict.

I know this sounds obvious when I write it out. But actually believing it? That took a while.

What it looks like day to day

Here's a concrete example.

Old me would write a landing page, obsess over every word, put off publishing for weeks, and then feel crushed if nobody signed up.

Now I try to ask: "What am I actually testing here?"

Maybe the hypothesis is: "People who struggle with documentation want a faster way to create it."

The landing page is just an experiment. If it converts, cool - hypothesis looks right. If it doesn't, maybe the hypothesis was off. Or the copy. Or who I showed it to.

None of that is me being wrong.

I can poke at it the same way I'd poke at broken code. Change something, run it again, see what happens.

Failing fast (actually)

This way of thinking also makes it easier to ship before you're ready.

With code, we get this intuitively. You don't write 10,000 lines and then run the compiler for the first time. You write a little, test, write more, test again.

But with marketing, we do the opposite. Spend months on the "perfect" product. Make a big announcement. Then wait to see if people clap.

That's insane when you think about it.

What if you shipped the scrappiest possible landing page first? Just to see if anyone bites. Just to test if the idea even makes sense.

You're not shipping garbage to customers. You're running a quick compile to catch obvious errors before you write more code.

The counterintuitive thing about hiding

Here's something that took me way too long to figure out: hiding is actually expensive.

Every time I disappear into my code editor instead of talking to a customer, I'm taking on debt. I might spend weeks building something nobody wants. All because I was too scared to ask.

Hearing "no" isn't failure. It's information. It tells you that path isn't worth pursuing. Now you can try something else.

Hiding feels safe, but it costs you the one thing you actually need: data.

It doesn't make the fear go away

I should be honest. Thinking about it this way doesn't make the anxiety disappear.

I still get that tight feeling before I post something. The old thoughts still show up: "What if nobody cares? What if it's stupid?"

But now I can catch myself. Notice when I'm slipping back into treating the market like a judge. And remind myself what's actually going on.

"This isn't about me. It's an experiment. What am I going to learn?"

A few things I do differently now

1. I ship tests, not products.

Before I write code for a new feature, I try to figure out if anyone even wants it. A fake button. A waitlist. A conversation. Something that gives me signal before I invest weeks of work.

2. I separate the builder from the seller.

When I switch into marketing mode, I try to think of it like running a script. If the script doesn't work, the script was bad. Not me. It sounds cheesy, but having that mental separation actually helps.

3. I ask different questions.

Instead of "Do they like me?" I try to ask "Is this working?" Instead of "Was I good enough?" I ask "What should I try next?"

Same rigor I'd apply to code. Just a different compiler.

Where this connects

Looking back at what I learned from my first startup, so much of my stress came from tying my identity to how the company was doing.

Simpo doing badly = I'm a failure.

This is the same trap, just applied to marketing. If someone says no, it must mean something's wrong with me.

But that's as silly as taking it personally when your code doesn't compile.

The compiler is just doing its job. So is the market.

Your job is to look at the error, tweak the code, and try again.

---

I'm still working on this. The urge to hide in code probably won't ever go away completely. But I'm getting better at noticing it.

If you're a technical founder who dreads marketing, maybe this helps. Maybe it sounds too simple. I thought so too at first.

But changing the question from "Do they like me?" to "Is this working?" made more of a difference than I expected.

The market isn't handing down a verdict. It's just a compiler with slow feedback loops.

Might as well treat it that way.

Frequently Asked Questions

Why do engineers avoid marketing?

Code gives you clear, fast feedback - it works or it doesn't. Marketing is slower and mushier, and when it fails it feels personal. Like rejection. That makes it psychologically harder for people who are used to systems that behave predictably.

How can technical founders get better at marketing?

Try thinking of it as running experiments instead of performing for an audience. Your landing page is a hypothesis. If it doesn't convert, something's off with the hypothesis or the execution - not with you. Same debugging mindset, different domain.

What's the 'market as compiler' idea?

When code doesn't compile, you don't feel judged. You just fix the bug. The idea is to treat market feedback the same way: a customer saying 'no' is information about a mismatch, not a statement about your worth as a person.

How do you validate ideas before building them?

Anything that gets you signal before you invest serious time. Fake buttons to see if people click. Waitlists. Conversations with potential users. Even just describing what you're thinking about building and seeing how people react. Quick compiles before you write more code.

How do you not take rejection personally?

Create some distance between you and the work. When you're in marketing mode, think of yourself as running a script. If the script fails, that's useful information about the script. It's not a referendum on you. Easier said than done, but it helps.

Does this actually make marketing less scary?

It doesn't make the fear go away. But it gives you something to do with it. You can notice when you're treating the market like a judge, remind yourself it's just a feedback system, and ask 'What will I learn?' instead of 'What will they think?' That shift adds up over time.