Working alone, it's easy to overestimate execution and underestimate direction and pace

When working alone, it's easy to believe one thing:

As long as I work a bit harder, many problems can be solved.

This idea is natural.

Because working alone means you have to shoulder a lot yourself. Building a product? You think it through. Writing code? You write it. Landing projects? You negotiate. Creating content? You publish it. When problems arise, you mostly have to handle them alone.

So when things don't go well, it's easy to first react at the execution level:

Maybe I'm not doing enough. Maybe I'm not moving fast enough. Maybe if I try a bit harder, the problem will pass.

I used to think this way too.

But over time, I've realized that many problems aren't execution problems at all. More precisely, I tend to overestimate execution and underestimate direction and pace.

I now feel this more and more.

Because when working alone, the biggest risk isn't doing too little, but rather:

• Direction isn't contained
• Pace isn't arranged well
• You're doing things, but the truly important things aren't being pushed forward with focus

In such cases, the stronger your execution, the more dangerous it can be.

Because you're not failing to move forward; you're diligently pushing an incorrect pace deeper.

Execution is easy to understand, so people grab it first

Why is execution easily overestimated? I think a key reason is that it's the most visible.

How much code you wrote today, how many pages you made, how many features you changed, how many articles you published, how many tasks you advanced—these are all countable.

Execution gives a strong sense of certainty:

• I did things today
• I wasn't idle today
• I'm making progress today
• I worked harder today than yesterday

This feeling brings comfort.

Especially when working alone, external feedback isn't timely, and results don't always come back immediately, so "at least I did a lot today" becomes an important psychological support.

But here's the problem.

Because strong execution solves the "doing" problem. Many truly troublesome areas aren't about "doing or not doing," but rather:

What to do. When to do it. Which to do first. Which shouldn't be done now.

These questions aren't as obvious as execution, but they often determine the outcome more.

The trap of working alone isn't laziness, but being genuinely busy

I increasingly feel that the most dangerous state when working alone isn't laziness, but being genuinely busy.

Because laziness is visible. But when you're genuinely busy, it's sometimes hard to see what's wrong.

You're advancing every day:

• Filling in product gaps
• Working on projects
• Publishing content
• Trying tools
• Tweaking workflows
• Ideas keep changing

Each thing, on its own, makes sense. And you're indeed doing each. But after a while, looking back, you find:

Key results aren't being steadily pulled out.

This state is draining.

Because you can't simply say "I didn't work hard." On the contrary, the problem is that you worked hard.

But the effort is diluted, spread across too many things that are at different stages and have different priorities.

At this point, execution isn't useless; it's just not landing where it should.

If direction is wrong, the stronger the execution, the faster you deviate

This is a statement I increasingly believe.

Many things aren't that you shouldn't do them, but that they aren't the most important thing to do right now.

For example:

• Before validating the product, you start adding many completeness features
• While under delivery pressure, your attention is drawn away by new ideas
• Before the content main line is stable, you start expanding topics everywhere
• Before confirming users actually want it, you do a lot of optimization
• Before the project scope is contained, you think about making the system prettier

None of these are wrong in isolation. The problem is their timing.

If the timing is off, the stronger your execution, the faster you'll spend time on things that shouldn't be prioritized.

I now feel that the hardest part of working alone isn't the execution itself, but constantly judging:

• Is this direction worth continuing now?
• What is the key result at this stage?
• Which things should be contained, not expanded?
• Which actions are advancing results, and which are just creating a sense of progress?

If this judgment is wrong, execution can't save you.

If pace is chaotic, many efforts cancel each other out

Direction is one issue; pace is another.

I wasn't very sensitive to "pace" before. Later, I found it has a huge impact.

Because many things aren't impossible to do, but they shouldn't be done at the same stage.

For example:

• Trying to validate the product while also building out the whole system
• Taking on projects while also pushing new directions
• Doing content while also restructuring the entire workflow
• Solving immediate problems while being constantly interrupted by long-term ideas

At such times, you often feel:

Why am I always busy, but I don't feel like I've made solid progress on anything?

I increasingly think this state isn't due to lack of effort, but because the pace is chaotic.

The result of chaotic pace isn't necessarily that something completely fails. More commonly:

• You advance each thing a bit
• But nothing is continuously pushed to a key milestone
• Attention keeps switching
• Emotions get scattered

When working alone, this cost is high. Because there's little buffer, and no one else to help you catch interruptions.

So pace isn't a nice-to-have for solo work; it's the underlying structure.

Working alone, what you need most isn't constant sprinting, but constantly returning to the main line

I increasingly don't think the most important thing for solo work is "sustained high intensity."

Because in reality, it's hard to maintain high intensity. Projects, products, content, life—they all interrupt you.

What I value more now is another ability:

Even with fluctuations, you can keep pulling yourself back to the main line.

I think this ability matters more than just sprinting.

Because what truly separates people isn't how hard you work in a particular week, but whether you can, when many things appear at once, still know:

• What is the main line?
• What is the stage priority?
• What should be done first?
• What should not be touched now?
• What, though valuable, can't take priority now?

This ability, in the end, is a sense of direction and pace.

It's not as flashy as execution, but it ultimately determines whether you're moving forward steadily.

Now I use a few questions to remind myself not to misapply execution

I now have a few questions I often ask myself.

I don't always answer them well, but at least they keep me from falling into the habit of "just work harder."

1. What is the most important result I need right now?

Not what the task is, but what the result is.

Is it validating a direction, completing a delivery, establishing the content main line, or getting a key process running?

If this isn't clear first, you'll easily end up doing many things that don't affect the result.

2. Is what I'm doing now advancing the result, or just creating a sense of progress?

I ask myself this often now.

Because many actions give you the feeling of "I'm making progress," but they don't necessarily push the most important current result.

Sometimes you're filling in completeness, sometimes you're doing something for peace of mind, sometimes you're just doing what's easier to start.

These aren't necessarily wrong. But they may not deserve to be done first.

3. Is this the right stage to do this now?

It's not about whether it's worth doing, but whether it should be done now.

These two are very different.

Many things will need to be done later, but doing them early can still be a mistake.

4. Am I spreading my attention too thin lately?

This question is especially important for solo work.

Because when there are many things, you easily default to "I'll advance a bit of everything; it's better than not advancing at all."

But reality is often that too scattered progress leads to no sense of results.

So now I no longer treat "strong execution" as a universal answer

Of course, I still think execution is important.

Without execution, working alone won't work. But I no longer treat it as the first answer.

Because many times, the real problem isn't that you're not doing enough, but that you're putting effort in the wrong place.

I increasingly feel that the reason people overestimate execution when working alone is that execution gives a strong sense of control.

But what's truly scarcer isn't that sense of control, but these:

• Judgment of direction
• Control of pace
• Understanding of stages
• Restraint in what not to do

These aren't flashy, and they won't make you feel "I did a lot today" immediately.

But they determine whether you're heading in the right place.

What I now remind myself isn't "work harder," but "don't get chaotic first"

This is a very real change I've had recently.

Before, I was more likely to tell myself:

Do a bit more. Push faster. Fill in more completeness. Persist a bit longer.

Now, I more often remind myself:

Don't get chaotic first.

Don't sprint when the direction isn't clear. Don't start too many lines when the pace isn't arranged. Don't assume that just because you can do something, you should do it now. Don't use execution on things that shouldn't be prioritized.

Because I increasingly feel that what truly separates people working alone isn't who can endure more, but who can, amid complexity, hold the main line, hold the pace, and hold the priorities.

So if I now look at "what's most easily overestimated when working alone," my answer is clear:

The most overestimated is execution.

And what's most underestimated is often:

Direction, and pace.

Many times, the latter truly determine the outcome.