We're transforming PRTG Network Monitor's 8M+ line Delphi codebase into a modern, modular Rust/Go/C++ architecture using AI-assisted workflows. The Architecture Team defines module boundaries, interface contracts, and architectural guardrails that enable Module Teams to build independently. This is system-level thinking, not implementation — you define what and where, not how.

As an Architect for Core Modules, you will define the architectural patterns and contracts for Rust-based modules in the new PRTG architecture. You work at the system level: analyzing legacy code to understand component boundaries, defining interface contracts between modules, and establishing the patterns that Module Teams will follow.

AI is central to how we work. You'll use AI tools like Claude to analyze legacy code, draft specifications, and generate architectural artifacts — then apply your expertise to validate, refine, and evolve both the outputs and the workflows. This isn't about replacing architectural thinking; it's about amplifying it.

You don't implement modules yourself — you enable others to implement them correctly. Your deliverables are specifications, contracts, and architectural decisions that make independent module development possible.

You'll be part of a small, senior Architecture Team — collaborating closely with fellow architects across Rust, Go, and security domains to shape the overall system design.

AI-Augmented Architectural Work

• Engineer prompts and workflows for architectural analysis — leverage AI to analyze legacy code, extract patterns, and generate architectural artifacts
• Define spec templates and formats — create specification structures that AI can work with effectively and humans can validate efficiently
• Review and refine AI-generated content — apply your expertise to ensure quality, correctness, and architectural coherence
• Evolve the AI workflow — continuously improve how we use AI for architectural work based on what you learn

Architectural Analysis & Decomposition

• Analyze legacy Delphi code at system level — understand component dependencies, data flows, and integration points (AI-assisted)
• Define module boundaries — where each Rust module fits in the overall architecture
• Map dependencies — understand what each module needs and what depends on it

Interface Contracts & Standards

• Design interface contracts — APIs, data formats, message schemas, integration points between modules
• Define behavioral requirements — what each module must do (functional contracts, not implementation details)
• Establish constraints — security requirements, performance targets, compatibility boundaries
• Document cross-cutting concerns — observability, logging, error handling patterns for Rust modules

Architectural Governance

• Review module designs — ensure Module Teams' designs align with architectural constraints
• Resolve interface conflicts — when modules have competing requirements, find solutions
• Enforce cross-module consistency — patterns, naming, error handling should be coherent
• Make technology decisions — libraries, frameworks, tooling for the Rust ecosystem

MUST HAVE

• 7+ years software development experience — you've built production systems and understand what makes software maintainable at scale. Rust experience required, but not necessarily 7 years of it.
• Systems architecture background — you've designed multi-component systems, defined interfaces between teams, and made decisions that constrained (productively) how others built things
• Legacy system experience — you've worked with large, old codebases and understand why modernization is hard. Bonus if you've actually done a strangler fig migration.
• Technical communication skills — you can write specifications that engineers actually understand and follow. You document decisions, not just code.
• Hands-on AI experience — you've used AI tools (Claude, Copilot, etc.) for development work and understand their strengths and limitations for architectural tasks

NICE TO HAVE

• Delphi background — understanding the source language makes legacy analysis much easier
• API design experience — you've designed contracts that multiple teams consumed successfully
• Performance-critical systems — you've made architectural decisions where latency and throughput mattered
• Monitoring/observability experience — you understand what makes systems debuggable at scale

Ideal Background

You've been the person who defined how systems fit together — not just implemented components within them. You've written the specs that other engineers worked from, resolved the conflicts when interfaces didn't match, and made the technology choices that teams lived with for years.

• Many possibilities to further develop your individual skillset
• Innovative and creative work environment with plenty of room for new ideas
• A structured onboarding phase with experienced colleagues
• Flexible working hours and a family-friendly environment
• Permanent employment contract at our headquarters in Nuremberg
• A great working atmosphere in an enthusiastic international team with flat hierarchies
• Paessler is a fast-growing midsized company that has been in the market for 20 years. The company is focused on long-term goals and is currently comprised of 350 employees