Workplace Image eurofunk Kappacher GmbH

Johannes Festi, Trainee Software Development bei eurofunk Kappacher

Description

Johannes Festi von eurofunk Kappacher gibt im Interview Einblicke in den Arbeitsalltag als Software Development Trainee, wie er dazu gekommen ist und was seiner Ansicht nach wichtig für den Einstieg ist.

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

Video Summary

In "Johannes Festi, Trainee Software Development bei eurofunk Kappacher," Speaker Johannes Festi shares a varied path: after a commercial education, university semesters, and office jobs, he completed a six‑month training and is now a junior fullstack developer in a trainee program. Rotating through six software development departments gives him a holistic view—from code and technology to the people behind it—and helps him understand how products connect. He values eurofunk’s 360‑degree control center solutions (hardware like desks, audio devices, and microphones plus software) for emergency services, airports, and chemical parks, and advises newcomers to stay curious: programming is like detective work, especially in debugging where you may be both investigator and culprit.

Detective Work in Code: Lessons from “Johannes Festi, Trainee Software Development bei eurofunk Kappacher” at eurofunk Kappacher GmbH

A non-linear path powered by curiosity

Great engineering stories often start with a simple question: What’s behind the screen? In the session “Johannes Festi, Trainee Software Development bei eurofunk Kappacher” (Speaker: Johannes Festi, Company: eurofunk Kappacher GmbH), we heard a devstory that turns this question into a career-defining compass.

Johannes describes his path to programming as “very versatile.” He comes from Lower Austria, completed a commercial school education, spent a few semesters at university, and worked in office jobs. Then he decided—decisively and with focus—to take a six‑month training at “Koderspäne Wiener.” Right after that, he entered the field as a Fullstack Junior Developer. Today, as a Trainee in Software Development at eurofunk Kappacher GmbH, he rotates through six departments to experience software engineering as a connected whole.

These milestones are more than a timeline. They reflect a mindset: to program because you want to understand how things work—and because you enjoy spotting clues, connecting dots, and building solutions. That’s the thread running through everything Johannes shares.

From commerce to code: a deliberate switch

Johannes didn’t start out with a typical developer résumé. He brings a commercial education, university exposure, and office experience. To us, that background is an asset rather than a detour:

  • A commercial lens focuses attention on process, quality, and customer needs.
  • Academic exposure strengthens structured thinking—useful when analyzing complex systems.
  • Office practice sharpens collaboration skills and a sense for roles, responsibilities, and communication.

He ties this background to a plain, powerful curiosity. He recalls visiting websites and asking, “What is actually behind this? Why does it work the way it does?” That question becomes the ignition for his transition into software.

Six months of focus: breaking into development

As Johannes puts it—with a concise “long story short”—he started the six‑month training at “Koderspäne Wiener.” Compact enough to force focus, long enough to lay a foundation, this period captures a pattern we see in many career changers:

  • A bounded learning sprint concentrates attention and energy.
  • The entry is practice-oriented: from “How does it work?” to “I can build this.”
  • The target is capability, not perfection—stepping confidently into a junior role.

By the end of that phase, Johannes is a Fullstack Junior Developer. While he doesn’t name specific technologies, “fullstack” signals a deliberate choice to learn broadly before specializing—a theme that carries through his trainee experience.

Fullstack as a learning arena: breadth before depth

In Johannes’s context, “fullstack” means understanding multiple layers and how they connect—frontend, backend, infrastructure; data, interfaces, user-facing behavior. Even without naming stacks or frameworks, one priority is clear: the ability to recognize relationships across the system. That’s not window dressing; it’s the core of his learning strategy.

For aspiring developers, that’s a vital message: It’s not only okay to start broad—it can be essential. If you internalize the system perspective early, your later deep dives are grounded in the why, not just the how.

Rotating through six departments: practicing systems thinking

The trainee program at eurofunk Kappacher GmbH is structured so Johannes “rotates through the six departments of software development.” He calls this both a major advantage and a big challenge. The value, as he describes it, goes beyond tools: he gets to know working styles, personalities, codebases, and “the technology that ultimately underpins it.”

We see three levels of impact in this rotation:

  1. Technical: You learn how requirements flow—from specification and architecture through implementation, testing, and delivery. You witness where dependencies emerge and how they’re managed.
  2. Human: “The personalities behind it” matter. People build systems. You internalize communication patterns, decision logics, and lines of responsibility.
  3. Product: Rotating across products reveals patterns, recurring constraints, and domain-specific traits. You learn to read product families, not just individual features.

Johannes summarizes the experience plainly: “There is actually something new to learn every day.” In a rotation, every chapter is a new context. It stretches your thinking and trains the flexibility modern engineering demands.

360-degree solutions: when hardware, audio, and software converge

A highlight of Johannes’s account is his take on his employer’s solution scope. eurofunk, he explains, offers a “360‑degree solution for control centers for emergency services and, among others, airports—which also operate their own control centers—or chemical parks.” The offering spans “from the desks to the audio devices, to the microphones and also in the software,” delivered as a “complete package” to customers.

What does that mean for day‑to‑day software work? We see several implications that shape Johannes’s learning environment:

  • End‑to‑end responsibility: If you provide 360‑degree solutions, you think from furniture to application. You must consider interfaces between the physical and the digital.
  • Interdisciplinarity: Audio, microphones, desks, software—multiple trades must align. Communication and integration are central to success.
  • Quality as a whole: When everything comes from one hand, quality is perceived as an integrated experience. Errors surface not only in logs but in real‑world operation.

For a trainee, it’s an ideal arena. The rotation reveals the building blocks; the 360‑degree solution reveals the whole. Together, they make tangible how “code and the technology behind it” interlock.

Curiosity as a habit: keep asking what’s behind the surface

Johannes keeps returning to one theme: curiosity. His advice to anyone starting out is to bring “interest” and “curiosity.” His own example is concrete: He visits a website and asks, “Why does it work the way it does?” That question drives the learning loop—from observation to understanding to implementation.

It’s a practical learning recipe:

  • Observe: Watch a system in action—a page, a device, a workflow.
  • Question: Why is it like this? What happens if I change X? What assumptions are baked in?
  • Decompose: Mentally break the system into parts. What clues does it reveal? What interfaces might exist?
  • Build: Try, reproduce, experiment, compare.

Competence emerges from direct engagement with real behavior—just as Johannes describes.

Programming as detective work: clues, causes, and the plot twist

Johannes uses a memorable metaphor: “Programming is a bit like detective work.” You need to “find clues to arrive at the right solution.” Bug fixing adds a twist: “Plot twist—sometimes you’re both the detective and the perpetrator.”

That image captures a core reality of engineering:

  • Clues: Logs, exceptions, under‑load behavior—each signal is an indicator.
  • Hypotheses: What could cause this? Which modules are in play? Which conditions trigger it?
  • Tests: Reproduce, narrow down, measure.
  • Ownership: If you worked on the code, you might also have introduced the bug. That doesn’t indict you; it accelerates learning when you surface it quickly.

For teams, the lesson is cultural: Reward detective work and treat the “perpetrator” moment as a chance to strengthen understanding, not to assign blame.

Practical takeaways for developers at any level

Johannes’s story translates into actionable practices. All of them reflect what he said—and all are applicable in everyday engineering:

  1. Start with a sharp question. “Why does this page work the way it does?” Make your curiosity concrete. It focuses your efforts and keeps motivation high.
  2. Simulate rotation even without a formal program. If there’s no official rotation, rotate informally: read code in adjacent modules, shadow teammates in reviews, switch vantage points between frontend, backend, and testing.
  3. Think in systems. A 360‑degree offering like eurofunk Kappacher GmbH’s reminds us that software is part of a larger whole. Ask: What real‑world environment or hardware shapes this feature’s behavior?
  4. Structure your debugging clues. Capture observations: What did I see? Under which conditions? Which hypotheses are ruled out? Turn ad hoc troubleshooting into a method.
  5. Embrace the “perpetrator” moment. If you introduced a bug, be the first to surface it and lead the fix. Transparency compounds learning and builds trust.
  6. Learn something small every day. As Johannes notes, “there is actually something new to learn every day.” Create micro‑learning slots: read 20 minutes, run a small experiment, or review a slice of code.

Team mechanics: rotation and 360-degree thinking as quality drivers

Johannes calls rotation both a “big advantage” and a “big task.” From a team perspective, that makes perfect sense:

  • Break down silos: Moving across departments reveals interface problems early—before they become costly.
  • Build a shared vocabulary: Different disciplines often use different words for similar concepts. Rotation aligns language and expectations.
  • Strengthen mentoring: Rotating trainees force teams to make tacit knowledge explicit, improving documentation and onboarding.
  • Ensure product coherence: Where “desks, audio devices, microphones, and software” must work together, clean interfaces and coordinated processes define the end experience.

Johannes emphasizes how “interesting” it is to understand connections—across departments, products, and technology. That appetite for relationships is itself a marker of quality.

Learning from mistakes: the culture behind the plot twist

The detective metaphor pays off when teams treat errors as learning events. Following Johannes’s logic suggests a practical loop:

  • Normalize errors: Complex systems produce bugs. The differentiator is the speed and clarity of detection and resolution.
  • Prefer causes over symptoms: Don’t just hot‑patch—trace back to origin. With structured clues, the actual cause often reveals itself “relatively soon.”
  • Share the learning: Every found clue becomes team learning material. Bring the plot twist into retros and knowledge bases.

The result is a learning curve that benefits both individuals and the organization.

Quality as a whole: delivering a complete package

When Johannes speaks of a “360‑degree solution” and a “complete package,” there’s a clear promise: customers receive a solution from one source—spanning physical setup, audio, and software. For engineers, this means designing quality as an integrated experience:

  • UX is more than UI: acoustics, ergonomics, latency, and fault tolerance matter.
  • Release is more than deployment: consider the real‑world environment where the solution operates.
  • Tests must cover system boundaries: not just unit or integration tests, but scenarios where hardware and software interact.

That perspective shapes architecture, code, and processes—and makes the work compelling because each improvement affects the whole experience.

A clear message to newcomers: follow your curiosity

Johannes offers straightforward advice: bring interest and curiosity. Keep asking, “What is actually behind this?” That mindset is not just a starting point; it’s a durable practice. If you stay curious, you will, like Johannes, find “something new to learn every day.”

Ways to put this into action:

  • When you use a feature, try to explain it as if to someone without context.
  • Seek the “why” behind the “how”: Why was this architecture chosen? Why does this module behave like this?
  • Build small prototypes to test your hypotheses—the fastest way to learn.

Closing: a devstory about systems thinking, ownership, and the joy of solving

“Johannes Festi, Trainee Software Development bei eurofunk Kappacher” is a devstory that starts with curiosity and lands on responsibility. Johannes shows how a diverse background—commercial education, time at university, office roles—can lead, via a six‑month training, into a junior developer position, and then into a rotating trainee program that systematically builds a systems‑level mindset.

His images stick: programming as detective work; bug fixing as a plot twist that turns you into both detective and culprit. His view of eurofunk Kappacher GmbH’s 360‑degree offering anchors those metaphors in reality—where desks, microphones, audio devices, and software don’t just coexist; they must work together.

Our takeaways: Ask questions. Look for clues. Understand the whole. And enjoy the fact that, as Johannes puts it, “there is actually something new to learn every day.”

More Tech Talks

More Tech Lead Stories

More Dev Stories