Inside dectria’s Engineering: Communication, Ownership, and a Full‑Stack TypeScript Culture — Insights from “Michael Jauk, Co-Founder von dectria”

Context and key takeaways from the session

In the session “Michael Jauk, Co-Founder von dectria,” Michael outlined how a compact, cross‑functional team can deliver impact through clear principles: open, direct communication and true ownership. Dectria has been around for just over two years. The group consists of roughly ten people, with five consistently in engineering at dectria. Despite the small size, the team covers the full product spectrum — frontend and backend, architecture, DevOps, mobile, cloud infrastructure, and design.

Two cultural pillars run through everything Michael described: communication at eye level and ownership. This is paired with a pragmatic process stance between Scrum and Kanban (“Scrumban”), an intentionally chosen end‑to‑end JavaScript/TypeScript stack, and a technology posture of API‑first, Cloud‑first, and Open‑Source‑first. For candidates, the recruitment journey is short, respectful, and free from artificial hurdles like LeetCode‑style drills. Onboarding is fast, anchored in a buddy system and “learning by doing.”

Below is our DevJobs.at editorial recap of what engineers and tech talent can learn from the session.

A small, capable team — fully cross‑functional

Dectria is “small but fine,” and the setup is designed accordingly. Around ten people in the group, five consistently in engineering — with the ability to deliver end‑to‑end:

• Frontend and backend
• Architecture and DevOps
• Mobile (React Native, with Flutter depending on the use case)
• Cloud infrastructure
• Design

This breadth enables holistic product development. For talent, that means high visibility, short feedback loops, and opportunities to work at the intersections of disciplines. If you like taking responsibility in a setup where your work has immediate impact, this environment supports it.

Ways of working: Scrumban without dogma

Michael frames the process as deliberately flexible — “somewhere between Scrum and Kanban.” The project context determines the level of structure:

• Larger projects: processes are “a bit stricter.”
• Smaller projects: processes are “looser,” with more decision space for developers.

This Scrumban approach achieves efficiency without unnecessary overhead, while keeping enough structure for quality and predictability. The team is empowered to make operational decisions where the most context lives — with the people doing the work.

DNA: communication and ownership

Two themes recur throughout: communication and ownership. These aren’t slogans — they are practiced daily.

Open, direct, eye‑level communication

• Internally and with customers, the norm is “open, direct communication on eye level.”
• The goal: everyone is “on the same page” about the why and the how.
• Developers are “enabled” to make decisions themselves.

The outcome is a shared understanding with fewer friction losses and a strong sense of responsibility. At dectria, you’re not just informed — you’re expected to shape.

Ownership as default — pride in work and results

• Ownership is core: “We are proud of the things we do.”
• That spans from software craftsmanship to “very small things in communication.”

Michael connects this to the Boy Scout rule:

Applied to source code, that means quality, clarity, and performance — without over‑engineering. The team emphasizes “good, beautiful, performant, but not over‑engineered solutions.”

Stack choices: full‑stack JavaScript/TypeScript, API‑first, Cloud‑first, Open‑Source‑first

Over the past years, dectria has converged on a consistent stack — with pragmatic flexibility for use cases.

Frontend, mobile, backend — end‑to‑end JS/TS

• Frontend: React and Next.js
• Mobile: primarily React Native; Flutter depending on the use case
• Backend: Node.js with Nest.js (with Express or Fastify)

Dectria deliberately runs a full‑stack JavaScript/TypeScript approach. Michael cites two benefits: simplicity and market breadth. There is “a large market” of technologies and solutions — and “many thousands of companies” using the same tools. This makes maintenance, knowledge transfer, and onboarding easier.

API‑first, Cloud‑first, Open‑Source‑first

• API‑first as the architectural stance.
• Cloud‑first for the “many flexibilities” that on‑premise setups don’t offer.
• Open‑Source‑first for flexibility and the support that open‑source projects bring — contrasted with proprietary stacks.

At the same time, Michael argues for balance. Software is fast‑moving; hype is tempting. Dectria looks for the “golden middle ground”: quickly adopt trends that make sense, while preserving long‑term maintainability. With JavaScript/TypeScript, they’ve found that balance — the ability to “act very quickly,” while still “guaranteeing long‑term maintenance.”

Recruiting: fast, respectful, and no LeetCode

The hiring process has two core steps — intentionally lean, focusing on culture and capability demonstrated through conversation:

1. Initial get‑to‑know meeting (agenda‑free):

• After an application (for an open role or unsolicited), there is a casual first conversation.
• Topics: mutual sympathy, mindset, culture fit, plus a high‑level review of past roles and qualifications.
• “No agenda, unstructured” — the goal is a shared feel: does it fit personally and in mindset?

1. Technical interview (no preparation required):

• Typically scheduled the following week.
• “No LeetCode” and no whiteboard drills.
• An informal discussion of foundational technical questions that can be answered “off the cuff.”
• The colleagues who would later work with the candidate are present.

Afterwards, the team aligns internally: Does it fit culturally and technically? Would the person be a gain for the “small but fine” team? If yes, the employment formalities and offer are handled — “and then it moves relatively quickly to the first day of work.”

Onboarding: buddy system and learning by doing

The start is pragmatic and close to real work:

• Day one: meet the team, handle formalities, set up the laptop and development environment.
• Very soon: join a live project to learn the working model — commits, process flow, and refinements.
• Buddy principle: a primary point of contact for questions — from feature context to everyday topics like lunch or home office.

Regular one‑on‑ones round this out — more frequent at the beginning, then tapering off. The goal is a two‑way check‑in: what worked well, where to “improve a bit,” and how the mutual fit is evolving.

What matters: soft skills, mindset, joy in the work

Michael is explicit: beyond hard skills, soft skills and mindset are decisive. In his words, “programming can always be learned.” Since ownership and communication are dectria’s leading values, the team pays particular attention to:

• Communication strength and interpersonal fit
• Work style and readiness to take responsibility (ownership)
• Joy in what you do, paired with a high quality bar

This combination shapes the culture — and it’s central in hiring.

Growth: decision freedom and development — with budget

Engineers at dectria should actively shape where they grow. Michael highlights:

• Decision freedom: “Where do they want to develop? What do they want to do? What do they not want to do?”
• A yearly, free‑to‑use budget per employee, which can be spent “on what they want” — in support of learning and development.

This signals trust and encourages self‑direction. For talent keen to steer their own focus, that’s a clear positive.

Collaboration: clarity, responsibility, pragmatism

Taken together, Michael’s points add up to a coherent model of daily collaboration:

• Context‑driven processes instead of dogma (Scrumban)
• Clear communication and transparency about the “why”
• Short paths in a small, cross‑functional team
• Fast onboarding into real projects
• Buddy support plus regular 1:1 reflection
• Quality focus without over‑engineering (Boy Scout rule)

For engineers, this means influence from day one — with support and clear guardrails.

Why dectria is attractive for tech talent

From an employer‑branding and engineering perspective, several concrete aspects stand out:

• Meaningful responsibility: ownership is practiced, not postered.
• On‑the‑job learning: quick immersion into projects, supported by a buddy and 1:1s.
• Modern, consistent toolchain: full‑stack JavaScript/TypeScript with React/Next.js, React Native/Flutter (use‑case‑driven), Node.js/Nest.js (Express/Fastify), API‑first.
• Process with judgment: Scrumban instead of rigid ceremony; tighter when needed, looser when helpful.
• Culture of openness: direct, eye‑level communication; everyone “on the same page.”
• Quality ethos: the Boy Scout rule in code — “leave it cleaner than you found it” — without over‑engineering.
• Cloud‑first and open‑source‑first: flexibility and community‑backed support.
• Lean hiring: fast, respectful, without artificial barriers.
• Space to grow: a yearly personal budget and real say in one’s trajectory.

For people who value impact, clarity, and responsibility, this combination is compelling.

Our DevJobs.at takeaway

The session “Michael Jauk, Co-Founder von dectria” shows how to build a capable engineering team at small scale through coherent choices:

• Principles before practices: communication and ownership as the north star.
• Process as a tool: Scrumban tuned to the project’s needs.
• Focus over flavor‑of‑the‑month: a consistent JS/TS stack, API‑first, Cloud‑ and Open‑Source‑first, with a sober view on hype.
• People over checklists: culture fit, soft skills, and joy in the work carry real weight — “programming can always be learned.”
• Onboarding that sticks: buddy system, learning by doing, early 1:1s — with two‑way feedback.

It’s a clear employer story: no buzzword bingo, just integrated decisions from stack to hiring.

Quotes and lines that stick

A few lines capture the culture and way of working:

Conclusion

Dectria demonstrates how much a small team can accomplish when culture, process, and technology align. Communication and ownership set the direction; Scrumban, a buddy‑based onboarding, and regular 1:1s translate that into daily practice. The end‑to‑end JavaScript/TypeScript stack — with React/Next.js, React Native/Flutter, Node.js/Nest.js, plus API‑first, Cloud‑first, and Open‑Source‑first — enables speed without sacrificing maintainability.

For tech talent who want to tie joy in their craft to responsibility and quality, this setup offers precisely that — “small but fine,” with real room to shape and clear guiding principles.

• 

  

  We love our Techstack

  Marc Kornberger von dectria erklärt in seinem devjobs.at TechTalk, welche Hintergedanken das Dev Team beim Festlegen des Techstacks hatte.

  Watch now