From Technical Physics to 3D MedTech: Lessons from “Katharina Freinschlag, 3D Software Entwicklerin bei CADS” (CADS GmbH)

A non-linear start that makes perfect sense

We often hear about tidy engineering careers: a CS degree, an internship, a junior role. In “Katharina Freinschlag, 3D Software Entwicklerin bei CADS,” the speaker offers a refreshingly different trajectory. She studied technical physics and only really encountered programming there—through C and C++ for numerical simulations. That mathematically grounded entry point now powers her day-to-day work building 3D software for doctors and surgeons.

What struck us is how clearly she connects motivation and method. Programming was never an abstract exercise for her; it was a tool to solve real problems. That mindset ties her journey together—from physics models implemented in C++ to medical 3D visualization where code meets clinical planning.

A mathematical lens on practical C++

In the physics program, Katharina learned C and C++ with a focus on implementing numerical simulations. That experience shaped her approach: algorithms aren’t just syntax—they are instruments for precise, efficient computation. Her master’s thesis followed the same line: a C++ implementation for a physical model where algorithmic efficiency mattered.

Key milestones she highlights:

• Learning C and C++ as part of technical physics
• Using programming to implement numerical simulations
• A master’s thesis in C++ with strong emphasis on efficiency
• Selecting additional CS courses and deciding to pursue software after graduation

This is learning in context. For Katharina, programming is driven by problems worth solving. That perspective continues to define her work—especially in performance-sensitive 3D visualization.

First industry steps: backend C++ and real-world learning

After graduation, Katharina started as a C++ software developer in the backend. Yet the majority of the skills she relies on today, she built on the job. That may be the most comforting—and practical—takeaway for anyone entering the field.

She points to core areas:

• Git and team collaboration—branching, reviews, shared workflows
• User interfaces—gaining experience that included JavaScript
• Build and test pipelines—automation as the backbone of reliability
• The surrounding “fundamentals”—architecture thinking, tooling, and process literacy

From our DevJobs.at editorial vantage point, this is powerful: few developers enter fully “complete.” What matters is your learning curve and your willingness to master the surrounding systems—tests, pipelines, interfaces, and teamwork—that turn code into dependable software.

3D medical software: from CT scans to operative planning

At CADS GmbH, Katharina works in a domain where technical depth meets human impact. The pipeline starts with patient data—CT images that are transformed into 3D anatomical models and visualized on screen. She even brought a 3D‑printed jawbone as a tangible analogue for what the software displays.

Once the models are in the application, clinicians can:

• Explore anatomy in 3D with spatial context
• Plan surgical cuts in maxillofacial procedures
• Inspect nerve pathways and tooth roots to avoid sensitive areas
• Design implants using a dedicated tool

One motivator stands out for her: seeing how the software translates directly to patient care. The line from code to clinical utility is clear—and that clarity comes with responsibility.

A broad stack instead of narrow labels

Her team doesn’t organize along classic frontend/backend boundaries. The work spans the entire 3D application: generating and rendering models, building tools for interaction, crafting the UI, and ensuring build/test pipelines and architecture hold together.

She mentions specific technologies:

• VTK as a C++ visualization library
• Qt for the user interface
• Unity for an augmented reality project—displaying 3D models on the HoloLens
• DevOps-adjacent concerns: build and test pipelines
• C++ at the core; JavaScript contributing to UI experience

For engineers, the takeaway is clear: 3D work is inherently interdisciplinary. Algorithmic thinking meets user interaction; visualization meets architecture. That breadth is a learning opportunity—you get to understand how the parts fit, rather than optimizing one silo.

Performance is a feature, not a luxury

Katharina emphasizes performance as a first-class product concern. Anatomical models are large because accuracy matters. At the same time, interaction must remain fluid—surgeons plan in real time, inspect cuts, and trace nerve paths. If rendering or tools lag, the product falls short.

This yields challenging computational paths—expensive rendering and complex operations on the models. The team frequently faces problems that require serious puzzle‑solving and tinkering. Here, her background shines: algorithmic clarity, efficiency focus, and the stamina to work through complexity until it’s tractable.

Developer takeaways:

• Performance stems from architecture, data structures, and algorithms—not just micro‑optimizations
• 3D visualization is data‑intensive—memory, latency, and render paths are intertwined
• Libraries like VTK are powerful building blocks, but product‑specific data flow and interaction decisions remain decisive
• “Smooth” interaction is a feature to design, measure, and test intentionally

Quality in healthcare: testing and code quality as non-negotiables

When software supports surgical planning or execution, the bar is high. Katharina is explicit: patient health is at stake, so their team maintains a strong focus on testing and code quality. The intent is straightforward—everything must work flawlessly.

Practical implications include:

• Testing along critical product paths
• Stable build and test pipelines
• Code quality as a shared standard

Rather than framing quality and performance as trade‑offs, she presents them as complementary. Smooth, reliable behavior is what clinicians need—which makes both pillars fundamental product qualities.

Team culture at CADS GmbH: close‑knit, flat, and idea‑friendly

Beyond tech and product, Katharina talks about the working environment. She describes CADS GmbH as having a familial atmosphere with flat hierarchies and ample room to contribute one’s own ideas. The result is engagement and joy: room for self‑realization and a team that enjoys working together.

That culture aligns with the breadth of their stack. When teams cover everything from VTK pipelines to Qt UIs and Unity prototypes for HoloLens, people need the autonomy to assume responsibility. Flat structures and open communication provide a solid foundation for that.

Pathways in—and the case for starting small

On entry routes, Katharina acknowledges the classical pathways: IT education at HTL or university. Many colleagues started that way. At the same time, she highlights viable entry points for career changers. Her advice is concrete and actionable:

• Dare to start—write small programs and try things
• Expect mistakes—and learn the underlying concepts by making them
• Pick projects that genuinely interest you—motivation fuels persistence

3D development and games engineering: a natural overlap

She points out the strong overlap between 3D development and games engineering: rendering, performance, and user interaction. Some colleagues began by developing games or writing mods—experience that maps well to medical visualization, with an added emphasis on quality and reliability.

In practice, that means:

• If you build games or mods, you already navigate 3D assets, interaction loops, and performance
• Those skills translate to clinical visualization work—augmented by a strong quality mindset

Continuous learning: staying current in a fast‑moving field

There’s a lot happening in software development—stasis isn’t an option. Katharina underlines the importance of keeping yourself current. At CADS GmbH, that shows up as regular trainings, conference visits, and peer updates. The effect, in her words: it never gets boring, and you never stop learning.

That ties back neatly to her roots in physics: curiosity and a researcher’s mindset remain productive companions—especially in domains like 3D and AR where the ground keeps shifting.

Practical takeaways for developers

Distilling her talk into practical guidance, we see clear themes:

1. Learn in context, not in isolation.

• Pair C++ with real problem spaces—simulation, visualization, and interaction.
• Treat efficiency as a core design goal from the start.

1. Invest in the “surrounding” skills.

• Git, reviews, CI/CD, and pipelines turn code into dependable software.
• UI exposure (including JavaScript) strengthens your user perspective.

1. Think end‑to‑end in 3D workflows.

• From CT ingestion to 3D model generation, rendering, interaction, and planning tools—everything is connected.
• VTK and Qt are strong building blocks; Unity can open AR avenues (e.g., HoloLens).

1. Optimize for fluid interaction.

• Large anatomical models require deliberate performance work.
• Treat “smooth” as a feature with profiling and testing behind it.

1. Make quality a habit—especially in medical contexts.

• Testing and code quality are non‑negotiable when supporting clinical work.
• Stable pipelines build trust in every release.

1. Culture multiplies competence.

• Flat hierarchies and room for ideas foster ownership and learning.
• A close‑knit team helps you explore a broad 3D stack effectively.

1. Career‑changing is realistic—start small.

• Small programs, personal projects, and mods build practical momentum.
• Pick topics that truly interest you—intrinsic motivation carries you through.

1. Stay curious—continuous learning is part of the job.

• Trainings, conferences, and peer updates keep you current.
• In dynamic spaces like 3D and AR, curiosity is a long‑term asset.

A closer look at the stack: VTK, Qt, Unity, and beyond

While the talk doesn’t dive into low‑level code, it signals the character of the work. VTK suggests a pipeline of data structures, filters, and rendering stages in C++. Qt implies tightly coupled interaction design and visualization. Unity for HoloLens adds spatial placement and head‑mounted interaction. Holding it together are architecture choices and stable build/test pipelines.

What matters in combination:

• Clean data paths—from CT images to robust 3D models
• Stable render paths—performance with large geometry
• Intuitive tools—cutting, measuring, planning to support domain expertise
• Consistent quality assurance—testing and code quality across all layers

This is a demanding stack, and that’s precisely what makes it appealing. You gain a synthesis of algorithmic thinking, systems perspective, and product focus that travels well across domains.

Motivation that lasts: seeing impact, owning responsibility

One of the strongest motivators in Katharina’s story is the visible impact of her work. Turning CT data into 3D models that clinicians use to plan procedures makes the line from code to patient very clear. That proximity to outcomes brings meaning—and a duty to meet the bar on performance and reliability.

For many engineers, that kind of purpose is powerful. Katharina’s path shows how inter­disciplinary 3D MedTech can offer it in spades.

A style of development: tinkering through complexity

Katharina talks about regularly facing complex rendering tasks and computationally heavy operations. The work requires puzzling and tinkering—until solutions emerge. That’s not a footnote; it’s the everyday reality of ambitious software. The payoff is tangible: the satisfaction of getting it to work, and the momentum that creates for the next challenge.

Conclusions for your own journey

This session doesn’t hand out a rigid checklist. Instead, it points to mindsets and practices that scale:

• Make learning problem‑driven—physics, simulation, 3D visualization: always anchor it in real use.
• Go beyond your primary language—Git, pipelines, UI, architecture.
• Seek environments that allow breadth—end‑to‑end contribution instead of strict silos.
• Treat performance and quality as product features—especially where people rely on your software.
• Start now—small projects you enjoy, and build from there.
• Stay curious—because software keeps moving.

Final thoughts: a career arc that inspires—and sets a standard

“Katharina Freinschlag, 3D Software Entwicklerin bei CADS” blends the analytical strength of technical physics with the pragmatism of building software for clinicians. It’s a career that didn’t start linearly—and is stronger for it. C++ efficiency, VTK visualization, Qt UIs, Unity on HoloLens, build and test pipelines, and Git‑based collaboration form a coherent toolkit for a task that matters.

From our DevJobs.at viewpoint, the core message is simple: good software is cross‑disciplinary teamwork. It thrives where people love to learn, take problems seriously, and treat quality as a promise. That’s the spirit Katharina embodies—and it’s what makes her story so valuable for engineers seeking a meaningful path into 3D software in healthcare.

• 

  

  Lukas Windner, Division Manager Quality Engineering bei CADS

  Division Manager Quality Engineering bei CADS Lukas Windner gibt im Interview einen Überblick über das Recruiting sowie Onboarding und spricht über den Aufbau der Teams und mit welchen Technologien gearbeitet wird.

  Watch now
• 

  

  Dominic Koch, Product Manager bei CADS

  Product Manager bei CADS Dominic Koch erzählt im Interview über die Abläufe im Unternehmen, was Neueinsteiger erwartet und mit welchen Technologien gearbeitet wird.

  Watch now

• 

  

  Claudia Wittner, Researcher bei CADS

  Claudia Wittner von CADS redet in ihrem Interview über die ersten Berührungspunkte mit dem Programmieren bis hin zur aktuellen Arbeit, wie ihr Alltag als Researcher aussieht und gibt Tipps für Anfänger.

  Watch now