enjoy IT GmbH

Etablierte Firma

Alle Videos anzeigen

Thomas Hochgatterer, Back End Developer bei enjoy IT

Thomas Hochgatterer von enjoy IT gibt im Interview Einblicke in seinen Werdegang mit dem Prorammieren, wie sich sein Arbeitsalltag als Back End Developer gestaltet und gibt Tipps für Neueinsteiger.

Beim Videoaufruf stimmst Du der Datenübermittlung an YouTube und der Datenschutzerklärung zu.

Video Zusammenfassung

In "Thomas Hochgatterer, Back End Developer bei enjoy IT" erzählt Speaker Thomas Hochgatterer, wie er über ein Wahlfach in der Hauptschule (Pascal mit 14), die HTL für EDV & Organisation und ein Wirtschaftsinformatikstudium zur Backend-Entwicklung fand. Er beschreibt seine Rolle: Daten im Hintergrund aufbereiten und manipulieren, Schnittstellen anbinden und Informationen für Frontends bereitstellen; in Projekten ist er von der Aufwandschätzung bis zur Entwicklung dabei und stimmt sich laufend mit Frontend-Teams ab. Sein Rat: zuerst Programmier-Basics mit einfachen Skriptsprachen lernen, dann zu objektorientierten Konzepten (bei ihm von Visual Basic Script zu Java) übergehen und im Tun die eigene Richtung finden.

Vom Pascal in der Hauptschule zum Backend bei enjoy IT: Die Entwicklerreise von Thomas Hochgatterer

Warum diese DevStory zählt

In unserer DevJobs.at Reihe schauen wir hinter die Kulissen echter Entwicklerbiografien – ohne Buzzwords, ohne Mythen. In dieser Ausgabe begleitet uns „Thomas Hochgatterer, Back End Developer bei enjoy IT“ auf einer kompakten, aber lehrreichen Reise: vom Freifach „Programmieren“ in der Hauptschule über die HTL und ein Wirtschaftsinformatikstudium bis hin zum heutigen Alltag als Backend-Entwickler bei der enjoy IT GmbH. Gerade weil Thomas die Stationen schnörkellos beschreibt, wirkt seine Geschichte umso greifbarer: Schritt für Schritt, Sprache für Sprache, Projekt für Projekt.

Was uns beim Gespräch mit Speaker Thomas Hochgatterer besonders aufgefallen ist: Sein Weg ist ein Plädoyer für solides Fundament, Neugier und kontinuierliches Lernen. Es geht nicht um den einen „perfekten“ Start oder die eine „richtige“ Technologie, sondern um das Dranbleiben – vom ersten Pascal-Programm bis zur strukturierten Arbeit an Schnittstellen, Datenflüssen und der Zusammenarbeit im Team.

Erste Zeilen Code: Freifach, Neugier, Pascal

Thomas’ Einstieg klingt unspektakulär – genau dadurch ist er so wertvoll. Er erzählt, wie er in der Hauptschule ein Freifach wählte, ohne genau zu wissen, was ihn erwartet:

„Wir haben da so ein Freifach gehabt Programmieren. Da habe ich mich einfach einmal angemeldet. Ich habe eigentlich nicht gewusst, was da wirklich auf mich zukommt. … Ich glaube, wir haben damals mit Pascal begonnen. Da war ich ungefähr 14 Jahre.“

Pascal als Startpunkt ist nicht die oft zitierte „Hype“-Sprache unserer Zeit. Doch gerade das unterstreicht eine einfache Wahrheit: Die erste Sprache ist Mittel zum Zweck – sie macht Denkweisen und Grundprinzipien begreifbar. Wer in Pascal Variablen, Kontrollstrukturen und einfache Programme baut, legt die Basis für alles, was danach kommt. Thomas blieb neugierig – und machte weiter.

HTL als Fundament: EDV, Organisation und die Basics

Die Neugier führte Thomas an die HTL für EDV und Organisation. Dort wurde das Fundament breiter, praktischer – und zugleich methodischer. Besonders hängen blieb bei ihm der Einstieg mit einer Skriptsprache:

„Man probiert einfach, dass man mal die Basics lernt, generell vom Programmieren. … Ich würde da empfehlen, dass man mit irgendwelchen einfachen Script-Sprachen anfängt, wo man einfach nur gewisse Sachen Schritt für Schritt durchläuft. Bei mir war das eben Visual Basic Script am Anfang in der HTL.“

Diese Aussage ist entwaffnend pragmatisch. Anfänger brauchen keine komplexen Toolchains und Frameworks, sondern Wiederholung und Feedback – Schritt für Schritt. Skriptsprachen helfen, die Schleife aus Idee, Code und Ergebnis kurz zu halten. Für Thomas waren es Pascal und später Visual Basic Script – je nach Umfeld ein anderes Vehikel, aber immer mit dem gleichen Ziel: Konzepte greifen.

Studium: Wirtschaftsinformatik und erste Praxis als Webentwickler

Nach HTL und Schulprojekten suchte Thomas die nächste Stufe und begann ein Wirtschaftsinformatikstudium. Charakteristisch ist, dass er Theorie mit Praxis verband:

„Während des Studiums habe ich dann auch nebenbei schon ein bisschen Erfahrung gesammelt. Eben als Webentwickler. Dort habe ich auch teilweise Frontend-Geschichten gemacht.“

Dieser Zwischenschritt ist aus unserer Sicht zentral: Frühe Praxiserfahrung erdet das Gelernte. Wer Websites baut, lernt Zwänge kennen, die im Lehrbuch selten vorkommen – Browserkompatibilität, Datenfluss, Termine, Absprachen. Dass Thomas „teilweise Frontend-Geschichten“ machte, war keine Sackgasse, sondern eine Horizonterweiterung. Später, im Backend, zahlt sich dieses Verständnis für die Bedürfnisse des Frontends aus.

Der Weg ins Backend: Ankommen, weil es passt

Mit der Zeit schärfte sich Thomas’ Richtung: Backend.

„Ja, und irgendwie bin ich jetzt beim Backend gelandet und das taugt mir eigentlich recht.“

Das klingt bewusst unsensationell – und trifft dennoch ins Schwarze. In einem Feld mit „so vielen Möglichkeiten“ (wie Thomas es formuliert), gewinnt man Richtung oft nicht auf dem Papier, sondern über Erfahrungen. Wer Backend-Arbeit schätzt, interessiert sich für Daten, Integrationen, Schnittstellen, Robustheit und das Funktionieren im Hintergrund. Für Thomas ist das kein großer Paukenschlag, sondern ein organischer Übergang: von Scripting zu objektorientiertem Denken, von Webprojekten zu der Disziplin, die Daten nutzbar macht.

Was Backend für Thomas bedeutet: Daten, Schnittstellen, Verlässlichkeit

Thomas beschreibt sein Backend-Verständnis klar und konkret:

„Grundsätzlich als Backend-Programmierer schaut man, dass man irgendwie im Hintergrund Daten aufbereitet, Leuten die Möglichkeit schafft, dass man eben Daten manipuliert, dass man irgendwelche Schnittstellen anbindet und dass man die dann auch wieder einer Frontend zur Verfügung stellt oder auch irgendwelche Schnittstellen.“

Daraus lassen sich drei Kernaufgaben ableiten:

Daten aufbereiten: Informationen strukturieren, konsistent halten, aus unterschiedlichen Quellen zusammenführen.
Manipulation ermöglichen: Über gut definierte Funktionen und Endpunkte erlauben, Daten zu erstellen, zu ändern, zu löschen – sicher und nachvollziehbar.
Schnittstellen anbinden und bereitstellen: Systeme integrieren und das eigene System zugänglich machen, oft für Frontends oder andere Services.

Diese Beschreibung verzichtet bewusst auf technische Modebegriffe und rückt das Wesentliche in den Fokus: Backend schafft die Grundlage dafür, dass Anwendungen zuverlässig funktionieren – heute, morgen und in der nächsten Version.

Rolle im Projekt: Von der Aufwandsschätzung bis zur Abstimmung mit dem Frontend

Ein praktischer Aspekt, den Thomas betont, ist sein durchgängiger Projekteinsatz:

„Die Aufgabe, was ich einnehme, ich bin dann eigentlich von Anfang an beim Projekt dabei. Also ich beginne bei der Aufwandschätzung. Also wir überlegen dann gemeinsam, wie setzen wir das um? Wie lange brauchen wir dafür? Und dann geht es eigentlich schon direkt in die Entwicklungsphase, wo man eben Teil von einem Projektteam ist. … Wir haben dann laufend Abstimmungen, auch mit den Frontend-Entwicklern und so läuft eigentlich unser Alltag ab.“

Das macht zwei Dinge sichtbar:

Backend-Entwicklung beginnt nicht mit dem ersten Code, sondern mit dem Verständnis der Aufgabe, der Abschätzung von Komplexität und dem Bewerten von Optionen. Wer früh dabei ist, kann Risiken identifizieren, Prioritäten sortieren und Schnittstellen so gestalten, dass später nicht jeder Schritt ein Sonderfall wird.
Kontinuierliche Zusammenarbeit mit dem Frontend ist keine Option, sondern eine Grundbedingung. Anforderungen übersetzen sich in Schemas, Endpunkte, Fehlerszenarien. Wenn beides Hand in Hand geht, entsteht ein System, das nicht nur technisch, sondern auch fachlich funktioniert.

Lernpfad und Empfehlungen: Einfach anfangen, Schritt für Schritt, OOP dazulernen

Thomas’ Lernlinie zeigt ein nachvollziehbares Muster, das wir als Empfehlung an Einsteiger und Aufsteiger gleichermaßen lesen:

„Man probiert einfach, dass man mal die Basics lernt, generell vom Programmieren. … Ich würde da empfehlen, dass man mit irgendwelchen einfachen Script-Sprachen anfängt, wo man einfach nur gewisse Sachen Schritt für Schritt durchläuft. … Ich habe dann mit Java weitergemacht. Dort ist dann die Objektorientierung dazugekommen.“

Dahinter steht ein roter Faden:

Start mit einfachen Skriptsprachen: Kurze Feedbackschleifen, schnelle Erfolge, Fokus auf Logik statt auf Tooling-Hürden.
Übergang zu objektorientierten Konzepten: Sobald die Grundlagen sitzen, öffnet OOP die Tür zu größeren Strukturen – Klassen, Kapselung, Abstraktion, Wiederverwendung.
Praxis als Kompass: „Im laufenden Betrieb lernt man dann wirklich, in welche Richtung sollte es gehen. Es gibt so viele Möglichkeiten.“ Lernen ist kein linearer Plan, sondern ein Zusammenspiel aus Interesse, Gelegenheit und Feedback.

Was wir als DevJobs.at aus der Session mitnehmen

Aus der Session mit „Thomas Hochgatterer, Back End Developer bei enjoy IT“ bleiben uns vier Leitgedanken:

Aus Neugier wird Richtung: Ein Freifach genügt, um eine Spur zu legen. Wer dranbleibt, findet sein Spielfeld – in Thomas’ Fall das Backend.
Fundamente schlagen Features: Basics zuerst – Skripting und Schritt-für-Schritt-Denken, dann OOP. Mit dieser Basis lässt sich jedes neue Tool einordnen.
Backend ist Team- und Schnittstellenarbeit: Datenqualität, Integrationen und die Zusammenarbeit mit dem Frontend entscheiden, ob ein Produkt rund wirkt.
Früh in Projekte einsteigen: Aufwandsschätzung und gemeinsame Planung verhindern Sackgassen und schaffen Orientierung für alle Beteiligten.

Konkrete Handlungsempfehlungen für angehende Backend-Entwickler

Aus Thomas’ Erzählung lassen sich praxisnahe Schritte ableiten – ohne Abkürzungen, aber mit klarer Richtung:

Beginne bewusst klein: Wähle eine einfache Skriptsprache, die dir schnelle Ergebnisse liefert. Übe Schleifen, Bedingungen, Funktionen. Halte die Schleife „ändern–ausführen–verstehen“ kurz.
Baue Routine auf: Löse kleine Aufgaben wiederholt, variiere sie und erkläre dir selbst, was im Code passiert. Verstehe Fehler als Feedback, nicht als Rückschlag.
Lerne OOP anhand einer Sprache, die dir liegt: Thomas nennt Java als Station, in der „die Objektorientierung dazugekommen“ ist. Nutze Klassen und Objekte, um Alltagsprobleme zu modellieren.
Suche Praxis neben der Theorie: Ein Nebenjob oder kleine Webprojekte im Studium, so wie bei Thomas, verbinden Konzepte mit echten Anforderungen – besonders wertvoll, wenn du später mit Frontend-Teams zusammenarbeitest.
Trainiere Schnittstellen-Denken: Frage dich bei jeder Funktion: Welche Daten gehen hinein, welche kommen heraus, was darf schiefgehen? Dieses Denken bereitet dich auf die Backend-Praxis vor, in der Schnittstellen Dreh- und Angelpunkt sind.
Übe Zusammenarbeit: Plane von Beginn an die Kommunikation mit dem Frontend oder anderen Stakeholdern ein. Je früher die Abstimmung, desto weniger Missverständnisse im späteren Verlauf.
Schätze Aufwand – gemeinsam: Beteilige dich an Aufwandsschätzungen. Es schärft deinen Blick für Komplexität und hilft dem Team, realistische Ziele zu setzen.
Nimm dir die Freiheit, eine Richtung zu wählen: „Es gibt so viele Möglichkeiten.“ Wenn dich Datenflüsse, Integrationen und Zuverlässigkeit begeistern, kann Backend deine Heimat sein.

Die stille Faszination des Backend: Warum „im Hintergrund“ nicht unsichtbar ist

Thomas beschreibt Backend als Arbeit „im Hintergrund“. Genau hier liegt die stille Faszination: Wenn es gut gemacht ist, merken Nutzerinnen und Nutzer nichts davon – weil alles funktioniert. Daten sind da, Schnittstellen sprechen dieselbe Sprache, Systeme bleiben konsistent. Diese „Unsichtbarkeit“ ist keine Geringschätzung, sondern die höchste Form von Verlässlichkeit.

Es ist auch eine Haltung: Nicht die Oberfläche steht im Mittelpunkt, sondern die Substanz. Wer Daten aufbereitet, Manipulation ermöglicht und Schnittstellen anbietet, baut das Fundament für alles, was man erlebt – im Frontend, in Prozessen, in der täglichen Nutzung.

Zitate, die hängen bleiben

Einige Sätze von Thomas sind so prägnant, dass sie Orientierung geben:

„Wir haben damals mit Pascal begonnen. Da war ich ungefähr 14 Jahre.“

„Bei mir war das eben Visual Basic Script am Anfang in der HTL. … Ich habe dann mit Java weitergemacht. Dort ist dann die Objektorientierung dazugekommen.“

„Grundsätzlich als Backend-Programmierer schaut man, dass man irgendwie im Hintergrund Daten aufbereitet … Schnittstellen anbindet … und die dann auch wieder einer Frontend zur Verfügung stellt.“

„Ich beginne bei der Aufwandschätzung … Wir überlegen dann gemeinsam, wie setzen wir das um? Wie lange brauchen wir dafür?“

„Es gibt so viele Möglichkeiten und bei mir ist es einfach die Backend-Entwicklung dann geworden.“

„… und irgendwie bin ich jetzt beim Backend gelandet und das taugt mir eigentlich recht.“

Diese Zitate erzählen keinen „Shortcut“, sondern eine Entwicklung. Und sie machen Mut: Wer in Bewegung bleibt, schärft sein Profil – auch ohne Masterplan, dafür mit klarem Blick auf Grundlagen und Teamarbeit.

Fazit: Ein verlässlicher Weg – Schritt für Schritt zum Backend

Die DevStory von „Thomas Hochgatterer, Back End Developer bei enjoy IT“ ist kein Feuerwerk an technologischen Schlagwörtern. Sie ist ein glaubwürdiger Bauplan für eine nachhaltige Entwicklerkarriere:

früh anfangen und neugierig bleiben,
Basics über schnelle Effekte stellen,
Praxis mit Theorie verbinden,
die eigene Richtung finden und vertiefen,
Verantwortung im Projekt übernehmen – von der Schätzung bis zur Abstimmung.

Für uns von DevJobs.at ist das die Art von Weg, die trägt. Sie macht aus Code Qualität, aus Schnittstellen Verbindungen und aus Projekten Produkte, die funktionieren. Oder, um es mit Thomas’ Worten zu sagen: Man landet irgendwann dort, wo es „einem taugt“ – und genau dort wird man wertvoll für sein Team.

Weitere Dev Stories