From School Labs to Modern .NET Backends: Takeaways from “Harald Leitner, Back End Developer at Meierhofer”

Why this story matters

Listening to “Harald Leitner, Back End Developer at Meierhofer,” we heard a voice shaped by decades of hands-on engineering, modern tooling, and a grounded sense of team culture. Harald Leitner takes us from his earliest lines of code in a school computer room to the day-to-day reality of building and maintaining backend systems in a Scrum team, powered by Azure DevOps and Git. Along the way, he shares the mindset that keeps developers relevant: embrace modern practices, value collaboration, and—above all—stay curious.

This is not a story of hype cycles or flashy buzzwords. It’s a lived account of how a developer grows: starting small, learning across paradigms, choosing tools for their fit rather than for ideology, and nurturing a team-first culture. For engineers, team leads, and students alike, the session offers a practical compass for long-term growth.

Early days: Visual Basic, Pascal, C++, and the leap to OOP

Harald’s journey begins in school: a computer room behind a wooden partition, big floppy disks, a keyboard, and those first hand-written functions. From Visual Basic he moved to Pascal via a school course, and then to C++—with object orientation as the defining conceptual jump.

What stands out for today’s learners:

• Foundational breadth pays off: Exposure to multiple languages and paradigms makes later abstractions easier to reason about.
• OOP as a mindset: For many, object orientation is the first encounter with structured, maintainable design.
• Nonlinear paths are normal: Visual Basic to Pascal to C++—each step brought a new concept and a broadened perspective.

From university to two decades of .NET

After school came university—a step Harald highlights as valuable not only for depth but also for formal recognition later on. Since then, his main focus has been .NET for roughly 20 years. Crucially, he avoids tribalism: it’s less about “.NET vs. Java” and more about whether a language and its ecosystem embody a modern approach to building software.

Key implications:

• Choose tools for capability, not identity: The right stack is the one that supports modern engineering practices well.
• Keep an open mind: Yesterday’s certainties can be overturned—and that flexibility is a strength.

Letting go of myths: Performance, practice, and moving on

A pivotal realization for Harald was that performance isn’t exclusive to C++. That shift freed him to embrace modern languages and tooling—and it’s a strong reminder for all of us.

Takeaways for practitioners:

• Performance is multifactorial: Runtime, memory, I/O, architecture, databases, and networks are all part of the equation—and modern platforms address them holistically.
• Developer experience matters: Productivity, debugging, observability, and CI/CD shape quality and delivery far beyond raw language speed.
• Embrace evolution: Technology moves for good reasons; staying current is not a luxury but a professional duty.

What backend work at Meierhofer looks like: Everything behind the interface

Harald’s scope is the backend. There’s a large interface where “patients can be created,” while the backend handles all the processing behind it. He mentions databases, encryption, and storage explicitly—the things that make front-end features real, trustworthy, and safe.

For backend engineers, this is a clear checklist:

• Data modeling and access
• Security and encryption
• Storage, integrity, and traceability of processes

When a system deals with patient data, the implications for backend engineering are obvious: do it right, secure it properly, and make it traceable.

Team rhythm: Scrum with five people, shared understanding, and team acceptance

Harald works in a Scrum team of five. The flow is clear: a task appears, the team discusses possible solutions and effort, one person takes it on, and help is available as needed. Work is accepted as a team.

The core elements:

• Shared understanding before implementation
• Realistic estimation and clear ownership
• Ongoing support instead of siloed work
• Team-based acceptance as a quality gate

Harald notes there are multiple teams, all following Scrum principles—this is the norm, not an exception.

Tooling that keeps pace: Azure DevOps, Git, and full traceability

Harald stresses working “at the pulse of time,” not with yesterday’s tools. Azure DevOps and Git shape their end-to-end development flow, making every step traceable—including the “wrong turns” along the way. This level of transparency is part of building professional software, not an optional extra.

Practical benefits:

• History: Decisions and experiments remain visible and understandable.
• Quality: Changes are traceable; risk becomes more manageable.
• Collaboration: Context is shared, not hoarded.

Culture over process: Team spirit as a force multiplier

Despite the clear processes and tools, Harald highlights the personal side as “almost more important.” A team where people genuinely help each other creates dependable performance—and makes work better for everyone.

What we learned:

• Collaboration is active: Team spirit is cultivated through willingness to help, communicate, and take responsibility.
• Process is a frame; culture is practice: Scrum provides structure; people bring it to life.

Getting started in software: Just begin

Harald’s advice for newcomers is refreshingly straightforward: start. Don’t fear math or the reasoning style. Books, YouTube—choose your medium; the important part is to get going and keep going.

As an editorial team, we appreciate the pragmatism here: learning has never been more accessible. The key is to overcome the first hurdle and build momentum.

Studying: Skill plus a piece of paper

Harald points out a reality many encounter: being able to do the work is crucial, and having formal proof can be helpful—especially when you apply later in your career. If you have the time, he recommends studying to deepen knowledge and gain that credential.

The balance is nuanced:

• Self-taught beginnings are effective and immediate.
• A formal degree can add depth and provide recognition in certain hiring contexts.

Staying current: Curiosity above all

Harald’s central message is curiosity. The field is in constant flux; new things appear all the time. Rather than feel intimidated, approach them with interest—try them out—and don’t let the volume of updates paralyze you.

The practical playbook:

• Explore before you judge: New tools and paradigms deserve a fair look.
• Small experiments beat big plans: Tiny trials lower the barrier and build learning momentum.
• Leverage abundant resources: For any topic, “there are 100 YouTube videos and articles.” Use them.

Five concrete lessons we’re taking with us

From “Harald Leitner, Back End Developer at Meierhofer,” we distilled five transfer-ready lessons:

1. Build on foundations and modern practices

• Multiple languages and paradigms sharpen your architectural judgment.
• Favor ecosystems that support today’s engineering realities—beyond tribal debates.

1. Make your work traceable—for yourself and your team

• Use version control and integrated tooling (Git, Azure DevOps) to make decisions visible step by step.
• Documentation is baked into transparent history and collaborative workflows.

1. Invest in team spirit

• Giving and receiving help is a performance accelerator, not an optional nicety.
• Team-based acceptance improves quality and shared understanding.

1. Start pragmatically and learn continuously

• Books, videos, articles: pick what gets you moving.
• Consider studying when you want depth or formal recognition, especially for later applications.

1. Stay curious

• Treat novelty as an invitation to learn, not a threat to stability.
• Keep experiments small and frequent to maintain momentum.

A day in the flow: How tasks move from idea to acceptance

Harald’s description of the development flow shows how good teams balance speed and quality:

• Task emerges: It’s surfaced early and discussed openly.
• Estimation: The team aligns on scope and effort before coding begins.
• Ownership: One person takes the task—but never in isolation.
• Support: Questions are encouraged; knowledge circulates instead of siloing.
• Team acceptance: Work is reviewed and accepted collectively; quality is a shared responsibility.

This chain works because culture and tooling reinforce each other. Being “at the pulse of time” means transparency, iteration, and a bias toward learning.

The value of history: Decisions, detours, and lessons learned

We found Harald’s emphasis on history particularly compelling. It’s not just about what happened, but also why and how—including which “wrong turns” were taken. Making that visible is powerful.

• Mistakes are part of the process: When surfaced, they improve future decision-making.
• History is knowledge management: New teammates can absorb context faster.
• Engineering culture: Transparency builds trust—in both the team and the software.

Security and data: Responsibility in the backend

When an interface allows creating “patients,” the backend must meet heightened expectations: data protection, encryption, correct persistence. Harald mentions encrypting and storing data explicitly—these are non-negotiables in serious backend work.

For backend engineers, this means:

• Security is architectural: It belongs in design and process, not just in a post-hoc checklist.
• Data integrity is central: What you store must be correct, consistent, and traceable.
• Practical solutions: Standards and tooling help, but accountability stays with the team.

Staying relevant: Specialize, but keep your aperture wide

Harald’s arc—from Visual Basic and Pascal/C++ to a long-standing focus on .NET—models a healthy balance: specialize deeply in one ecosystem, yet avoid ideological narrowing. His stance that the “modern perspective on software” matters more than stack favoritism is a north star for career decisions.

Implications for your path:

• Go deep in a stack—but remain interoperable.
• Evaluate tech by how well it supports modern practices.
• Revisit old assumptions—like the “only C++ is fast” myth—when evidence changes.

Mental models for growth: Curiosity as a practice

Boiled down, Harald’s advice is a mental model for sustained growth:

• Curiosity over fear: New topics are opportunities, not threats.
• Exploration over dogma: Look first, judge later.
• Iterative learning: Small, frequent trials keep the learning flywheel spinning.

This model aligns perfectly with the tooling and culture he describes: a transparent, iterative practice where learning is visible and valued.

Practical next steps for your next sprint

Inspired by Harald’s story? Start small and keep it concrete:

• Pick a two-week learning goal (e.g., a micro backend with secure storage mechanics).
• Use Git and a task board (e.g., Azure DevOps Boards) to make your steps visible.
• Ask for feedback proactively—and offer it just as freely.
• For every new topic, read one article and watch a short video—just enough to start.
• Write down what you tried and why—your personal history speeds up your feedback loop.

These steps are intentionally modest—enough to build momentum without overwhelm. That’s curiosity in action.

Closing: A career shaped by mindset

“Harald Leitner, Back End Developer at Meierhofer” is a quietly powerful reminder of how developers grow over the long run: through curiosity, collaboration, modern tools, and the humility to let go of outdated beliefs.

Harald’s path from a school computer room to .NET-focused backend work, his Scrum team of five, the Azure DevOps and Git toolchain, the emphasis on security and data, and his balanced advice—start now, and study if it fits—together form a practical compass. Follow it, and you’ll find yourself not just keeping up, but building software and careers with intention.

And if there’s one line to carry into your next sprint, it’s this: curiosity is the most important thing. In software, that mindset keeps you moving—step by step, traceably, together.

• 

  

  Martin Brandstetter, Full Stack Developer bei Meierhofer

  Martin Brandstetter von Meierhofer erzählt im Interview über seine ersten Berührungspunkte mit dem Programmieren, was seine aktuelle Arbeit umfasst und gibt Tipps für Neueinsteiger.

  Watch now