From Deep Support to Data Migrations: Inside ABP PATENT NETWORK’s App2IP Team – Insights from “Stefan Wöhrer, Product Manager bei ABP PATENT NETWORK”

Context: A tech-lead story grounded in pragmatism and customer impact

In our DevJobs.at techleadstory session “Stefan Wöhrer, Product Manager bei ABP PATENT NETWORK,” speaker Stefan Wöhrer of ABP PATENT NETWORK GmbH outlined a compact, high-impact setup: a four-person team, a deliberately elastic definition of “support,” pragmatic data migrations for large industrial customers, and clear hiring expectations. The throughline is simple and strong: curiosity, clear writing and thinking, and the drive to turn complex data into meaningful structures.

From first-level hotline work to deep SQL analysis, from capturing customer requests to hands-on migration development, many threads come together here. For engineers who want direct responsibility, to work with real customer data, and to learn a legal-adjacent domain, this is an environment with measurable impact—free of heavy processes, yet rigorous in semantic understanding.

Session reference: Title: Stefan Wöhrer, Product Manager bei ABP PATENT NETWORK · Speaker: Stefan Wöhrer · Company: ABP PATENT NETWORK GmbH

Team structure: Small, focused, high leverage

The current team is four people. What starts as “support” is intentionally expanded to include product management at the interface of customer needs and software development.

• Product management as a true bridge: The team gathers, evaluates, and prepares customer requests so engineering can act with clarity. Not every request makes the cut, and the “why” needs transparent communication.
• First-level support with depth: Two colleagues staff the support hotline and handle support emails. This goes “technically quite deep” at times—connecting to databases, running queries, and providing customers with actionable, data-backed answers.
• Migration engineering for new customers: A standout technical challenge lies in onboarding new customers—often larger industrial companies—by migrating and structuring their existing datasets into App2IP.

The blend of direct customer context, data fluency, and close engineering alignment shapes the culture. For engineers, it translates to more context, more autonomy, and more responsibility.

Product management that lives in reality

Here, product management isn’t a slide deck; it’s a working interface. Wöhrer outlines the path from customer need to software change: capture, assess, prepare, prioritize, communicate, and hand over. The key is pragmatic value judgment: which requests make sense, which don’t, and how to explain that fairly.

• Clarity and prioritization: What gets in? What benefits multiple customers? What changes are coherent with the system’s logic?
• Communication and expectations: The bridge stands only if both sides understand each other.
• System proximity: The interface isn’t abstract; it touches data, checks assumptions, and navigates complexity firsthand.

This yields product quality through judgment, not just throughput. Ideas aren’t implemented blindly; they are evaluated for fit with the data model and the users’ day-to-day workflows.

Data migration as a craft: Semantics over syntax

One of the team’s most distinctive challenges—and value drivers—is migrating substantial data volumes into App2IP. The scale is concrete:

• Around 100,000 documents
• About 5,000 case files (“Akten”)
• 2,000–3,000 deadlines (“Fristen”)

Data arrives from legacy systems or varied formats—Excel, SQL databases, JSON, “whatever the customer brings.” Integration is done via migration scripts: targeted, application-aware transformations rather than one-shot generic imports.

A trained software developer, Wöhrer still writes these migrations “in a very unconstrained environment”—no test suites, no formal specifications. That’s not a free pass on quality; it’s a different quality mechanism: semantic rigor. It’s not enough to parse strings, dates, and integers correctly; you must ask whether the mapping is meaningful in the customer’s domain.

This requires domain empathy, careful judgment, and the ability to test changes against real-world practice. It’s also a recipe for engaging, non-repetitive engineering work.

The stack: C#, SQL, and Elasticsearch—chosen for impact

The technology mix around App2IP is straightforward and pragmatic:

• C# / .NET: Because the team works closely with software engineering, C# is the core programming medium. .NET knowledge is a plus.
• SQL: Complex queries across large datasets are a daily task. Engineers are expected to not only write correct queries but also interpret the results and explain them to customers. SQL joins are central.
• Elasticsearch: App2IP runs on a dual-database model: SQL for transactional “movement data,” and Elasticsearch as a full-text index. Everything in the system is full-text scanned and searchable in real time—ideal for a legal-adjacent environment where communication runs across emails, PDFs, and spreadsheets.

The scale is proven in production: “We have a tenant with roughly 2.8 million documents in the system, and it works like that.” High-quality full-text search is a differentiator—and it demands understanding of indexing and query design.

Support with depth: From hotline to database handle

Two team members operate first-level support—and dive deep when needed. That means no mere ticket forwarding; it means analysis, SQL queries, database connections, and delivering clear, actionable customer guidance.

This practice improves first-contact resolution, builds trust, and returns valuable product feedback. For engineers, it’s also training in problem framing: What question lies beneath the question? Which data actually answers it? And how do you translate system complexity into plain language?

Hiring: Uncomplicated, fast, respectful

Wöhrer describes the hiring process as “rather uncomplicated”—no convoluted rounds.

• Sourcing: Headhunters, portals like DevJobs, plus occasional speculative applications.
• First touch and intro call: Remote (e.g., Teams) or on-site, depending on logistics (candidates from Vienna may start remotely).
• On-site in Windisch-Garsten: A deeper dive into technical topics, meeting the team, and testing mutual fit. Usually, a decision is made at this stage.

It’s an efficient, substance-first process that mirrors the team’s culture.

What really matters: Curiosity, clear writing, a will to learn

The domain is legal-adjacent, with case files, deadlines, documents, and interactions with lawyers and authorities—and complex interrelations among these entities. That understanding can’t be shortcut by a tutorial; it’s built through engagement, careful reading, and asking good questions.

Wöhrer’s core requirement is crisp:

Technical skills—C#, .NET, SQL (including complex joins), Elasticsearch—matter, and they’re used daily. But the deciding factor is your ability to structure information, communicate clearly, and reason about meaning. The team’s setup supports learning the domain on the job.

Collaboration with engineering: Proximity over silos

Closeness to the development team is an everyday reality:

• Shared medium: C# allows tight handoffs and clear technical discussions.
• Low-friction interfaces: Requests are vetted and prepared so engineering can move quickly without ambiguity.

The result is a loop of feedback, domain checks, and targeted implementation. Support feeds real user signals; product management prioritizes; engineering delivers and contributes expertise.

Quality through meaning: Why “no formal tests” doesn’t mean “no standards”

A point Wöhrer stresses is that migration is done in an “unconstrained” setting—without formal test mandates or heavy specifications. That’s not an anti-quality stance; it’s a different quality anchor:

• Data is never neutral: Semantic fit determines migration value.
• Domain logic before fields: Correct type mapping is insufficient if the target structure doesn’t reflect how people work.
• Human responsibility: The engineer migrating data owns the judgment call—requiring experience, critical thinking, and clear customer communication.

For many technical talents, this is precisely the kind of responsibility that makes the work meaningful.

Day-in-the-job: Patterns without a script

Days vary because customers, data, and questions vary. Recurring patterns include:

• Qualifying support requests and diving into the database when needed.
• Writing complex SQL queries, interpreting the results, and communicating them in plain terms.
• Capturing and preparing product requirements for engineering.
• Designing or adapting migration scripts, running realistic test loads, and validating semantic soundness.
• Querying Elasticsearch to answer document-related questions.

The breadth rewards curiosity as much as discipline.

Why App2IP is technically interesting: Two data worlds, one immediate benefit

SQL and Elasticsearch together make App2IP adept at both structured transactions and unstructured content, in real time:

• SQL: Consistency, relationships, and complex joins across many entities.
• Elasticsearch: Rich full-text indexing across emails, PDFs, and spreadsheets—immediately searchable at scale.

The cited “roughly 2.8 million documents” is not a lab benchmark—it’s a real tenant. For engineers, that’s fertile ground for learning: query design, index health, and relevance in a legal-adjacent context.

Employer branding: What ABP PATENT NETWORK offers—who will thrive here

From Wöhrer’s insights, a clear profile emerges. This environment suits tech talent who…

• …embrace customer context as a source of relevance.
• …enjoy turning heterogeneous data into meaningful structures—beyond type conversion.
• …like working with C#, .NET, SQL, and Elasticsearch and want to grow on large datasets.
• …prefer a small, focused team with real autonomy.
• …want to learn how case files, documents, deadlines, and country contexts interrelate in a legal-adjacent domain.
• …appreciate straightforward, no-frills processes—in daily work and in hiring.

Concrete reasons include:

• A simple hiring path (initial contact, intro—remote or on-site—then a deeper session in Windisch-Garsten with a quick decision).
• Real responsibility from day one—with visible impact on customer systems.
• Learning on two axes: technology (C#, SQL, Elasticsearch) and domain (case files, deadlines, documents in a legal-adjacent setting).

Candidate profile: Skills that make you effective here

Three capability areas crystallize from the session:

1) Core abilities

• Read and write clearly: Clear language reflects clear thinking.
• Curiosity: The domain is the real challenge—curious minds learn fast.

2) Technical toolkit

• C# and .NET: Practical, close to the development team.
• Advanced SQL: Complex joins, large datasets, and interpretive analysis.
• Elasticsearch basics: Indexing, querying, and full-text thinking.

3) Ways of working

• Customer orientation: Understand questions, manage expectations, explain results.
• Ownership: Make migration calls and validate semantic soundness.
• Team play: Structure requirements and integrate feedback from engineering.

Organization and communication: The backbone of product evolution

The “Support + Product + Engineering proximity” model brings tangible advantages:

• Real-time feedback: Support spots patterns, product prioritizes, engineering implements.
• Learning by doing: Domain knowledge grows with every ticket, migration, and handoff.
• Transparent decisions: Which customer requests get built—and why—is traceable.

This setup avoids bottlenecks: knowledge spreads, and decisions are made where the information is richest—close to the problem.

Migration scripts as a value engine: Individual paths over one-size-fits-all imports

Choosing migration scripts as the integration backbone is telling. Given the variety of sources, standard tools hit limits when semantic nuances matter. Scripts allow:

• Fine control: Field-by-field, rule-by-rule—plausible and auditable.
• Iteration: Test with real data, adjust, validate meaning.
• Documentation through outcome: The migration “explains itself” when data lands in the right place and shape.

For engineers, this is gratifying work: you’re solving the actual problem and learning a great deal about customers’ data landscapes.

Search at scale: Full text as a differentiator

In an environment where so much communication lives in emails, PDFs, and spreadsheets, robust full-text search isn’t a nice-to-have; it makes workflows viable. App2IP uses Elasticsearch—and scales to millions of documents for individual tenants.

Diving into this technology teaches more than a tool—it teaches a model: how to shape unstructured information so it becomes valuable in real time.

Easy entry, substantive growth: A learning path that matters

Entry into the team is deliberately straightforward—no “complicated admission procedure.” The learning path, however, is substantive: domain depth, technical complexity, and responsibility in customer-facing situations. It’s a rare combination that fosters both professional and personal growth.

Practically, that means:

• Learning on the job: Real migrations and support cases beat any textbook.
• Working with customers: Immediate feedback on your work.
• Tight alignment with engineering: Fast knowledge transfer and short feedback loops.

Conclusion: For the curious who enjoy complexity—and want impact

Our conversation with Stefan Wöhrer points to a team that wins on substance: small headcount, big responsibility, real data scale, and direct customer impact. If you work well with C#, .NET, SQL, and Elasticsearch—or are ready to dig in—and if you take domain logic seriously, ABP PATENT NETWORK offers a challenging and rewarding environment.

• Migration as a disciplined practice—validated by meaning, not just syntax.
• Support that doesn’t pass tickets along but understands and resolves.
• Product management that sets priorities and brings clarity.
• A stack that scales—SQL and Elasticsearch as a powerful duo.

Applications come via headhunters, portals like DevJobs, and speculative outreach. The interview process mirrors the work: pragmatic and direct. If the on-site session in Windisch-Garsten goes well—for both sides—you can quickly become part of a team that asks, every day, how to make data meaningful.

In short, it’s an invitation to those who value responsibility, context, and the intersection of technology, data, and customer value—where impact is visible.

• 

  

  Fokus auf IP

  Daniel Holzner von ABP PATENT NETWORK gibt in seinem devjobs.at TechTalk einen Überblick über die im Unternehmen entwickelten Projekte und deren Challenges.

  Watch now

• 

  

  Alessandro Aichmann, Teammanager Software bei ABP PATENT NETWORK

  Teammanager Software bei ABP PATENT NETWORK Alessandro Aichmann gibt im Interview Einblicke in die Software Abteilung im Unternehmen und auf was dort bei einer Bewerbung geachtet wird.

  Watch now

• 

  

  Denis Husidic, Software Developer bei ABP PATENT NETWORK

  Denis Husidic von ABP PATENT NETWORK erzählt im Interview über seine Laufbahn als Software Developer und über seine aktuelle Rolle im Unternehmen – und warum Kreativität beim Entwickeln wichtig ist.

  Watch now