Project Focus over Silos: How Philipp Jahoda (CTO, Ahoi Kapptn!) leads a 10–11 person dev team, hires well, and stays technologically current

Our take on “Philipp Jahoda, CTO von AhoiKapptn!”

What makes a small, all-engineering team both efficient and appealing to tech talent? In the session “Philipp Jahoda, CTO von AhoiKapptn!”, we at DevJobs.at heard a crisp, practice-first answer. Philipp Jahoda outlines Ahoi Kapptn!’s current setup—ten to eleven people, all developers—and explains why the company organizes around projects, how it is standardizing its hiring process, and which technology choices anchor day-to-day delivery.

The short version: instead of creating early silos (Backend, Web, Mobile), Ahoi Kapptn! operates in project-based pods, limits how many projects each person touches, and thereby reduces context switching. The hiring pipeline is straightforward, featuring a coding challenge via an internal tool, a team review of results, and a conversation focused on personal fit. The stack leans on proven technologies (Spring, MongoDB) while remaining open to cross-platform options such as React Native or Flutter when budgets require it. For engineers who value ownership, focus, and learning, this is a compelling mix.

Project-first instead of function-first: how a pure dev team organizes

Ahoi Kapptn! currently runs a compact engineering team—“all developers,” ten to eleven in total. From that, the organizational model follows. Rather than forming formal function teams—like a dedicated “Backend Team,” “Mobile Team,” or “Web Team”—Philipp says they are “very project-specific” right now. At the current size, “it doesn’t make a lot of sense” to split into permanent function silos.

• Projects are the organizing unit: A typical project brings together a backend developer, an app developer, and a web developer—exactly what’s needed if the deliverable spans app and website.
• Small, focused staffing: Individuals are deliberately assigned to as few concurrent initiatives as possible.
• Role mix follows demand: The skill set in each project reflects the actual requirements, avoiding handover-heavy patterns between isolated function teams.

This setup unlocks ownership. If you work inside the project, you operate near the requirements and can make decisions without bouncing across internal boundaries. Communication remains tight, and context is shared where it matters: in the project team.

Context switching is real overhead—Ahoi Kapptn! minimizes it by design

Philipp emphasizes the “overhead” of “switching between two projects.” To counter this, Ahoi Kapptn! watches closely that “individuals are involved in as few projects as possible.”

This is a mature take on engineering time: the scarcest resource in software is focused attention. Minimizing context changes increases signal-to-noise and converts hours into working solutions. For engineers, the promise is less thrash and more deep work.

What this means day-to-day

• Longer flow windows: Staying in one problem space helps you acquire domain understanding faster and make better calls.
• Fewer handoffs: Decisions remain near the people with full context; less duplication and fewer progress resets.
• Higher quality: End-to-end responsibility across backend, web, and app within a project drives coherence and polish.

Hiring at Ahoi Kapptn!: channels, process, expectations

Ahoi Kapptn! is actively building a standardized hiring process. The sourcing mix is explicit: job platforms like DevJobs.at and LinkedIn, plus outreach through personal channels (people they know). The pipeline itself is pragmatic and transparent.

The steps in short:

1. Application intake and initial review

• Applications “typically land” on Philipp Jahoda’s desk first. He evaluates “how the person presents themselves” and matches skills “to our requirements.”
• This is a short, careful filter for relevance and baseline fit.

1. Coding challenge via an internal tool

• If the skills align, candidates receive a “small coding challenge.” An internal tool delivers instructions; candidates implement the task and submit results.
• Submissions go back to Philipp and are “usually reviewed by the team.” That point matters—quality assessment is a shared view, not a single gate.

1. Conversation focused on personal fit

• If the challenge is “satisfactory,” the candidate is invited to an interview that emphasizes personal match: “Does the person fit the team?” and “will they enrich the working climate?”
• With both capability and collaboration aligned, the final step is an offer.

This pipeline signals a fair split between demonstrable technical competence and cultural compatibility. For candidates, it’s clear what matters: good code and good collaboration.

What candidates can prepare for

• Sharpen your presentation: The first screen looks closely at how you present and how your skills align. A concise, relevant profile makes a difference.
• Let your code do the talking: The coding challenge is central. Clean design, readability, and solution-oriented thinking are the best calling cards.
• Emphasize collaboration: The interview probes whether you’ll “enrich the working climate.” Constructive communication and a team-first approach are key.

The engineering stack: proven defaults, pragmatic flexibility

Ahoi Kapptn! leans on technologies it has used “for a longer period”—with the caveat that “in tech, several years is already long.” On the backend, the team “mainly” uses Spring. For databases, the choice is “requirement-specific,” though “mostly MongoDB.” On mobile, the default recommendation is native development: separate iOS and Android apps.

Budgets, however, matter. When native isn’t feasible, the team adopts “the more cost-effective” approach: cross-platform via React Native or Flutter.

• Backend: Primary reliance on Spring, adapted to customer requirements.
• Databases: Often MongoDB, with the actual choice driven by the problem.
• Mobile: Preference for native iOS and Android; React Native or Flutter when budget constraints make cross-platform the practical path.

This is a grounded stance: choose robust defaults that have proven durable, and reserve flexibility for situations where constraints or requirements call for it.

Staying current is the core challenge—and the cultural backbone

Philipp names the major challenge plainly: “It’s important that we always stay on the ball technologically.” In practice, that breaks down into two loops:

1. Evolving what you already use: “How are the technologies we use developing? Are they still up to date?”
2. Evaluating what’s new: “What’s new out there, and how can we use it?”

This two-speed mindset—keep existing tools fresh, scan for valuable additions—fits the project-first organization. Working close to customer needs makes it obvious when a tool stops pulling its weight. Conversely, you adopt new tech where it solves a real problem.

A learning loop embedded in delivery

While the session doesn’t outline formal programs, it implies a learning culture you can feel:

• Continuous relevance checks: Tools used “for a longer period” are regularly assessed for currency and suitability.
• Context-aware adoption: Changes in requirements or constraints (e.g., budget) trigger appropriate alternatives like React Native or Flutter on mobile.
• Team-based assessment: Even the hiring challenge results are “reviewed by the team,” reflecting a habit of shared evaluation.

For engineers, that’s the sweet spot: established fundamentals, plus permission to integrate new solutions where they clearly fit.

Collaboration inside projects: end-to-end responsibility

Because the team organizes around projects, collaboration runs across backend, web, and mobile inside a concrete outcome. Philipp’s example—a project staffed with a backend developer, an app developer, and a web developer—shows how responsibilities align with the product edge.

• End-to-end thinking: Decisions are made near where their impact is immediate—inside the project.
• Shared quality control: The habit of team reviews in hiring mirrors the collaborative approach likely seen in delivery: artifacts and decisions benefit from multiple eyes.
• Clearer information flow: Instead of handoffs between isolated departments, project teams coordinate directly.

In short, work happens where context lives. That supports quality, speed, and developer satisfaction.

Why Ahoi Kapptn! is attractive to tech talent

From the session, several compelling points emerge for engineers considering Ahoi Kapptn!:

• Focus over fragmentation: Involvement in “as few projects as possible” preserves deep work and accelerates progress.
• Ownership near the outcome: Project teams decide in context—fewer cross-department bottlenecks, more autonomy.
• Fair, transparent hiring: A real coding challenge, a team review, and an interview that values personal fit.
• Pragmatic stack: Spring and MongoDB as solid anchors; native mobile by default, with pragmatic use of React Native or Flutter where budgets require.
• Continuous currency: An explicit commitment to “staying on the ball technologically.”
• Short paths to leadership: In a ten-to-eleven-person all-dev team, your application “typically” reaches the CTO—feedback loops are tight.

For many engineers, that combination—focus, responsibility, and learning—defines a high-quality workplace.

A note for applicants: how to align yourself

• Clarify your profile: Show relevant experience and concrete outcomes in a way that’s easy to match to requirements.
• Bring your best code: The challenge is your canvas. Favor clarity, testability, and thoughtful trade-offs.
• Demonstrate stack fluency: Experience with Spring, document databases (like MongoDB), and mobile development (native or cross-platform) aligns well—depending on the role.
• Show collaborative strength: Project-based teams thrive on communication. Be ready to discuss how you solicit feedback and make decisions transparent.
• Prove your learning habit: “Staying current” means mastering the old while onboarding the new judiciously. Prepare examples.

One-line summary of the engineering culture: effective, focused, learning-driven

From “Philipp Jahoda, CTO von AhoiKapptn!”, Ahoi Kapptn! comes across as engineering-first: project teams instead of premature function silos, focus instead of constant task switching, a fair hiring loop with real team involvement, and a tech posture that respects what works while evaluating what’s next.

That principle scales: it’s how small teams deliver big outcomes. If you’re the kind of engineer who prefers pragmatism over dogma and ownership over bureaucracy, this environment will feel like home.

Conclusion: a setup that converts focus into quality

• Project-based teams reduce coordination overhead and speed up delivery.
• The hiring process is transparent, collaborative, and grounded in real work.
• The stack balances stability (Spring, MongoDB, native mobile) with pragmatic options (React Native, Flutter) when budgets call for it.
• Staying current is both challenge and engine for growth.

“Philipp Jahoda, CTO von AhoiKapptn!” shows Ahoi Kapptn!’s brand of tech leadership: create the conditions for focused work and let good software follow. For engineers, that’s an invitation to do your best work—close to the problem, alongside a team that values both craft and collaboration.

• 

  

  App Clips

  Philipp Jahoda von Ahoi Kapptn! präsentiert in seinem devjobs.at TechTalk die Grundidee der iOS App Clips und gibt ein Beispiel einer Implimentierung.

  Watch now
• 

  

  UI/UX

  Philipp Baldauf von Ahoi Kapptn! erläutert in seinem devjobs.at TechTalk die Herangehensweise des Unternehmens an die Themen UI und UX.

  Watch now