From Flash Mini-Games to Kubernetes: Klio Czirny’s Path at LinkThat YouCon EDV Dienstleistungs GmbH

Insights from the session “Klio Czirny, Software Developer bei LinkThat”

In the session “Klio Czirny, Software Developer bei LinkThat,” Speaker Klio Czirny from LinkThat YouCon EDV Dienstleistungs GmbH shared a grounded, practice-first account of her journey in software development. What stood out to us at DevJobs.at was the clarity of her perspective: focus on learning how to learn, start with hands-on work, split projects into workable packages, and cultivate a team culture where communication ensures that, in the best case, both sides learn—and in the worst case, at least one does.

Her story moves from early explorations with Macromedia Flash and small games, to a master’s in Industrial Simulations, and on to a current effort to deliver a Dockerized .NET application that runs stably and securely across customer systems, monitored and managed with Kubernetes. It’s an arc that translates personal experience into practical lessons for engineers at any stage.

A creative technical start: graphical school and Flash experiments

Czirny began at a graphical HTL (a technical high school with a graphics focus), where she experimented with Macromedia Flash and built small games. Those early projects do more than evoke nostalgia; they chart the moment when creativity meets technical logic—events, state, interaction—fundamentals that reappear in every larger software system later on.

She recalls how enjoyable this was, a clue to an enduring theme in her journey: approach new tools with curiosity and keep the work playful where possible. Starting with small, fun, buildable artifacts can be the spark that sustains motivation across more demanding phases.

A decisive vacation course: discovering computer simulations

When it came time to choose a degree program, a vacation course with a focus on computer simulation became pivotal. It drew her in strongly enough that she decided to pursue it further, culminating in a master’s degree in Industrial Simulations—a blend of mathematics, physics, and programming.

The way she frames the core outcome of that program is especially telling: beyond subject matter, it trained her to acquire knowledge independently to solve concrete problems. This “learn-how-to-learn” stance threads through the rest of her story and strongly resonates with what we see in sustainable engineering careers.

Early professional phase: from C++ to UI, with game mathematics in between

After completing her degree, Czirny went straight into development in the gambling domain, writing C++. She worked across both frontend and backend and touched on mathematics, game mathematics, and game design. Later, her stack extended to TypeScript and Angular, app development, and building widgets for dashboards and user interfaces.

This breadth is less about collecting tools than about responding to the realities of software delivery. Understanding the path from computation through data flow into user-facing surfaces makes for stronger decisions at every layer. It also lays the groundwork for platform concerns—like deployment consistency and runtime management—that show up in her current project.

Joining LinkThat: onboarding by doing, then expanding scope

At LinkThat YouCon EDV Dienstleistungs GmbH, Czirny is newly onboarded and immersing herself in the product ecosystem. The approach she describes is simple and effective: dive in, take on smaller tickets, learn how things fit together, and use that early momentum to figure out where to focus.

It’s an onboarding pattern we’ve seen work repeatedly. Start with tangible tasks, seek quick feedback loops, and let that clarity inform your trajectory within the team.

First major project: packaging a .NET app with Docker, managing with Kubernetes

After the first month, Czirny has already started a larger initiative. The objective: provide a .NET application to customers in a way that makes it flexible to deploy and consistent in behavior—stable and secure—regardless of the system it runs on. Kubernetes will be used for monitoring and container management. She emphasizes that the scope spans planning from the outset through testing, including the division of work into manageable packages.

Read this as a transition from “we have an application” to “we have a platform we can operate.” Containerizing with Docker reframes runtime concerns around a reproducible unit; Kubernetes complements it with orchestration, visibility, and operational discipline. The dual aim of stability and security, delivered consistently across environments, is central to how she articulates the project.

Crucially, her description highlights that this is not just a matter of building an image. It’s about seeing the effort through—planning, testing, and cutting the work so it can actually be executed by a team. It’s the marriage of technical choice and execution practice that makes initiatives like this stick.

Team culture as an accelerator: familiar, respectful, helpful

Czirny’s description of her team centers on a familiar atmosphere, long-tenured colleagues, and communication marked by respect and helpfulness. This is not presented as a soft extra; it’s the soil from which speed and shared learning grow.

She underscores that working with people like this makes progress faster together than working alone. And her succinct thought on communication captures an important principle: when communication works, both sides learn; when it doesn’t, at least one still might. In practice, environments like this shorten feedback loops, strengthen handovers, and reduce friction between roles.

Advice to beginners: don’t linger in theory—start building

Czirny’s guidance for those starting out is unambiguous: don’t spend too long in theory. In programming, you learn best by doing. Go for tutorials and learning platforms that include hands-on components. And seek out people who know the terrain—ask questions; they’ll help, because nobody wants to see you get stuck. Above all, just start—and be genuinely interested.

What we appreciate here is the completeness of the advice: it spans method (practice over prolonged theory), resources (hands-on materials), and social dynamics (talk to people who can help). It neatly aligns with the rest of her journey, where deliberate practice, combined with peer exchange, consistently unlocks the next stage.

Practice-grounded takeaways for engineers

Drawing from Czirny’s account, here are several takeaways we see as broadly useful without venturing beyond what she shared.

1) Learn to learn—methodically, with a problem in mind

The central skill she highlights is the ability to teach yourself what you need in order to solve concrete problems. To apply this:

• Define the next problem you’re solving clearly and narrowly.
• Break your knowledge gaps into answerable questions.
• Seek answers in small increments and apply them immediately.
• Repeat the loop until a thin thread of understanding becomes reliable skill.

2) Start small and iterate

Her onboarding approach—small tickets, quick exposure, and then scaling up—works because it balances real progress with continual context-building. Practically speaking:

• Pick a modest task with real-world edges (not a toy-only exercise).
• Capture what you learn—for yourself and for teammates.
• Widen the scope as your context deepens, not before.

3) Cross the seams between disciplines

Czirny’s path crosses backend and frontend, mathematics and game design, TypeScript and Angular, app work and UI widgets. Being able to step across those seams yields holistic thinking:

• Choose tasks that deliberately straddle boundaries (data model meets UI, for example).
• Align terms and expectations with adjacent roles to avoid mismatched assumptions.

4) Think about deployment from day zero

The .NET project’s aim—stable, secure, and consistent behavior across systems—speaks to treating runtime as a first-class concern:

• Bake runtime assumptions into design early rather than patching late.
• Pursue reproducibility so “it runs the same everywhere.”
• Pair containerization with orchestration and visibility so operations keep pace with delivery.

5) Communicate so at least one person learns

Her view on teamwork places respectful, helpful communication at the center of progress:

• Ask questions sooner rather than wrestling in isolation for too long.
• Share intermediate states and uncertainties to invite course corrections.
• Value both senior and junior perspectives—insight often arrives from unexpected angles.

Why Czirny’s journey resonates now

We see several themes in her story that are particularly relevant to how teams build software today:

• Self-directed learning keeps engineers adaptable across shifting stacks.
• Practical work remains the most reliable teacher, provided it’s paired with timely feedback.
• Platform competence—containerization and orchestration—underpins reliable delivery for modern systems.
• Team culture is a productivity lever, not a footnote: helpfulness and respect compress the path to working software.

Czirny’s timeline—graphical school and Flash mini-games, a master’s in Industrial Simulations spanning math, physics, and programming, C++ in gambling development, TypeScript/Angular and app/UI work—shows how well-chosen next steps build compounding capability. Today, that breadth serves her as she helps make a .NET application behave consistently and securely across environments via Docker and Kubernetes.

Immediate actions inspired by her approach

If you want to act on the spirit of her advice right away, consider these moves:

• Pick a small end-to-end project (a tiny widget, a basic API, a UI component) so you can see how pieces connect.
• Choose a hands-on tutorial where each step yields something runnable.
• Ask a domain expert for 15 minutes of guidance—arrive with precise questions.
• Write down what you learned today and what you’ll try next; brevity beats silence.
• Practice cutting work into feasible packages: one goal, three sub-steps, start the first immediately.

Lines that linger

The session “Klio Czirny, Software Developer bei LinkThat” leaves us with compact principles we’ll remember: learn how to acquire knowledge independently to solve problems; don’t overstay in theory; seek hands-on materials; ask people who know; communicate so learning reliably happens. These are the kinds of heuristics that don’t expire when frameworks change.

Closing: A compass for pragmatic, effective engineering

From Macromedia Flash experiments at a graphical HTL, to Industrial Simulations, to containerizing a .NET application and managing it with Kubernetes, Klio Czirny’s account sketches a practical compass for engineers: start building, learn deliberately, shape work into achievable pieces, and cultivate communication that accelerates everyone involved.

Our key takeaway from “Klio Czirny, Software Developer bei LinkThat” is that steady, unspectacular steps can compound into serious capability. Czirny’s path is a reminder to keep moving, keep asking, and keep turning lessons into operating principles—today in the context of Docker and Kubernetes, tomorrow wherever the next problem leads.

• 

  

  Steffen Kopany, Head of Software Development von LinkThat

  Steffen Kopany von LinkThat spricht im Interview über das Development Team aus organisatorischer und technologischer Perspektive und was bei neuen Mitarbeitern wichtig ist.

  Watch now