Inside Txture Engineering: Scrum, TypeScript, Kotlin, and Team Harmony — A Deep Dive with Christian Esswein, Senior Full Stack Developer at Txture

Introduction: Building real products with focus, freedom, and clarity

In this techleadstory, our conversation with “Christian Esswein, Senior Full Stack Developer at Txture” delivers an unusually clear picture of how a modern product team operates. Txture is a tool vendor with its own products — delivered as a SaaS application and, when needed, deployed on-premises at customers. Users access the software via a web frontend. What stood out to us: a compact, effective engineering team that prioritizes technical excellence, open communication, and flexible collaboration — while running a serious, multifaceted software stack.

From work organization (Scrum, daily stand-ups, sub-tasking) and a straightforward, respectful hiring experience to a robust engineering foundation (React with TypeScript, CraftQL, Kotlin/Java with Spring, Docker/Kubernetes, extensive unit testing, and an in-house graph database with versioning), Christian offered a concise yet dense tour of engineering at Txture. The takeaway is simple: this is product development where every contribution matters.

Team structure: 8–9 engineers, clear strengths, shared architecture work

“We’re currently eight in the dev team — depending on how you count, nine,” says Christian. The team is intentionally split by personal preference and expertise: some focus on the frontend, others mainly on the backend. What’s key is how new features are tackled together:

• The group meets to define architecture: How should the feature be structured? Where is data needed? How will it be provided?
• The work is then broken down into smaller sub-tasks and distributed across the team.

This blend of specialization and shared responsibility ensures architecture isn’t created in a silo, but owned by the team. At the same time, tasks remain well-scoped and deliverable.

Work organization: Scrum for focus and transparency — across office and remote

Txture follows Scrum for overall communication and structure. That creates predictability and makes progress visible — especially important because “two of us work primarily remote, the rest are in the Innsbruck office.” Scrum helps the team keep its focus, stay clear on who is doing what, and understand when specific features can be expected to ship.

• Daily stand-up: The day usually starts with a quick stand-up. Everyone shares what they’re working on, what’s next, and where friction might be.
• Early issue detection: By syncing daily, issues surface early. The team can then create small ad-hoc groups to tackle and resolve problems.

It’s a pragmatic, structured way of working that makes hybrid collaboration reliable. Transparency replaces guesswork — and accelerates delivery.

Flexibility in practice: Work when it fits — as long as it fits together

Beyond fixed meetings, time management is “relatively flexible.” In Innsbruck that also means: take advantage of the snow in the morning or go mountain biking in the summer — and then start your workday. The message is clear: Txture takes individual rhythms seriously. What matters is accountability, alignment, and results. That creates real freedom without disrupting the team cadence.

Culture and expectations: Technical strength, team harmony, and clear communication

Christian is direct about expectations: “Technical competence has to be there. Without it, nothing works.” Equally important: “team harmony has to fit.” In a young, motivated company — “we’re 18 people in total now” — you spend a lot of time together. That leads to a few cultural constants:

• Work should be fun — without joy, productivity suffers.
• Communication is essential. Candidates should be open, ask for help, and bring in their ideas.
• Initiative matters: As a tool vendor with its own product(s), it’s “nice and very important” that everyone helps create the product. Txture offers a lot of freedom in how and where you contribute — in return, you’re expected to think your way in and show initiative.

In short, this is a culture of responsibility, collegiality, and product focus. If you only want to “close tickets,” this might not be your place. If you want to shape the product, it very well could be.

Hiring focus: Frontend and full-stack — technology-open, product-oriented

Longer term, Txture is looking for support “in almost all areas.” Right now, the emphasis is on frontend and full-stack profiles.

• Frontend: React and TypeScript are the foundation; styling uses Styled Components or Emotion. Importantly, there’s technology openness. If you come from Angular or Vue.js and are willing to learn, you’re welcome.
• Full-stack: On the backend side, Christian highlights “CraftQL with TypeScript, Node.js with Mongo databases behind it.” It’s a space that rewards interface thinking, data flows, and coherent services.

The message is clear: learning mindset, care, and product understanding matter more than specific frameworks.

Application process: Lean, respectful, and practical

The path into the team is intentionally simple. “Just contact us via our website text.io.” The process has three steps:

1. Short phone call: An initial get-to-know-you to align expectations — on both sides. It saves time if the fit isn’t there.
2. Next round to get to know each other: The goal is to see if it harmonizes and fits.
3. Technical interview: In the dev track, you’ll walk through a code example together — typically a component with a few deliberately placed small bugs. Together you discuss: What’s good? What should be improved? The focus is on working together on code.

Txture hires for the Innsbruck office and is “also open to remote positions.” Reach out — and see “what comes together.”

Product, architecture, and codebase: SaaS, on-prem, web frontend — and substantial scale

Txture ships its software as a SaaS, offers on-prem deployments when needed, and provides a web frontend. From an engineering perspective, the frontend codebase is substantial: “around 250,000 lines of code on the frontend alone.”

• Why TypeScript? “It helps during development so a developer knows in advance whether the code they’re building will work, gets solid auto-complete, and benefits from static checks.” At this scale, strong typing isn’t a nice-to-have — it’s a productivity and quality lever.
• Mid-layer: “We’re increasingly using CraftQL in the mid-layer.” The goal is to ensure — during development — that communication between server and client parts works, and that “we only load the data we actually need.”

Together, TypeScript and CraftQL create reliable contracts between frontend and backend — fewer runtime surprises, more predictability.

Backend stack: Kotlin/Java with Spring, microservices, Node.js

The server application is “written in Kotlin, partly still in Java, using the Spring Framework.” There are also microservices, “largely in Kotlin, partly in Node.js.” On quality, Christian mentions “over 2,500 unit tests” — a strong signal of serious test coverage. Overall, it’s a modern JVM-centric environment with pragmatic use of Node.js where it makes sense.

Deployment and operations: Docker, Kubernetes, reproducible states

For deployments, Txture has “for some time now been using almost exclusively Docker,” with “quite a lot deployed to our Kubernetes cluster.” That pays off in two ways:

• Dynamic scaling: Systems grow with their load.
• Reproducibility: It “helps us to reproduce any state locally to identify and debug issues.” For developers, that means realistic environments are easy to spin up and bugs can be traced precisely.

This is more than an ops detail — it’s a team-wide productivity boost.

Storage: SQLite, MongoDB — and a custom graph database with versioning

On the storage layer, Txture uses “SQLite and MongoDB,” and also mentions “a self-written graph database with versioning.” That’s notable: you don’t build your own graph DB as a side project. It points to specific requirements and the capability to develop fit-for-purpose infrastructure. For engineers, this implies working with challenging data models where consistency, history, and query performance intersect.

Quality in practice: Typing, tests, and collaborative reviews

The elements Christian describes add up to a clear quality posture:

• Strong typing on the frontend (TypeScript) for early error prevention and better developer ergonomics (auto-complete, static checks).
• Contract clarity between client and server via CraftQL — only the data that’s needed.
• 2,500+ unit tests on the server side — a meaningful automated safety net.
• Collaborative code walkthroughs in the technical interview mirror everyday practice: code is a team sport.

If you value building things well, the structures here help you do exactly that — without unnecessary bureaucracy.

Collaboration: Small, focused groups for hard problems

Christian describes a culture where issues are surfaced early and addressed in small groups. The daily stand-up acts as radar — then ad-hoc taskforces form to investigate and resolve. The result: short feedback loops and minimal idle time. Especially in a hybrid setup (two remote, the rest in-office), this is the difference between “parallel solo development” and true collaboration.

Responsibility and initiative: Co-creating the product instead of just closing tickets

As a tool vendor with its own product(s), Txture relies on people who think beyond the code. “We offer a lot of freedom in how and where you can contribute,” says Christian. In return, they expect you to “think your way in… and show a bit of initiative.”

This isn’t marketing talk; it’s a consequence of being a product company. If you build features, you shape the product. If that’s what you want, Txture offers the stage.

Why Txture is attractive for tech talent

From this session with “Christian Esswein, Senior Full Stack Developer at Txture,” a few strong reasons emerge:

• Product impact: Work on owned products with real users and clear roadmaps — you’re evolving something that matters.
• Solid engineering foundation: TypeScript in a sizable frontend, CraftQL for clear interfaces, Kotlin/Java with Spring on the backend, a meaningful unit test base, Docker/Kubernetes for reproducible environments.
• Challenging data models: The combination of MongoDB, SQLite, and a custom graph database with versioning.
• Structured collaboration: Scrum, daily stand-ups, sub-tasking — plus small-group problem solving for speed.
• Flexibility with accountability: Freedom around fixed meetings; room for personal routines and the Innsbruck outdoor lifestyle.
• Culture of openness: Communication, team harmony, and fun at work — because without that, as Christian says, productivity “simply suffers.”
• Fair hiring process: Lean, respectful, and practical — with options for both Innsbruck office and remote.
• Technology openness: React/TypeScript at the core, but Angular/Vue.js backgrounds welcome — as long as you’re eager to learn and product-minded.

What we learned from the session

From our time with “Christian Esswein, Senior Full Stack Developer at Txture,” we saw a team that practices modern product development in a pragmatic, focused way. Nothing is over-engineered for show: Scrum serves the work, daily stand-ups are short and useful, and technical choices align with product quality and delivery. The freedom on offer rewards ownership, while the tech stack is built for the realities of large codebases.

Boiled down, the essence is this:

• Process clarity creates speed.
• Typing and tests drive quality and developer experience.
• Shared architecture work prevents silos.
• Good communication and team harmony are productivity factors — not just “soft skills.”

Conclusion: For engineers who want to shape

Txture combines the strengths of a focused product team with modern technology and genuine flexibility. If you enjoy taking responsibility in an 8–9 person dev team, if React/TypeScript or Kotlin/Node.js is your home (and you like to keep learning), if you prefer quality over theatrics and a respectful, open way of working, the environment here is compelling.

Or, to borrow Christian’s closing sentiment: get in touch — and “see what comes together.” For us, it’s an invitation to anyone who sees product development as a team effort and wants to help shape it.