From C64 to Full‑Stack Ownership: Takeaways from “Roland Kern, Senior Full Stack Developer bei DIG” (DIG GmbH)

What we heard in the session: Title, Speaker, Company

In the session “Roland Kern, Senior Full Stack Developer bei DIG,” speaker Roland Kern of DIG GmbH walked us through his path into software, the essence of his Full‑Stack role, and the mindset that keeps him moving forward. At DevJobs.at, we listened closely and found a clear, human‑centered narrative about curiosity, practice, and responsibility.

The milestones are concise yet evocative: a Commodore 64 at age ten; programming in school with Turbo Pascal; a university degree in Media Technology and Design; a pivotal internship that steered him back from the more artistic, multimedia side into software engineering; and today a Senior role that blends frontend, backend, a strong design sensibility, and team responsibility.

The C64 beginning: Playfulness meets real learning

Kern received a C64 at the age of ten—“of course for playing,” as he puts it. The real turning point, however, was the manual. That documentation opened a doorway into BASIC and his very first programming experiences. For us, it’s a powerful image: learning often starts where curiosity meets something hands‑on and immediately useful.

• A tangible early environment (the C64) makes technology graspable.
• Good documentation (here: the manual) acts like a mentor.
• “Play” and “learning” aren’t opposites—they’re complementary drivers of discovery.

Kern reminds us of a timeless lesson: when you open the door to tech yourself—out of genuine curiosity and the urge to try things—you lay down foundations that last.

School: Turbo Pascal and structured thinking

In school, a special informatics program brought Turbo Pascal into the picture. If BASIC was the playful beginning, Pascal added structure and formal discipline.

Turbo Pascal might be rare on modern stacks, yet the effect remains: learning the craft with classical languages builds patterns that outlive any single technology—control flow, data types, algorithms, readability. Kern’s journey shows how those fundamentals are a reliable base, no matter where technology trends drift.

University: Media Technology and Design—and a return to software

Kern studied Media Technology and Design. During his studies, Java and a bit of C entered the mix. Then came a decisive turn: an internship that nudged him back toward software engineering and somewhat away from the artistic side of multimedia.

This is the crux: no abrupt switch, no either‑or. The design sensibility stayed—and became an asset. It surfaces later in Full‑Stack work, especially in user interfaces and usability. For us, the principle is clear:

• Detours aren’t baggage; they differentiate you.
• Interdisciplinarity—tech and design together—is a genuine lever in product work.

Full‑Stack as end‑to‑end responsibility

When Kern talks about his role, end‑to‑end ownership is front and center: frontend and backend, integrated with the responsibility to deliver a complete solution.

“Completely” isn’t just code across two layers. It means absorbing a customer need, modeling it, thinking through interfaces and UI, and shipping a working part of a product. From our viewpoint, Full‑Stack in Kern’s framing implies:

• Understanding and sharpening requirements; expressing them as clear backlog units.
• Designing frontend and backend coherently, not as siloed handoffs.
• Defining quality not only by technical metrics, but by the actual user experience.

Variety over backlog treadmill: Design as a quality anchor

Kern stresses that his work isn’t defined by an endless ticket queue. His background broadens his perspective—and his responsibility.

This is where his design roots resurface. “Looks good” and “reasonably usable” are two sides of the same coin: aesthetics and usability. In a Full‑Stack capacity, they aren’t “details for later,” but primary success criteria. Our read:

• Product thinking over ticket grinding: prioritize user flows over subsystems.
• Treat design as responsibility, not an add‑on.
• Usability is quality—on par with correctness and performance.

Workflows in the product: Configuration, not just implementation

A telling detail about the product landscape: “Customer workflows are configured in our product with a dedicated workflow designer.” That signals a context in which not every solution is hard‑coded; configuration plays a central role.

For Full‑Stack engineers, that often‑overlooked angle matters: thinking in business processes that can change without bespoke development for every variant. Practically, this means:

• You’re not only building an application—you’re building room for users to shape their work.
• Stability and changeability must be designed together.
• A “workflow designer” demands clear interfaces, semantics, and a solid UX.

Seniority as a team mandate: Onboarding and platform knowledge

Beyond implementation, Kern underlines his responsibility as a Senior: bringing new developers on board and explaining how the platform works.

That’s Seniority in action: not just delivering, but enabling. What stands out is the pragmatic, team‑centered framing—no “lone expert,” but someone who makes complexity understandable and thus accelerates the team. Our takeaways:

• Seniority is measured by knowledge transfer as much as by tickets shipped.
• Platform knowledge multiplies value when it becomes accessible to others.
• Onboarding is product work: enabling new colleagues boosts the whole system.

Learning and entry: Interest over pedigree

Kern becomes especially direct when he talks about how to learn. His advice is refreshingly concrete:

And he extends it to backgrounds:

Three clear messages emerge:

1. Real projects over abstract exercises: motivation fuels practice.
2. Language is secondary: the underlying concepts matter most.
3. Background isn’t a gatekeeper: proficiency comes from practice, curiosity, and focus—whether you come via university, HTL, or another path.

Practical impulses for newcomers

Kern’s points translate directly into action. If you’re starting out, you can:

• Turn a personal itch into a small, tangible project (a tool for your routine, a mini‑app, a script that removes friction).
• Choose a language that excites you—don’t chase the “correct” one. Motivation beats dogma.
• Iterate in small steps: ship something visible, gather feedback, refine.
• Treat design as first‑class: aim not only for “works,” but for “is usable.”

Cultivating Full‑Stack thinking—guided by Kern’s cues

From Kern’s description of his role, you can derive guardrails for Full‑Stack work without speculating beyond the talk:

• Start with the user flow: what task does the customer truly need to complete?
• Think end‑to‑end: design frontend and backend together, not as serial handoffs.
• Consider configurability: where does a configurable workflow help instead of hard‑coding variants?
• Make design and usability part of the definition of done.
• Share knowledge: explain the platform, accelerate onboarding, surface questions early.

These points mirror what Kern explicitly underlines: the harmony of technology, design sensibility, and team responsibility.

The value of detours: Media, design, and a better product lens

Kern’s story shows that careers don’t have to be linear. The swing from the artistic/multimedia side back to software wasn’t a break; it was a boost. The feeling for design became a resource. Anyone building products benefits from this mix: a sense of form, clarity in interaction, and technical execution.

The lesson isn’t “everyone should study design,” but rather: acknowledge and cultivate adjacent competencies. For Full‑Stack work, this cross‑profile often makes the difference.

Why “honest interest” is the strongest currency

When Kern says “honest interest” is the most important thing, it reads as more than motivation—it’s a method:

• Interest produces stamina—you stick with problems because they matter to you.
• Interest deepens understanding—you try, compare, and truly grasp instead of only “implementing.”
• Interest connects—you find better alignment in teams, because your questions are clearer and your goals more grounded.

In a world of changing tools, “honest interest” remains stable. It carries you across languages and frameworks—the very arc reflected in Kern’s path from C64 and Pascal to Java/C and today’s Full‑Stack work.

Mentoring as a force multiplier

Kern’s mention of onboarding makes a broader point: learning is a team act. Those who explain, understand better; those who listen, accelerate their growth. Teams that cultivate this exchange reduce ramp‑up time and improve decision quality—not because they know everything, but because knowledge is accessible.

For us, this is one of the strongest, implicit messages in his story: Seniority shows when you make complexity understandable for others.

A compass for careers without rigid templates

Kern states plainly that formal background doesn’t decide everything. His own example (Media Technology and Design, then software) and his acknowledgment of strong developers from HTL underline the same idea: capability emerges in practice. This isn’t an argument against education—it’s an argument for proximity to real work and intrinsic motivation.

If you adopt this compass, you’ll make better choices:

• Instead of “Which language will advance me fastest?” ask “What do I genuinely enjoy—and will stick with?”
• Instead of “How do I optimize my resume?” ask “How do I ship outcomes that genuinely improve something?”

Concrete next steps—inspired by Roland Kern

• Pick a project that touches your daily life (a workflow, a routine, something that annoys you) and build a first version within a week.
• Close the loop: not just logic, but a small interface that is clearly usable.
• Write down the user flow before you write code.
• Explain your solution to another developer—as a dry run for onboarding.
• Ask where configurability would make your solution last longer.

These steps align directly with Kern’s statements: interest, end‑to‑end thinking, usability, knowledge sharing, and process awareness.

Conclusion: Craft, attitude, and a human lens

“Roland Kern, Senior Full Stack Developer bei DIG” draws the picture of a developer who blends craft and attitude. From the C64 manual through Turbo Pascal and Java/C to today’s Senior role at DIG GmbH, a consistent idea emerges: Full‑Stack is more than technological breadth—it’s the responsibility to carry requirements end‑to‑end, to take user orientation seriously, and to share knowledge in the team.

The most essential line remains his advice:

It sounds simple—and in practice it’s radical. Work that starts there tends to endure, keep you learning, and make the people around you better. That’s exactly what we took away from this session.

• 

  

  Gerald Sigmund, Chief Software Architect von DIG

  Der Chief Software Architect von DIG Gerald Sigmund erzählt im Interview über den Aufbau des Devteams im Unternehmen, mit welchen Technologien gearbeitet wird und wie das Recruiting abläuft.

  Watch now

• 

  

  Philipp Kirschner, Senior Software Developer bei DIG

  Philipp Kirschner von DIG spricht im Interview über seine Anfänge im Programmieren mit Computerspiele, was seine aktuelle Arbeit beinhaltet und wie man am besten selbst im Software Development Fuß fasst.

  Watch now