As a Backend Software Engineer within the Real User Monitoring (RUM) Core team at Dynatrace, I contribute to the core high-load, high-availability ingestion pipelines that capture and process real-time user experience data at scale. Working primarily with Java, our team prototypes, implements, and optimizes backend features, ensuring system components maintain peak performance and resilience under heavy loads. Collaborating closely with cross-functional teams and product architects, I take end-to-end ownership of backend services, from initial design and debugging to monitoring and analyzing their live performance directly within the Dynatrace platform.

I designed and implemented a novel Model Context Protocol (MCP) server integration for the Graphical Language Server Platform (GLSP), establishing a structured framework for Large Language Models (LLMs) to act as stateful, interactive assistants within graphical modeling environments. By embedding the MCP server directly into GLSP's existing Node.js client-server architecture, the system shares session management and dependency injection containers within a single process, avoiding the overhead and fragility of traditional inter-process communication. The resulting reusable library, @eclipse-glsp/server-mcp, exposes generic tool and resource endpoints that allow AI agents to surgically interact with and alter diagram elements directly within the editor. Both client and server implementations were successfully accepted and merged into the official upstream Eclipse GLSP open-source repositories.

Following a Design Science Research methodology, I evaluated the framework's performance against alternative serialization-based (JSON/XML) and text-DSL (PlantUML) interaction models using standardized modeling exercises. The empirical results demonstrated that the protocol-driven approach achieves near-perfect precision and recall in information retrieval while completely eliminating syntactic errors during model manipulation. Most notably during iterative model modifications, the MCP server prevents the structural corruption typical of generative re-generation methods by executing surgical API operations. Additionally, by incorporating domain optimizations such as identifier aliasing, Markdown serialization, and deterministic layout offloading, the architecture successfully reduced operational token costs and inference latency by approximately 50%.

I built a full-stack evaluation project designed to analyze how different backend and frontend technologies, as well as architectures, measure up under real-world conditions. A rigorous specification for a simple blog application (Conduit) is implemented across multiple tech stacks. This allows for direct comparison of various aspects. On the one hand, the developer experience such as code boilerplate, type safety, and ecosystem maturity, as well as raw performance metrics like response times, resource utilization, and throughput. The resulting data serves as a practical guide for choosing the optimal architecture based on measurable trade-offs, while also providing some insights into developer ergonomics.

After multiple years on ice, this legacy Java project was resurrected at the behest of the German Federal Ministry of Justice. Our team's mission was twofold: first, a major modernization effort to upgrade the outdated codebase from Java 11 to Java 17; and second, the successful implementation and completion of the remaining project requirements. Navigating an inherited, unfinished architecture required both deep technical troubleshooting to resolve technical debt and a goal-oriented approach to deliver on a critical public sector mandate.

I developed an open-source framework designed to seamlessly integrate text-based grammar support into web-based graphical modeling environments. It bridges the gap between two distinct modeling paradigms by connecting the Graphical Language Server Platform (GLSP), used for diagrammatic views, with Langium, a parsing workbench for textual domain-specific languages. By embedding lightweight Monaco text editors directly into graphical diagram elements, the framework allows language engineers to implement advanced, context-aware textual sub-languages. These embedded editors provide rich IDE features like autocomplete, syntax highlighting, and live validation markers directly within the graphical layout.

The core technical achievement of the framework lies in its unified abstract syntax graph and its sophisticated bi-directional synchronization. Textual elements are structurally aware of their exact position on the canvas, meaning a condition expression typed into a specific edge dynamically restricts its scope and filters autocomplete options based only on elements declared in preceding graphical nodes. An automated message bus manages communication between the components, ensuring that any modification to either the graphical layout or the text immediately triggers scope re-evaluation and highlights dangling references. This reusable architecture significantly lowers the implementation overhead for language engineers looking to build robust, hybrid modeling tools.