From Math to Full‑Stack: Max Ehlmaier (WienIT) on the Organic Path across Backend and Frontend

Session context: “Max Ehlmaier, Full Stack Developer bei WienIT” (devstory)

In our devstory session “Max Ehlmaier, Full Stack Developer bei WienIT,” we followed a developer who turned early curiosity for technology and math into a deliberate full‑stack role. Max speaks plainly about what motivated him, which decisions mattered, and why the full‑stack route is less a checklist and more an organic progression. For developers considering a similar path, his story highlights a pragmatic stance: focus on fundamentals, build real applications, and grow step by step—driven by the desire to ship features.

Early curiosity: technology and math as the starting point

Max’s trajectory starts with a classic spark: strong interest in tech and mathematics during school. That led him to begin a mathematics degree. In hindsight he sees it both ways. On the one hand, it “wasn’t the right thing” for him; on the other hand, it was a great decision because in his very first semester he encountered programming for the first time—and realized that’s what truly resonated.

That realization marks a pivotal shift: theoretical interest morphs into practical programming. What looks like a detour is really a continuation with more direct outcomes.

The turning point: switching to computer science

As programming takes hold, Max moves from mathematics to computer science. He notes that while other math courses didn’t feel like a fit, programming did—and that was decisive. After a few semesters, the breakthrough arrives when he builds his first “fully-fledged” web applications. At that point, it’s clear he’s in the right field.

Those early semesters give him two things: the methodical scaffolding and the first tangible wins of seeing a web app come to life. That combination—understanding plus delivery—becomes a throughline in his career.

Professional experience during university: Java backends as a foundation

Max enters professional development “already alongside” his studies, focusing on backend Java work. He builds backends and gets hands-on with logic, services, and data. That creates a solid base: clear data flows and robust interfaces.

The stance underneath is key: he wants to build applications. Once that “sits” and the backend feels comfortable, curiosity pulls him toward “the other side”—the frontend. That deliberate step beyond his comfort zone becomes the bridge toward full‑stack work.

Crossing over: exploring frontend to become full‑stack

With backend experience in place, Max explores the UI layer: components, interactions—the parts “the user can use in their browser.” He grows “gradually into the full‑stack area,” not through a dramatic pivot, but through steady expansion with the product in mind.

His sequence—go deep on backend, then add frontend—isn’t dogma, it’s pragmatic. It avoids overwhelm, keeps the learning curve steep, and makes cross‑cutting constraints tangible: how a data structure influences the UI, or how API design shapes component implementation. Max cultivates understanding on both sides—and of the connective tissue between them.

Full‑stack at WienIT: building web apps for the Wiener Stadtwerke group

Today Max works as a Full Stack Developer at WienIT, developing web applications “for the different companies of the Wiener Stadtwerkegruppe.” Full‑stack, in his words, means owning both backend and frontend responsibilities:

• Backend: logic, databases, interfaces, and data structures
• Frontend: components and functionality “the user can use in their browser”

That end‑to‑end remit naturally makes him a bridge—not only between backend and frontend, but also across teams.

The interface role: infrastructure, web design, and the big picture

Max regularly connects with colleagues from specialized areas—such as “infrastructure” and “web design.” This interface role isn’t an add‑on; it flows from the full‑stack perspective that aligns backend and frontend concerns with operational and design requirements.

What he especially values is accompanying a feature “from the ideation phase through delivery to the customer.” That end‑to‑end involvement creates context, sharpens decision quality, and raises the odds that features actually fit their use.

Tech stack: Java/Spring in the backend, Angular/Vue.js in the frontend

Technologically, his environment is clear:

• Backend: Java, extensively with the Spring framework
• Frontend: single‑page application frameworks such as Angular or Vue.js

It’s a common enterprise pairing: a mature backend ecosystem with modern SPA frameworks. For Max, tools aren’t ends in themselves—they’re how you build robust systems and deliver user functionality efficiently.

What full‑stack means in practice

When Max frames his role, several advantages become visible:

• Holistic view: Decisions happen at the intersection of backend and frontend—close to user needs and system constraints.
• Communication leverage: As a full‑stack developer he can “take on a certain interface function,” connecting infrastructure, web design, and other specializations.
• End‑to‑end ownership: From idea to delivery—a continuous thread that anchors quality and accountability.

He doesn’t label these as “advantages,” yet they’re evident in how he works: full‑stack helps turn an idea into a shippable feature because one person holds the threads together.

Becoming full‑stack: no checklist, an organic progression

Max is explicit: there isn’t a prescribed path to becoming a full‑stack developer, and you don’t arrive by “ticking all the boxes.” Instead, it’s “a rather organic development.” The common denominator is motivation: “have the drive to build applications,” paired with a willingness to engage the fundamentals.

He names them plainly: data structures, for‑loops, if‑statements. This is realism, not romance. If you want to build applications, you don’t get around these basics.

Start focused, then expand

Max advises choosing “either frontend or backend” at the beginning and focusing there, “because otherwise it can get a bit overwhelming.” Once you “feel comfortable” in that area, expand to the other side. Competence grows along real tasks—not along an idealized checklist.

Baseline for entering a full‑stack role

If you want to “start somewhere as a full‑stack developer,” Max suggests you bring two essentials:

• one programming language on the frontend and one on the backend “where you feel reasonably confident,” and
• motivation plus readiness to “look at something new.”

It’s intentionally pragmatic: not about knowing everything, but about being productive—with a clear learning trajectory ahead.

Transferable lessons from Max’s story

From Max’s narrative, several practical steps emerge:

1. Take your interest seriously: tech and math affinity is a great base, but the spark comes from building. Seek contexts where you actually program.
2. Bring practice in early: Like Max entering backend work “alongside” his studies, gather real experience early. The key is delivering real applications.
3. Stabilize fundamentals: data structures, loops, conditionals—these are not formalities. They’re the tools for every codebase.
4. Build one strong leg first: choose backend or frontend until you “feel comfortable.” This avoids overwhelm and raises the quality of your contributions.
5. Then add the other side: expand out of genuine interest and with specific tasks. That’s how you grow into full‑stack organically.
6. Lean into interfaces: seek out infrastructure, design, and other teams. Full‑stack thrives on connecting the dots.
7. Think end to end: accompany a feature “from the ideation phase through delivery.” It sharpens priorities and improves decisions.

These steps mirror the spirit of Max’s approach: practical, learning‑oriented, and focused on shipping value.

Tooling meets product: the dialogue of backend and frontend

Max’s description of working at WienIT underscores how tightly backend and frontend are coupled:

• Sound data structures simplify frontend components; the API delivers precisely what the UI needs.
• A clear user flow on the frontend guides purposeful API and data design on the backend.

That interplay creates efficiency and coherence: full‑stack developers perceive the consequences on both sides and choose in favor of the system as a whole.

Why “organic” works so well

Max’s emphasis on an “organic” path reflects the rhythm of real work: you build something, hit a boundary, learn what’s needed, and build further. This cycle keeps you from getting lost in theory and from rushing blindly into implementation. It produces robust skills—not because everything was perfectly planned, but because everything grew from practice.

Memorable lines from the session

A few statements stand out because they cut to the core:

These aren’t platitudes. They’re compact, actionable guidance.

Our DevJobs.at takeaways

From “Max Ehlmaier, Full Stack Developer bei WienIT,” we draw three clear principles:

• Full‑stack is an outcome, not an end in itself. The role emerges when you assume product responsibility and open up in both directions.
• Fundamentals beat checklists. Data structures, control flow, and interface understanding outlast any long list of frameworks.
• Focus first, expand second. Establish one leg before adding the other—staying productive all the way.

These lessons help newcomers and experienced developers alike who want to take on end‑to‑end responsibility.

Practical next steps for aspiring full‑stack developers

Max’s advice translates into straightforward actions:

• Choose deliberately: start with backend or frontend—whichever attracts you more right now.
• Strengthen basics: practice data structures, loops, and conditionals. Build small, end‑to‑end features that exercise those fundamentals.
• Ship a real app: implement a small web app—either from API to UI or the other way around.
• Add the second leg: once comfortable in your first area, allocate time to learn the other side.
• Cultivate interfaces: talk to infrastructure and design. Understand their constraints and how they shape your work.
• Carry a feature end to end: consciously accompany a feature “from the ideation phase through delivery.”

This isn’t a dogma; it reflects the spirit of Max’s approach—practical, learning‑centric, and delivery‑oriented.

Conclusion: Full‑stack as a mindset—learning from Max Ehlmaier (WienIT)

Max Ehlmaier shows a grounded route into full‑stack development: early excitement for tech, a first encounter with programming in university, a deliberate switch to computer science, a professional backend foundation with Java and Spring, an intentional move into the frontend, and, today, full‑stack work at WienIT serving the companies of the Wiener Stadtwerkegruppe.

His message encourages and clarifies: you don’t need a perfect roadmap. You need curiosity, the drive to build real applications, strong fundamentals—and a willingness to expand to the other side step by step. Follow that path and you won’t just stack technologies; you’ll assume responsibility for the whole. That’s the strength of full‑stack in practice.

• 

  

  Florence Adegeye, Service Owner bei WienIT

  Service Owner bei WienIT Florence Adegeye gibt im Interview Einblicke in den Aufbau der Teams, worauf beim Recruiting der Fokus liegt und welche Technologien im Unternehmen Einsatz finden.

  Watch now

• 

  

  Michelle Hackl, Lead Data Engineer bei WienIT

  Michelle Hackl von WienIT gibt im Interview einen Einblick in ihren beruflichen Background, wie der Arbeitsalltag als Lead Data Engineer aussieht und welche Skills es für den Einstieg in eine Techlead Rolle braucht.

  Watch now
• 

  

  Paula Gludovatz, Scrummie bei WienIT

  Paula Gludovatz von WienIT erzählt im Interview über ihren Werdegang bis hin zur aktuellen Arbeit mit Scrum und was hier für Neueinsteiger wesentlich ist.

  Watch now