From Math Enthusiast to Full‑Stack: Eva Haslinger, Full Stack Developer at Blockpit, on Study, Stack, and Teamwork

Why this devstory stands out

At DevJobs.at we hear many developer stories. The session “Eva Haslinger, Full Stack Developer at Blockpit” stands out for its clarity and groundedness. Eva traces her path without hype: early HTML/CSS/JavaScript experiments, a deliberate pivot to Software Engineering, a turning point with C# and especially Java, and a present-day role that treats Full‑Stack as end‑to‑end responsibility rather than a checklist of tools.

Threading through her account is a simple principle: let interest be your compass, use education to add structure, and leverage teamwork to deliver. That mix makes her perspective useful for beginners and for anyone deciding how to shape their place in the stack.

First steps: A math lover with a web start

Eva describes herself as a “math freak.” That playful label matters: enjoying math often aligns with the logic, structure, and problem‑solving that make programming satisfying. She gravitated to technical subjects more than to language courses and attended a school for communications and media design, where she wrote her first lines of code.

• Entry via the web: HTML and CSS for structure and design.
• JavaScript to “bring it to life” and get immediate, visual feedback.

This path is common for many developers: quick wins, instant output, and the realization that code changes the screen. That feedback loop fuels curiosity and makes the next steps less daunting.

A decisive fork: Design or programming?

After school, Eva faced a choice: keep following design, or commit to programming. She chose programming and calls it one of her best decisions, enrolling in a Software Engineering program in “Hagenwerk.”

What resonated with her:

• She felt at home and liked the courses—a strong sign that content, pace, and learning style fit.
• The program added structure and breadth: not just tools, but concepts.

This phase marks a shift from “web tinkering” to systematic software engineering. Her motivation—interest—remained constant, while the framework became more rigorous and conceptual.

From TypeScript/JavaScript to C# and Java: a turning point in understanding

Eva’s first programming languages were TypeScript and JavaScript, aligned with web work. Although C# was in the mix, it didn’t fully click at first. The turning point came at university, with deeper focus on C# and especially Java.

This line isn’t dismissive of web tech—it marks an “aha” moment. Statically typed, object‑oriented ecosystems, larger codebases, layers of architecture, clear separation of concerns—these can unlock a new mental model of software. For Eva, the benefits became tangible: maintainability, well‑defined interfaces, and a mindset that maps naturally to services and abstractions.

Full‑Stack at Blockpit: owning the stack, bridging the layers

Today, Eva works at Blockpit as a Full‑Stack Developer. She started in frontend and expanded to cover the entire stack. Her description of the role is crisp: a Full‑Stack Developer keeps an overview of the whole technology stack—starting at the database and ending at the user interface.

1) Databases: model, setup, and choice

The stack begins with data. For Eva, key questions include:

• How is the database structured—what does the product domain need?
• How is it set up and operated?
• Which database is the right choice for the use case?

It’s not just tables or collections; it’s domain thinking, queries and indices, and acknowledging how data shape the rest of the system.

2) Services: query, analyze, and add business logic

Next come services that fetch data, process them, and apply logic. Eva emphasizes this layer explicitly: queries, analysis, and logic. It’s the beating heart of an application—the rules, validations, and decisions that encode domain understanding.

3) Interfaces: clean hand‑offs to the frontend

Bridging backend and frontend are interfaces. In Full‑Stack work this is pivotal: what data are exposed and in what shape? How stable and comprehensible is the API? The quality of these contracts determines how effectively the frontend can build—and how robust the system is as a whole.

4) Frontend: presentation, interaction, immediate feedback

Finally, the frontend makes data usable. It’s where people interact with the system. This is where information architecture, consistency, performance, and translation matter: turning complex logic into an interface that makes sense.

Eva’s description underscores a point: Full‑Stack isn’t “doing everything at once,” it’s “owning the seams” and designing the hand‑offs between layers.

Teamwork: at least as important as code

Eva is as emphatic about teamwork as she is about technology. For her, communication is “at least as important” as programming.

What that means in practice:

• Co‑creating concepts.
• Reviewing architectural options.
• Working out solutions together.

In day‑to‑day work, this pays off. Clear communication prevents interface friction, reduces misunderstandings, and builds a shared architectural vision. Full‑Stack profiles benefit especially, because they bridge frontend, backend, and data perspectives.

Freedom at Blockpit: responsibility that motivates

Eva emphasizes one aspect about her role at Blockpit: she enjoys “a lot of freedom.” Even as she still considers herself a “young developer,” she can:

• develop her own features,
• define her own user stories,
• take part in architectural decisions.

Her observation draws a familiar contrast: large organizations often favor specialization and narrower scopes. An environment like Blockpit can offer broader ownership—great for people who want to learn quickly and think end‑to‑end. For Full‑Stack developers, that can be especially energizing, because the role thrives on connecting dots across layers.

Advice for beginners: let interest be your guide

Eva’s central career principle is simple: start where your interest is. Don’t force yourself into C or C++ if you have no affinity for low‑level or hardware‑adjacent work. Instead, pick a path that aligns with what you enjoy:

• If you like design or want fast visual progress: build websites. HTML/CSS/JavaScript provide immediate feedback and keep motivation high.
• If you’re less into design and more into exposing data and logic: build services and provide functionality via an API.
• If you’re a “data person,” fascinated by storage, querying, and analysis: consider Data Science or Data Engineering.

These options lower the threshold to getting started. They respect different motivations and make progress tangible.

Why a Software Engineering degree can help: concepts and overview

Eva recommends pursuing a Software Engineering degree—especially if you didn’t come from a specialized technical school. For her, the study program bridged the gap between initial practice and deeper understanding.

What it adds:

• Core concepts you might not systematically learn on your own.
• Technologies that may not be “new and shiny” but are used in real companies.
• A broad overview of “what’s out there,” providing a framework for future decisions and specialization.

The key isn’t a diploma for its own sake. It’s the scaffold that combines breadth with depth. If you lack that conceptual base—particularly without a prior technical track—formal study can lay durable foundations: languages and paradigms, architecture, interfaces, data modeling.

Mental models embedded in Eva’s story

Eva doesn’t present theory slides, yet her remarks hint at practical mental models:

• Start where the feedback loop is short: a web entry point isn’t “basic,” it’s an effective learning engine.
• Curiosity drives depth: exploring C# and Java gave Eva a new paradigm and a sturdier mental model of software.
• Full‑Stack means owning the seams: interfaces and boundaries are where systems succeed or fail.
• Communication scales systems: good team practices multiply code quality, speed, and architectural clarity.
• Freedom invites ownership: greater autonomy is meaningful when paired with accountability.

Concrete takeaways for developers

Here are actionable points distilled from “Eva Haslinger, Full Stack Developer at Blockpit”:

1. Choose your entry point by interest, not trend rankings. Motivation compounds learning.
2. Use short feedback loops (e.g., the web) to build momentum and confidence.
3. Try different paradigms. A shift to C# and Java gave Eva a new understanding of programming.
4. Develop a systems view: Database → Service/Logic → Interface → Frontend. Full‑Stack starts as a mental model.
5. Practice team skills deliberately. Communication isn’t “nice to have” but a production factor.
6. Seek environments with autonomy if you want to grow fast. Broad responsibility accelerates learning.
7. Consider formal study if you need conceptual breadth—especially without a prior technical track.
8. Align with your inclination: design/frontend, services/API, or data—each can anchor a great career.

What sticks with us

Two lines linger:

The first captures the click when concepts cohere and programming reveals itself as architecture and systems thinking, not just UI effect. The second centers the human element—because good software is a team sport.

The devstory of Eva Haslinger, Full Stack Developer at Blockpit, is more than a personal timeline. It’s a compass: interest as fuel, conceptual understanding as toolkit, teamwork as force multiplier. With that mindset, you can find your place in any stack—and take ownership where software makes a difference.

• 

  

  Building Docker Images

  Julian Handl von Blockpit zeigt in seinem devjobs.at TechTalk, warum manchmal Docker Images viel zu viel Speicherplatz brauchen und gibt Tipps was man dagegen tun kann.

  Watch now