Logo Elektrobit

Elektrobit

Established Company
Show all Videos

Nikolaus Donath, Technology Team Manager bei Elektrobit

Description

Nikolaus Donath von Elektrobit gibt im Interview Einblicke in die Rolle als Technology Team Manager und spricht über den Aufbau des Teams.

By playing the video, you agree to data transfer to YouTube and acknowledge the privacy policy.

Video Summary

In "Nikolaus Donath, Technology Team Manager bei Elektrobit," Speaker Nikolaus Donath shares his path from developer to team lead and stresses that new leaders need a solid technical foundation plus soft skills like delegation and granting autonomy so teams can learn, develop, and scale. Elektrobit builds software for cars; team leads come from development and stay hands-on as Product Owners, Scrum Masters, or Software Architects—he is Product Owner for the TCP-AP stack of the in-vehicle OS, bridging customer feature timelines and efficient team delivery. His 15-person distributed team (Vienna, Croatia, remote) works in three subteams with two-week sprints and a quarterly Programming-Increment planning workshop held preferably in person with social activities like shared meals or grilling, reinforcing alignment, cohesion, and successful launches seen on the road.

Leading with Technical Depth: Lessons from “Nikolaus Donath, Technology Team Manager bei Elektrobit” on team scaling, customer focus, and delivering automotive software

Introduction: A tech lead who balances code, people, and delivery

In the session “Nikolaus Donath, Technology Team Manager bei Elektrobit,” one theme stood out: at Elektrobit, technical leadership is truly technical. Nikolaus Donath started as a developer, moved into project management, repeatedly volunteered “to do a little more,” and then stepped into a team lead role when the opportunity arose. Today he serves as Product Owner for the TCP-AP stack in Elektrobit’s operating system for in-vehicle ECUs—offering a concrete view of what effective leadership looks like in this environment: deep technical grounding, deliberate delegation, real autonomy, and clear, customer-attuned delivery.

“What’s important is building a strong technical foundation … and being able to talk to the team at eye level.”

For engineers and aspiring leaders, this talk is a tightly argued playbook for aligning technical excellence, agile practice, and human collaboration to ship automotive software that ends up inside real cars.

Elektrobit in focus: Automotive software with an operating system and TCP-AP stack

Elektrobit builds software for cars. A central component: an operating system for in-vehicle control units (ECUs). The TCP-AP stack Nikolaus oversees is part of this operating system. Customers are automotive suppliers building new ECUs for new vehicles, and they integrate Elektrobit’s OS to do so.

That sets a precise mandate for engineering:

  • Deliver the features customers need in the stack.
  • Meet supplier timelines, which are tied to the automaker’s program cadence.
  • Keep the team working efficiently and sustainably so plans become reality.

“I make sure our customers get the functionality at the time they need it—and that the team can work well and efficiently.”

Balancing customer deadlines and team health isn’t a contradiction at Elektrobit—it’s the operating principle.

From developer to team leader: responsibility grows with the work

Nikolaus’ path is characteristic for technical leadership at Elektrobit: start in development, lead projects, then take on a team. The decisive factor was not a title but a willingness to assume responsibility. He “kept volunteering to do a bit more,” and when the team lead role was posted, he applied and stepped up.

For emerging leaders, the pattern is clear:

  • Responsibility starts with the work, not the title.
  • Looking beyond your own code opens the door to project and eventually team leadership.
  • Leadership at Elektrobit stays technical; the route to it runs through development, not around it.

What makes engineering leadership effective

Nikolaus distills the requirements for new team leads into two axes: technical depth and impactful soft skills.

1) Technical foundation: talk “at eye level” with the team

Team leads at Elektrobit come from development and remain active in projects. They understand what the team is building and can engage on substance. That enables sharp decisions, credible prioritization, and near-term support when it’s needed most.

  • Grasp the stack and the team’s ongoing work.
  • Communicate about architecture, implementation, and dependencies.
  • Translate customer requirements into scoped work for the team.

2) Soft skills: delegate, protect autonomy, enable growth

Good leadership delegates—so team members can develop their own styles. Too much micromanagement slows teams down; too little direction risks delivery. The balance: clear goals and guardrails, with wide autonomy in execution.

“I shouldn’t prescribe in too much detail how the work has to be done … in the end, the team should be able to develop and learn … otherwise it won’t scale.”

Core points we heard:

  • Delegation with trust: hand over responsibility, not just tasks.
  • Autonomy as the default: allow different working styles as long as goals and quality are met.
  • Growth as a priority: give space for learning and style formation.
  • Scaling via leadership: only genuine delegation allows work to scale.

Team leadership at Elektrobit is hands-on and multifaceted

In development, team leadership is a technical role. Leads come from engineering and continue to contribute directly—as Product Owners, Scrum Masters, or Software Architects. This is not a managerial layer abstracted away from delivery; it is technical leadership that bridges hands-on work and coordination.

Nikolaus’ role is clear: he is the Product Owner for the TCP-AP stack of Elektrobit’s operating system. He mediates between customers (suppliers) and developers, aligns requirements and delivery timelines, and ensures the team can operate efficiently. This proximity to customers and code sharpens priorities and creates a shared definition of “done.”

Customer focus with real cadence

Automotive suppliers maintain firm timelines for deliveries to the carmaker. This shapes development: required features must be available on time. The Product Owner ensures that scope and timing align—for the customer and for the team.

Concrete guardrails underscored in the session:

  • Translate customer requirements into realistic team capacity.
  • Clarify delivery dates and reconcile them with effort estimates.
  • Prioritize so timelines and quality remain achievable.
  • Communicate tightly with customers and the team—without translation loss.

This balance works because leadership at Elektrobit keeps both rhythms in view: the external cadence of customers and the internal flow of the team.

Team structure and ways of working: 15 people, 3 subteams, two-week sprints

Nikolaus’ team includes 15 people, distributed across Vienna, Croatia, and several fully remote members. Most collaboration happens virtually. The structure is well-defined:

  • Three subteams, each with a dedicated Scrum Master.
  • Nikolaus serves as Product Owner for the TCP-AP stack.
  • Two-week sprints set the delivery heartbeat.
  • Every three months, a “Programming-Increment-Planung” takes place—a one- to two-day planning workshop for the upcoming quarter.

Quarterly planning: creating clarity together

The quarterly planning (Program Increment) is a deliberate pause in the sprint rhythm. The goal is to plan the next three months in detail, preferably in person where possible, so that content, dependencies, and workload distribution are thoroughly discussed.

“We … go through what we will do in the next three months in detail … so everyone knows what’s coming … and then the team estimates the work.”

Key elements:

  • Shared understanding: “everyone on the same page.”
  • Team-based estimation to ensure feasibility.
  • Commitment through clarity—what will be completed in three months and how work is allocated.

Collaboration means connection, too

Around the planning workshop there’s a small social program: going out for dinner, grabbing pizza, or grilling on the terrace. In distributed teams, these moments strengthen cohesion—and make the virtual day-to-day run smoother.

“It’s just nice to meet regularly in person and privately. I really enjoy that.”

Motivation: challenging projects—plus a visible end result

What drives the work? For Nikolaus, it’s the combination of technical challenge and a realistic scope. The ideal project is demanding, new, and doable. Collaboration with customers and the automaker is part of the process, and success becomes literally visible at the end: cars on the road running the team’s software.

“In the end … we see the vehicle driving on the road with our software inside. That’s just very nice.”

For engineers, this is a rare, tangible proof of impact: your code moves in the real world.

What Elektrobit expects from tech talent

Based on Nikolaus’ remarks, expectations are crisp and practical:

  • Strong technical foundation: understand the team’s work and converse at eye level.
  • Ownership mindset: step up, look beyond your own code, volunteer to take on more.
  • Delegation as a leadership skill: if you lead, you hand over responsibility—and safeguard autonomy.
  • Autonomy in practice: develop your own style, craft solutions independently, uphold quality.
  • Agile discipline: commit to two-week sprints, estimation, and a solid quarterly planning cadence.
  • Distributed collaboration: contribute effectively virtually, plan intensively in workshops, and value social bonding.
  • Customer proximity: understand requirements, respect timelines, and communicate in solutions.

These aren’t slogans—they show up in every sprint and every quarterly plan.

Why engineers should consider Elektrobit

The session offers multiple, concrete reasons to put Elektrobit on your radar:

  • Direct product impact: contribute to an operating system for ECUs—including the TCP-AP stack—with a visible outcome in vehicles.
  • Technical leadership: leads remain hands-on, working as Product Owners, Scrum Masters, or Software Architects.
  • Clear operating rhythms: two-week sprints anchored by structured quarterly planning.
  • Real autonomy: delegation and freedom are the norm—growth and personal working style are embraced.
  • Customer cadence: work paced by supplier timelines and aligned with automaker programs.
  • Distributed, well-orchestrated teams: Vienna, Croatia, and fully remote members—virtual by default, deep alignment in person when possible.
  • Human-centered team culture: shared dinners, pizza, grilling—relationship-building is part of the operating model.

For seasoned engineers and aspiring team leads alike, this is an environment where both technical depth and collaborative strength matter.

Practices that scale: from delegation to planning

The talk surfaces the building blocks Elektrobit uses to scale software development without sacrificing quality or cadence:

  • Delegation by default: distribute responsibility so that not “everything is done by one person”—that’s how work scales.
  • Clear roles: Product Owner, Scrum Master, Software Architect—technical leadership, not administrative overhead.
  • Sprint cadence plus program increment: short-cycle delivery matched with quarterly focus—detail and foresight in balance.
  • Team-based estimation: the people who do the work size the work.
  • Relationship rituals: social time around key planning moments builds trust.

These elements reinforce each other: they sharpen priorities, keep teams focused, and support a reliable delivery rhythm.

Quotes and guiding principles that stick

Several lines from Nikolaus capture Elektrobit’s culture succinctly:

  • “A good technical foundation … and being able to talk at eye level with the team.”
  • “Delegate … and give the freedom for each team member to develop their own style.”
  • “Otherwise it won’t scale.”
  • “I make sure customers get the functionality at the time they need it—and the team can work efficiently.”
  • “In the end … we see the vehicle on the road with our software inside.”

These are more than quotes—they’re operating principles.

Conclusion: Technical leadership that makes impact visible

“Nikolaus Donath, Technology Team Manager bei Elektrobit” presents a leadership model that holds up in practice: technical depth, deliberate delegation, structured planning, and real customer proximity. The result is teams that hit demanding targets—and software that quite literally ends up on the road.

If you’re looking for a place where leadership isn’t decoupled from engineering, Elektrobit stands out: take ownership, grow with your team, deliver together—and enjoy seeing your results drive by on the street.

More Tech Talks

More Tech Lead Stories

More Dev Stories