How to Run a 1:1 With a Senior Engineer (When You're Not Technical)

The Pattern Nobody Warns You About

You're a founder. You know your product. You know your market. But when your senior engineer sits down across from you for a 1:1, you go quiet. Maybe they start talking about technical decisions you don't fully grasp. Maybe they mention someone's been frustrated. Maybe they just look tired. And you nod and say "sounds good" and move on.

A month later that senior engineer leaves. You're shocked. In retrospect, there were three signals you missed.

This happens to nearly every technical founder I work with who isn't deeply hands-on in code. And it happens to plenty of non-technical founders running engineering teams. The problem isn't that you're not smart enough—it's that you don't have a structure for the conversation. You're improvising.

I've run hundreds of 1:1s as a CTO, and I've sat beside founders while they fumbled through them. The difference between a 1:1 that builds trust and one that leaves your engineer feeling unseen is almost entirely about preparation and the questions you ask.

Here's my template. Use it. Adapt it. Make it yours. But do it consistently.

Why This Hour Matters More Than Your Next Board Call

A 1:1 with a senior engineer isn't a status update. It's not a code review. It's not a retrospective. It's the only recurring moment you have to understand the human behind the commits.

Senior engineers can leave quietly or noisily. They can start moving slower—still writing code, still in meetings, but checked out. They can become bottlenecks because they're gatekeeping knowledge instead of multiplying it. Or they can become your force multiplier, mentoring juniors, pushing the architecture forward, and protecting you from bad decisions.

The difference is often whether they feel like you see them.

When you're not technical enough to evaluate their work directly, your job in a 1:1 becomes even more critical. You're listening for:

Are they still challenged?
Do they feel heard?
Is someone blocking them?
Are they thinking about leaving?
Do they know what they're working toward?

These aren't things you can parse from a pull request.

The Template I Use (And Hand to Founders)

I keep 1:1s to 30 minutes, scheduled every two weeks. I always start with the same opener.

Opening (2 minutes): "How are you doing? And I mean really—not just work."

Then I shut up. Let them answer. This is not rhetorical. I'm listening for tone and truthfulness. If they say "fine, good," I might press once: "Real answer?" But if they're deflecting, I don't push. Sometimes they just need the door open for next time.

Wins since last 1:1 (5 minutes): "What shipped or moved forward that you're proud of?"

Don't ask for the list of everything they did. Ask what they feel good about. This tells you what matters to them and gives you a moment to celebrate. Senior engineers often feel invisible—especially when things are stable. Acknowledge the work. Be specific: "I heard you unblocked the payments team. That mattered."

What's blocking or frustrating (5 minutes): "What's harder than it should be? What's keeping you from shipping faster?"

This is where the signals emerge. Maybe it's a technical debt point. Maybe it's a person. Maybe it's process. Maybe it's ambiguity about priorities. Don't solve it in the moment. Just listen. Write it down. Acknowledge it: "That's real. I hear you."

How are things with the team? (5 minutes): "How's it going with [other senior engineer or team]? Anyone you're worried about? Anyone you want to see us hire?"

You can't ask this about themselves—you'll get the corporate answer. But senior engineers see things you don't. They talk to juniors about whether they're happy. They know who's frustrated. They know if there's a hidden conflict. This is where you get intelligence.

Career/growth (5 minutes): "Where do you want to go in the next year? How can we get you there?"

Don't assume they want your job. Some of your best engineers don't want to manage. Some want to go deeper on systems. Some want to explore adjacent fields. Some actually just want to write code. But they need to know you asked. They need a path that doesn't end in "stay or leave."

Close (2 minutes): "Anything you want from me? Anything I should know?"

This is their moment. Shut up again.

A Real Example

I once worked with a founder whose senior engineer had been unusually quiet in meetings. The founder was nervous but didn't want to pry. In the next 1:1, when asked "What's harder than it should be?", the engineer said: "I feel like my opinion doesn't matter anymore. We code everything the way the new hire suggested, even when it's worse."

The founder had no idea. There was a real architectural conflict. The new hire was confident, the senior engineer was cautious, and the founder had unconsciously given the new hire credibility because they were newer and louder.

Without that 1:1 structure, that would have festered for six more months. The senior engineer would have started shipping slower. They'd have been "not a team player." Then they'd have left, and the founder would have been surprised.

Instead, the founder sat down with both engineers, heard the actual disagreement, and helped them work through it. The new hire learned. The senior engineer felt heard. The founder understood the architecture better.

That conversation only happened because the structure created space for honesty.

The Counterpoint: When 1:1s Become Theater

Some founders treat 1:1s as a checkbox. They show up unprepared, half-listen, and promise to fix things they never follow up on. That's worse than no 1:1s.

Senior engineers are watching whether you actually heard them. If you say "Yeah, the CI/CD pipeline is slow, we should fix that" and then three months pass and nothing changes, you've burned trust. They stop talking.

The fix: Keep a running list of what you heard in 1:1s. Even if you can't solve something immediately, you need a response. "I talked to the tech lead about the pipeline. Here's the timeline." Not "I forgot." Accountability matters.

Also, don't treat 1:1s as an interrogation about status. If you want to know what they're building, read the tickets. The 1:1 is for the human stuff.

Where I Come In

If you're a founder without engineering depth, this is exactly the kind of thing I help with. I'll sit in your 1:1s, help you ask better questions, coach you on what the signals mean, and work with you to structure how you actually respond to what you hear. Over a few cycles, you'll own it. Your team will feel the difference.

Let's talk.

Your Action Checklist

Schedule 1:1s every two weeks with each senior engineer. Block the time like it's a customer call.
Before each 1:1, review your notes from the last one. Did you follow up on anything you said you would?
Use the template above. Don't improvise until you're comfortable.
Keep a simple note for each person: Wins, blockers, team observations, growth interests. That's it.
After the 1:1, send them a short message recapping what you heard and what you're going to do about it. This shows you were listening.
Every three 1:1 cycles, ask yourself: Is this person still energized? Are they more trusting of me?

The Real CTA

Schedule 30 minutes this week with your senior engineer. Use this template. Listen more than you talk. That's the move.