I Am a Developer, So Treat Me Like That

Why Self-Leadership Matters More Than Any Company Policy

How often were you, as a developer, the target of finger-pointing from other departments? People who define what needs to be done until when, without involving you and expecting that you commit to it, and blame you if it fails.

If yes, it’s a bad environment for sure; that doesn’t mean at all that you are powerless.

Stoicism teaches that, even in chaotic environments, a developer always controls how they respond and how they choose to act.

So, let’s get into how we practise Self-Leadership to take real ownership.
Or in other words: How to become a trusted Software Engineer.

My personal message to developers aligned with this article:

The Problematic Software Development Space

Developers often wait for better leadership, managers, structure, prioritization, and communication. There is nothing wrong with wanting these things; they genuinely improve teams, yet relying on them entirely is also one of the fastest ways to lose stability and to feel powerless in your own career.

What I have learned, both as a developer and later as a leader, is that the most important form of leadership in our work is not the leadership that comes from above; it is the leadership we apply to ourselves. Self-leadership determines how much pressure we feel, how much clarity we operate with, and whether we stay confident in an environment that constantly tries to pull us into someone else’s urgency.

One of the biggest traps for developers is believing that their value is tied to the number of tasks they complete. In that mindset, every external request feels urgent, every message feels critical, and every meeting feels like a threat to productivity. It becomes easy to lose control of the day. Self-leadership begins with a different assumption: you are a professional who creates value through judgment and intention, rather than reacting to noise. You do not exist to respond to chaos; you exist to convert chaos into clarity. This single shift alleviates a significant amount of internal pressure.

Self-leadership is the key to influence and change.

Developers who practice self-leadership do not wait passively for clarity; they create it. They push back when priorities are unclear, because protecting focus is part of their responsibility. They ask for context before committing to work, because committing without context is not heroic; it is irresponsible. They refuse to let urgency dictate their actions, because urgency is often just the result of someone else’s lack of planning. A self-led developer can say “not now”, “this is not the real issue”, or “we need a proper understanding before we proceed” without losing confidence or status. It is not arrogance; it is professional maturity.

We don’t burn out; we get mentally exhausted.

This mindset also protects against “burnout”. Burnout, or more precisely mental exhaustion, rarely stems from hard work; it often arises from feeling trapped by an external agenda. When deadlines, priorities, and interruptions all feel imposed, your energy drains faster than your work can compensate. When you operate from self-leadership, you regain control of your attention and your pace. You set boundaries around deep work.

You define what “done” means based on quality and long-term value, not on surface-level pressure. You communicate proactively, rather than waiting until you are overwhelmed. Burnout grows in silence; confidence grows in clarity.

“You have power over your mind, not outside events. Realize this, and you will find strength.”
Marcus Aurelius, Meditations, Book 12, Section 36

Be willing to be challenged and challenge others.

Self-leadership also includes trusting your experience. Developers often underestimate the value of their instincts, which include the sense that a task is underspecified, that a deadline is unrealistic, or that a design will introduce long-term problems. Speaking up not only helps the team, it reinforces your internal sense of agency. Each time you act from conviction instead of fear, you strengthen your professional identity.

👉 You shift from “I hope they treat me like a developer” to “I carry myself as a developer, and the environment adjusts accordingly.”

This is the fundamental foundation of confidence. Not bravado, not ego, but the calm understanding that your work is to think, evaluate, challenge, and guide. When you lead yourself, others naturally follow. When you stay composed while others panic, you become a stabilizing force. When you keep direction while others scatter, you become indispensable.

🍀 Self-leadership does not replace your manager; it replaces anxiety with intention.

Being a developer means owning your craft, not being owned by everything around it. Treat yourself like a developer first, and eventually the world will too.

Leadership traits that developers should master to be valued and respected, thereby enabling them to influence their environment effectively. Without those, you get only respected as a “coder” or “programmer”, not as a mature professional taking ownership of an entire product.

Fellow Developer, Work daily on the following traits of yours:

I. Credibility
II. Role Model
III. Vision, Mission & Clarity
IV. Challenge

—Adrian