Role Overview:

You're joining the Tool Module & Foundation cluster, the value stream that builds the capability backbone of our platform. Here you'll own new agent tools, core API endpoints, and foundational system work while paired closely with senior engineers. This cluster directly feeds the LLM/Agent Core and Microsoft Integrations teams, your solid module work is what lets them build on clean, tested foundations. As you grow, you'll move into higher-complexity streams, retrieval and RAG, document processing, and multi-tenant data patterns. This is a stream where learning fast and shipping real code are the same thing.

Key Responsibilities:

  • Build and extend tool modules, new capabilities for the agents, following our established module patterns.

  • Add API endpoints, write tests, fix bugs, and improve logging across the platform.

  • Work on document processing (PDF and Office formats), the web chat widget, and admin screens.

  • Pair with senior engineers on migrations, multi-tenant data, and our message-processing loop, until you own them yourself.

Tech Stack:

Python, Django (with DRF), PostgreSQL, Docker, and Git, plus the major LLM APIs (OpenAI, Azure OpenAI, Anthropic). A bit of front end: Alpine.js, Tailwind, vanilla JS.

Required Qualifications:

  • Solid Python fundamentals and a genuine interest in clean, tested code.

  • Some Django experience, or strong general programming skills and a track record of learning fast.

  • Comfortable with REST APIs and basic SQL.

  • Clear written communication, you ask good questions and flag blockers early.

  • Real curiosity about LLMs and AI agents, side projects, experiments, anything hands-on counts.

Nice to Have:

  • Django REST Framework, any OpenAI or LLM API tinkering, Docker basics, or front-end work (JS, HTML, CSS).

  • Exposure to Microsoft Graph or OAuth, web scraping, or document parsing.

Ways of Working:

  • We design in code, not documents. You'll open a PR early, even if it's a work in progress, and iterate with feedback rather than waiting for a perfect design.

  • When you're blocked or uncertain, you pair, synchronously with whoever's nearby. Slack doesn't replace sitting together on a hard problem.

  • You own what you ship. If your code breaks in production, you fix it. You write runbooks and clear commit messages because you respect the next person reading them.

  • Questions are expected. Ask them early, ask them often. "I don't know" is a stronger signal than pretending.

  • You move from well-scoped corners to harder work at your own pace. No arbitrary junior-task queue. Once you're solid on module patterns, you pick your next challenge.

Who You Are:

In terms of your work:

  • Proactive and self-starting, you pick up tickets, dig in, and don't wait to be told what's next.

  • You take ownership of what you ship and care that it actually works in production.

  • You're hungry to learn and comfortable being the most junior person in the room, for now.

Decision-making and communication:

  • Within your module cluster, you can make technical choices, language features, library picks, API design, without approval, your senior will review in code review.

  • If your change touches another cluster, database schema changes that affect integrations for example, you raise it early, in a PR comment or a quick sync, not after it's written.

  • You communicate blockers and uncertainties immediately, not when deadlines are near.

What We Offer:

  • Wellpass, access to thousands of gyms, pools and studios across Germany.

  • Modern hardware and hybrid working.

  • A small team where your work is visible and your growth is fast.

Equal Opportunity Statement:

We make hiring decisions on qualification and fit alone. We welcome applications regardless of gender, age, origin, religion, disability or sexual identity.

DEUTSCH

Warum diese Rolle existiert:

Du kommst in den Cluster Tool Module & Foundation, den Wertstrom, der das Fähigkeiten-Fundament unserer Plattform baut. Hier übernimmst du neue Agent-Tools, zentrale API-Endpunkte und grundlegende Systemarbeit, eng begleitet von erfahrenen Entwickler:innen. Dieser Cluster liefert direkt an die Teams LLM/Agent Core und Microsoft-Integrationen, deine solide Modularbeit ist das Fundament, auf dem sie aufbauen. Mit der Zeit wächst du in komplexere Bereiche, Retrieval und RAG, Dokumentenverarbeitung und Multi-Tenant-Datenmuster. In diesem Bereich sind schnelles Lernen und echtes, produktives Coden dasselbe.

Was du übernimmst:

  • Baue und erweitere Tool-Module, neue Fähigkeiten für die Agenten, nach unseren etablierten Modul-Mustern.

  • Ergänze API-Endpunkte, schreibe Tests, behebe Bugs und verbessere das Logging über die Plattform hinweg.

  • Arbeite an der Dokumentenverarbeitung (PDF und Office-Formate), am Web-Chat-Widget und an Admin-Oberflächen.

  • Arbeite eng mit erfahrenen Entwickler:innen an Migrationen, Multi-Tenant-Daten und unserer Message-Processing-Loop, bis du sie selbst verantwortest.

Tech-Stack:

Python, Django (mit DRF), PostgreSQL, Docker und Git, plus die wichtigsten LLM-APIs (OpenAI, Azure OpenAI, Anthropic). Etwas Frontend: Alpine.js, Tailwind, reines JavaScript.

Must-have:

  • Solide Python-Grundlagen und echtes Interesse an sauberem, getestetem Code.

  • Etwas Django-Erfahrung, oder starke allgemeine Programmierfähigkeiten und die nachweisbare Fähigkeit, dich schnell einzuarbeiten.

  • Sicher im Umgang mit REST-APIs und grundlegendem SQL.

  • Klare schriftliche Kommunikation, du stellst gute Fragen und meldest Blocker früh.

  • Echte Neugier für LLMs und KI-Agenten, Nebenprojekte, Experimente, alles Praktische zählt.

Nice-to-have:

  • Django REST Framework, jegliches Herumprobieren mit OpenAI- oder LLM-APIs, Docker-Grundlagen oder Frontend-Arbeit (JS, HTML, CSS).

  • Erfahrung mit Microsoft Graph oder OAuth, Web-Scraping oder Dokumentenverarbeitung.

Wie wir arbeiten:

  • Wir gestalten in Code, nicht in Dokumenten. Du eröffnest früh einen PR, auch wenn er noch nicht fertig ist, und iterierst mit Feedback, statt auf ein perfektes Konzept zu warten.

  • Wenn du blockiert oder unsicher bist, paarst du dich, synchron mit wem auch immer gerade da ist. Slack ersetzt nicht das gemeinsame Ringen mit einem schwierigen Problem.

  • Du verantwortest, was du lieferst. Bricht dein Code in der Produktion, behebst du es. Du schreibst Runbooks und klare Commit-Messages, weil du die nächste Person respektierst, die sie liest.

  • Fragen sind erwünscht. Stell sie früh, stell sie oft. „Ich weiß es nicht" ist ein stärkeres Signal als so zu tun, als wüsstest du es.

  • Du bewegst dich von klar abgegrenzten Aufgaben zu schwierigerer Arbeit, in deinem eigenen Tempo. Keine willkürliche Junior-Aufgabenliste. Sobald du die Modul-Muster beherrschst, wählst du deine nächste Herausforderung.

Wer du bist:

In Bezug auf deine Arbeit:

  • Proaktiv und selbststartend, du greifst Tickets auf, gehst rein und wartest nicht darauf, dass man dir sagt, was als Nächstes kommt.

  • Du übernimmst Verantwortung für das, was du lieferst, und dir ist wichtig, dass es in der Produktion tatsächlich funktioniert.

  • Du willst lernen und bist bereit, vorerst die am wenigsten erfahrene Person im Raum zu sein.

Entscheidung und Kommunikation:

  • Innerhalb deines Modul-Clusters triffst du technische Entscheidungen, Sprachfeatures, Bibliothekswahl, API-Design, ohne Freigabe, dein:e Senior reviewt in der Code-Review.

  • Betrifft deine Änderung einen anderen Cluster, zum Beispiel Datenbankschema-Änderungen, die Integrationen betreffen, meldest du das früh, in einem PR-Kommentar oder einem kurzen Sync, nicht nachdem es schon geschrieben ist.

  • Du kommunizierst Blocker und Unsicherheiten sofort, nicht erst kurz vor der Deadline.

Was wir bieten:

  • Wellpass, Zugang zu tausenden Fitnessstudios, Schwimmbädern und Studios in ganz Deutschland.

  • Moderne Hardware und hybrides Arbeiten.

  • Ein kleines Team, in dem deine Arbeit sichtbar ist und du schnell wächst.

Zurück