<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by OTTO Tech on Medium]]></title>
        <description><![CDATA[Stories by OTTO Tech on Medium]]></description>
        <link>https://medium.com/@otto.tech?source=rss-a4d9b275e3bc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*yqGbvaVdqWmpOgq1-kGT-w.png</url>
            <title>Stories by OTTO Tech on Medium</title>
            <link>https://medium.com/@otto.tech?source=rss-a4d9b275e3bc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:22:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@otto.tech/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[AI Agents in Retail: 
How GAIA Automates Decision-Making Processes at OTTO]]></title>
            <link>https://medium.com/otto-tech/ai-agents-in-retail-how-gaia-automates-decision-making-processes-at-otto-afe1259944ce?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/afe1259944ce</guid>
            <category><![CDATA[snowflake]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[streamlit]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Thu, 01 Oct 2026 10:14:58 GMT</pubDate>
            <atom:updated>2026-10-05T12:26:33.384Z</atom:updated>
            <content:encoded><![CDATA[<p>With the GAIA Cockpit, OTTO is developing a control tool for the AI agent GAIA. Using the GEMA meeting as an example, this article shows how AI agents help reduce the effort required for preparation and follow-up, consolidate information from various sources, and facilitate faster, well-informed decision-making. The technical foundation consists of Snowflake Cortex AI and a custom-developed Streamlit app.</p><h3>How AI Agents Support Decision-Making Processes</h3><p>Artificial intelligence has long since moved beyond its role as merely a chatbot or analytical tool in businesses. Increasingly, AI agents are taking on specific tasks within complex processes: They link data from various systems, prepare decisions, identify deviations, and trigger follow-up actions. As a result, AI is evolving from a mere assistance tool to an active participant in processes.</p><p>The potential is particularly great in retail and e-commerce. Dynamic markets and the close interdependence of product assortments, pricing, inventory, campaigns, and operational management create a high degree of complexity. AI agents can help consolidate information, reveal connections, and prepare decisions in a more targeted manner.</p><p>This is precisely where one of our current projects at OTTO comes in: With the GAIA Cockpit, we are developing a management tool for the AI agent GAIA (GEMA AI Assistant), which supports the cross-departmental GEMA meeting (GEMA stands for “Joint Market Development”). This meeting brings together key metrics, trends, and areas requiring action to prepare data-driven decisions more efficiently.</p><h3>OTTO’s Team Inc(AI)</h3><p>Before we dive into the GAIA Cockpit, we’d like to briefly introduce the team behind the project. We at OTTO’s Team Inc(AI) (“Inc” stands for “Incubator”) are a team of data scientists and machine learning engineers. We support the initial implementation of AI solutions for a wide variety of use cases at OTTO and guide the teams through the process from brainstorming sessions to prototype development.</p><h3>The Challenge at the GEMA Meeting</h3><p>OTTO’s GEMA Meeting takes place every two weeks and brings together decision-makers from all relevant platform areas.</p><p>The GEMA Meeting serves to analyze past trading activities across departments and coordinate future management strategies. The focus is on quickly identifying necessary actions, defining common goals, and establishing a shared understanding.</p><p>Precisely because so many different departments come together at the biweekly meeting, the manual effort required for preparation and follow-up is very high.<br>The high complexity of the topics and the interdependence of the individual organizational units also make it difficult to analyze problems quickly and clearly.<br>To reduce this effort, the AI agent GAIA comes into play.</p><h3>The Architecture of GAIA</h3><p>GAIA is not designed as an isolated AI prototype, but rather as an expandable system for specific work processes. The following sections show how this system is technically structured and how it can be put to practical use.</p><h3>Snowflake Cortex AI as the Technical Foundation</h3><p>Our technical foundation is Snowflake Cortex AI. Snowflake is primarily known as a database provider, but it also offers an integrated way to deploy AI agents. Snowflake’s agents are powered by common LLMs such as GPT or Anthropic models. These can access the data stored in Snowflake. A prerequisite is that the agent is granted the appropriate access rights for each data source. The data is made accessible to the agent through natural-language descriptions of the table columns — so-called “semantic views.” The agent can thus generate and execute appropriate SQL queries.</p><figure><img alt="The GAIA agent in action in Snowflake Intelligence." src="https://cdn-images-1.medium.com/max/833/1*dg4T7b7mk9JqqwocxWXLTA.png" /><figcaption><em>Figure 1: The GAIA agent in action in Snowflake Intelligence.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/833/1*Vk1GztcA4IjojM5lGK_nIQ.png" /><figcaption><em>Figure 2: The GAIA Cockpit’s knowledge base aggregates relevant information and makes it available to the AI agent.</em></figcaption></figure><h3>The GAIA Cockpit as a Flexible Extension</h3><p><em>The app includes the following key components:</em></p><ul><li>The ability to provide the agent with unstructured data directly via a simple file upload function, such as definitions of KPIs, economic knowledge, business logic, or minutes from GEMA meetings</li><li>Scheduling of asynchronous agent tasks: the agent receives tasks that it is to execute at a specified time, either once or on a recurring basis. The tasks can be defined manually in the app or automatically extracted from the GEMA minutes.</li><li>Notifications via MS Teams: Upon completion of a task, a message is sent to the GAIA Teams channel implemented via a webhook.</li><li>Skills enable the definition of recipe-like sequences of actions to provide the agent with guidance for more specific tasks and, if necessary, support it with executable code.</li><li>Evaluation function: Users can directly label the agent’s responses to prompts as correct or incorrect. The labeled data then serves as training data for the agent’s continuous improvement.</li></ul><h3>Conclusion</h3><p>With GAIA and the GAIA Cockpit, we are creating a flexible technical foundation for integrating AI agents into complex control and decision-making processes in a targeted manner. This allows us to streamline cross-departmental coordination, reduce the effort required for manual preparation and follow-up, and significantly better leverage the potential of data and knowledge in the context of GEMA meetings. At the same time, this approach demonstrates how existing third-party products, such as Snowflake Cortex AI, can be expanded into customized AI solutions — all through AI with manageable effort.</p><p>We hope this insight will provide inspiration on how AI agents can be integrated pragmatically and effectively into existing management processes. If this insight sparks new ideas, we’d be delighted to hear your thoughts, feedback, and further perspectives.</p><p>Anyone interested in how AI agents are transforming not only control processes but also the development of digital products will find further insights in the following article: “AI Software Development — How AI Agents Are Transforming Our Engineering.” In it, we show how software development at OTTO is undergoing a fundamental transformation through AI-assisted engineering, specification-driven work, and the use of specialized AI agents.</p><h4><em>AI Software Development </em>–<br>How AI Agents Are Transforming Our Engineering:</h4><p><a href="https://www.otto.de/jobs/en/blogs/techblog/ai-software-development/">https://www.otto.de/jobs/en/blogs/techblog/ai-software-development/</a></p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/en/blogs/techblog/">Techblog</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kBaQ7HjK6md08N1-6-T_bw.jpeg" /><figcaption>The Authors: <a href="https://edit.otto.com/en/blogs/techblog/authors/team-inc-ai/">Team Inc(AI)</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=afe1259944ce" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/ai-agents-in-retail-how-gaia-automates-decision-making-processes-at-otto-afe1259944ce">AI Agents in Retail: 
How GAIA Automates Decision-Making Processes at OTTO</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rewriting OTTO in Rust: 
oxidizing our codebase, one service at a time]]></title>
            <link>https://medium.com/otto-tech/rewriting-otto-in-rust-oxidizing-our-codebase-one-service-at-a-time-19a55df35aed?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/19a55df35aed</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[rust-programming-language]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 10:07:30 GMT</pubDate>
            <atom:updated>2026-08-24T10:14:10.734Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, you’ll learn why one of our engineering teams gradually migrated its <strong>AWS Lambda </strong>functions and <strong>microservices </strong>to <strong>Rust </strong>and discovered that the famous engineering mantra “<strong>Rewrite it in Rust</strong>” was more than just a meme. The focus lies on the programming language’s advantages in terms of <strong>error handling, performance, resource requirements</strong>, and developer experience, as well as a comparison with <strong>Kotlin, TypeScript, and Go</strong>. The article also shows how Rust evolved from an initial experiment to a<strong> production-ready backend standard</strong>, the challenges that arose along the way, and the lessons learned from migration, pair programming, and collaborative knowledge-building .</p><p>You can read more about Rust at OTTO here:</p><ul><li><a href="https://www.otto.de/jobs/en/blogs/techblog/recap-of-the-eurorust-2023-conference-in-brussels/">Recap of the EuroRust 2023 Conference in Brussels</a></li></ul><h3>Where do we come from?</h3><p>FT9 is one of many development teams responsible for specific areas of otto.de and the app, known as “verticals”. For this blog post, the “Benefit” vertical is particularly relevant, as this is where we develop customer benefits. It is our team’s core product. All the authors of this post work in FT9.</p><p>Throughout their customer journey, our customers encounter customer benefits at various points. These can reduce the price of a product, thereby helping customers save money when shopping. For OTTO and its marketplace partners, customer benefits also offer the opportunity to differentiate products from the competition and position them strategically. To ensure customers actually take advantage of these benefits, we display them at many different touchpoints. Some of these areas are personalised. For example, we sort customer benefits based on a score or filter them to match the products displayed in a search. To meet these requirements, we run microservices and Lambdas on AWS. Our microservices process an average of around 5,000 requests per second. Wherever possible, the client or an upstream proxy caches the requests. For the remaining requests, our goal is to achieve a p95 (95th percentile latency) response time of under ten milliseconds.</p><p>We started out with classic Spring Boot microservices, initially in Java and later in Kotlin. The infrastructure and monitoring were implemented in Python. Other teams frequently forked these solutions, which meant that new applications could be brought into production quickly.</p><p>Over the years, our technology stack has expanded, and Lambda functions have been added to our services. To this end, we trialled several languages: Python, Java, Kotlin and TypeScript. Each presented its own challenges. We lacked the necessary depth of experience with Python within the team. Java and Kotlin failed to meet our performance requirements, particularly during cold starts. With TypeScript, we faced a different problem: Serverless, our build tool for TypeScript Lambdas, released version 4 as a paid upgrade and, at the same time, announced the end of support for version 3.</p><h3>Why Rust?</h3><p>So why Rust and not one of the many alternatives on the market? Our decision was based on a comparison of various technologies and the requirements of our serverless architecture.</p><h4>The search for the right language</h4><p>Kotlin was the obvious choice at first, as our existing applications were already written in it. However, when it came to lambdas, it was the JVM tooling in particular that held us back. Bundling Kotlin lambdas reliably was cumbersome and error-prone. Furthermore, whilst we had a great deal of experience with Kotlin and Spring Boot within the team, we had significantly less experience with the ecosystem outside of Spring. We also tested Spring Boot with lambdas, but rejected this approach due to build issues and very high latencies. AWS SnapStart was not yet available in eu-central-1 at that time.</p><p>We considered Go as a second language. However, the language differs significantly from the concepts and conventions we have come to value in Kotlin. In particular, we found ourselves lacking a similarly expressive type system, null safety comparable to Kotlin’s, and a balanced mix of different programming paradigms, such as in the declarative handling of iterators. Continuing to use TypeScript was also not an attractive option for us. The tooling is suboptimal and fragmented, and the language also has several drawbacks: types are not enforced at runtime, the fragmentation into ESM and CJS creates additional complexity, and other peculiarities make it difficult to use.</p><p>As it happened, several developers in the team had already been exploring Rust in their spare time. This put Rust — which was still rather niche for Lambdas at the time — on our radar, initially out of purely hypothetical interest. However, following a showcase on Rust Lambdas at the Serverless Summit, as well as a number of practical experiments and tests, it quickly became clear that Rust not only works for Lambdas, but also fits our use cases and team preferences very well.</p><h4>What makes Rust attractive for lambdas</h4><p>So what exactly makes Rust attractive for Lambdas? First, a technical overview: Rust is a statically and strongly typed, compiled programming language which, much like Kotlin, combines imperative and functional programming. Unlike languages such as Kotlin, however, Rust does not come with a runtime environment and does not require a garbage collector. Instead, memory safety is ensured by rules that the compiler checks.</p><p>Rust is compiled to native machine code via LLVM and requires no runtime. This contributes to small binaries, short start-up times and low resource consumption. In the linked Lambda benchmark, Rust is faster and more resource-efficient than the alternatives mentioned. This combination is particularly interesting for Lambdas because their costs depend on runtime and allocated computing resources. Rust therefore reduces both execution time and resource requirements.</p><p>The strong performance and efficiency weren’t the primary reasons for our decision, but a welcome bonus. Rust’s powerful type system is far more important to us. The absence of null pointers is particularly relevant. It was a real no-brainer for us, as it plays a crucial role in ensuring the correctness of the code. Furthermore, Rust maps potential error states as enums within the type system, thereby preventing nasty surprises caused by unhandled exceptions at runtime. Such exceptions are a major weakness of the Kotlin type system, as they render critical control flow invisible to developers. Rust makes the implicit explicit: if an error can occur, it must be handled.</p><p>Last but not least, Rust’s tooling is first-class. Build and dependency management, linters, formatters and test runners are closely integrated. This means we rarely have to switch between different tools and can focus more on what really matters: writing code. In addition, Cargo Lambda provides dedicated Lambda tooling that makes it easier to build, run locally and deploy Lambdas.</p><p>All these insights convinced us to give Rust a go for Lambdas. But isn’t Rust considered a particularly complex language? It’s true that Rust does things quite differently from other languages — partly to enable high performance — and some language constructs may seem challenging at first glance. In our case, however, we mainly write highly abstracted CRUD code, which can also be implemented in Rust without any problems. The syntax remains C-like, and familiar abstractions such as iterators or async/await made it easier for us to get started. Based on our experience, we cannot therefore confirm the widespread preconception that Rust is fundamentally too complex.</p><p>Algebraic data types have also helped us to model domain logic more precisely than we could previously in Kotlin. In Rust, more logic can be formally expressed within the type system. This means that invalid states become apparent earlier, and the actual code becomes more reliable.</p><p>It has also become apparent recently that Rust is well suited to agentic workflows. The powerful type system and the informative compiler messages provide an agent with rapid, high-quality feedback on whether changes are correct. This creates a short feedback loop: the agent makes a change using the contextual information available in the type system, the compiler and tests provide immediate feedback, and the agent uses this feedback for the next adjustment. The automation of code writing also puts into perspective the widespread perception of Rust as an overly complex language.</p><p>Taken together, these characteristics were convincing enough for us to start using Rust productively for our Lambdas, thereby laying the foundation for further services written in Rust.</p><h3>Adopting Rust in practice</h3><p>We deliberately introduced Rust incrementally: first in Lambdas, then in long-running services. This allowed us to test the language in a production environment without risking disruption to operations through a big-bang migration. We started with Lambdas because they were small, well-defined and could be iterated on quickly using the Rust toolchain. Initially, we migrated functions that were not business-critical but were complex enough to provide robust insights for future services. At the same time, we reviewed our architecture and tooling. We were able to replace some legacy functions with leaner alternatives. For example, we replaced our in-house JVM job frameworks (for scheduled background processes) with lambdas.. Building on this experience, we ventured into long-running services and gradually implemented endpoints in a Rust service running in parallel. As web frameworks in Rust are more modular and leaner than those in the JVM ecosystem, we initially had to make more decisions ourselves and consciously assemble individual building blocks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/0*nLK1tEEIbI6WyR3n.png" /><figcaption><em>Figure 1: New modular architecture.</em></figcaption></figure><h4>What went well?</h4><p>Our incremental approach has proved its worth. We were initially able to deploy Rust in areas where we could get rapid feedback, and subsequently apply the insights gained to our services without jeopardising operations. The impact was particularly evident in terms of performance, resource usage and start-up times. Our Lambdas start without a lengthy warm-up phase, and our services require fewer resources under load. This enables us to provision additional capacity more quickly during peak loads.</p><p>Since the complete migration of our team’s code to Rust, we have had no production incidents attributable to errors in our application code. Rust is a key factor in this: error conditions are visible in the type system, and we identify many issues during compilation rather than during or after deployment. As a result, fewer bugs make it into production, our operational overhead is reduced, and we can iterate more quickly. New code is also easier for us to read and more secure.</p><p>Building knowledge together was at least as important as the tooling. We worked through the material together, discussed decisions as a team, and later shared our experiences in OTTO-wide sessions such as Show-and-Tell. Particularly in the early stages, focusing on short feedback cycles really helped us. We combined learning resources such as the Rust Book, Rustlings and 100 Exercises to Learn Rust with production code and pair programming within the team. At first, the compiler felt like an additional adversary. However, it quickly became a tool that highlighted errors early on, thereby providing reassurance. To help new colleagues get up to speed, we translated these experiences into clear team practices. Pair programming and community resources helped us apply these practices to actual code and become productive quickly, even without prior experience of Rust.</p><p><strong><em>From a junior developer’s perspective:</em></strong><em> For me, Rust was less about ‘a new syntax’ and more about a new way of thinking at the start. The balance between learning the material, pair programming and making small, self-contained changes to production code was key: I was able to try out concepts straight away, get feedback from the compiler and ask more in-depth questions during pair programming. The exceptionally good Rust documentation and exercises were particularly helpful.</em></p><h4>What challenges did we face?</h4><p>In addition to style and architectural considerations, we encountered other challenges typical of Rust: ownership, lifetimes, and safely working with the borrow checker take time. This is especially true when you want to not only satisfy the compiler but also write clean and efficient code. Over time, however, we became familiar with idiomatic and maintainable patterns. For us, these include Rust’s conversion traits such as “From” and “AsRef”, as well as Axum’s “FromRequestParts” trait for handler functions. These allow us to elegantly extract additional information from a request.</p><p>One challenge was the transition from a coding style that was initially not very Rust-idiomatic to idiomatic Rust. Our setup was heavily influenced by Spring, Kotlin, and Java. At first, a lot of it felt like a direct translation from our previous stack. Over time, through refactoring, we established common standards: more enums and type modeling, better error handling, and greater use of Rust patterns and features. For example, we agreed to bubble up non-retryable errors using the question mark operator “?” and to use a single, larger error enum instead of scattering multiple small ones throughout the code. At the architectural level, we placed greater emphasis on the Functional Core/Imperative Shell pattern, which separates business logic from technical side effects. This enabled us to clearly separate pure functions — that is, deterministic functions without side effects — from infrastructure code, making the code clearer and easier to test. Our code is now housed in a single monorepo.</p><figure><img alt="Codeausschnitt in dunkler Entwicklungsumgebung, der das Rust-Enum Result&lt;T, E&gt; zeigt. Das Enum enthält die Varianten Ok(T) für erfolgreiche Ergebnisse und Err(E) für Fehlerwerte. Kommentare beschreiben die jeweilige Bedeutung der beiden Rückgabewerte." src="https://cdn-images-1.medium.com/max/624/0*2W6FKLH5SCe8R7SO.png" /><figcaption><em>Figure 2: Result Enum from std::result</em></figcaption></figure><p>The consistent use of Clippy lints also helped us during the transition. Gradually, discussions about the lints led to the establishment of shared team conventions. Rules such as “checked_conversions” or “match_wildcard_for_single_variants”not only clarified style issues but also prevented specific bugs.</p><p><strong><em>From a junior developer’s perspective: </em></strong><em>Ownership and lifetimes have drastically changed the way I look at code. Instead of hoping that “the compiler will optimize it,” you’re forced to explicitly understand data flow and trade-offs (copying vs. referencing, data lifetimes, concurrency). This is challenging at first, but becomes manageable with targeted deep dives and pair programming. From then on, the compiler feels less like a gatekeeper and more like a safety net.</em></p><h4>What have we learned?</h4><p>Our most important insight is therefore less technical and more organizational in nature: A new language does not have to prove that it works in an isolated experiment. Small, productive components, short feedback cycles, and a step-by-step expansion provide reliable answers more quickly than lengthy discussions about theoretical pros and cons.</p><p>At the same time, the myth that Rust is difficult to get started with has been put into perspective for us. Similar to Google, we’ve found that getting started is very doable when learning phases, pairing, and productive tasks are combined effectively. In hindsight, however, we should have scheduled an external review of our practices sooner. That would likely have saved us a few iterations and subsequent refactorings.</p><p><strong><em>From a junior developer’s perspective: </em></strong><em>The “hard” concepts pay off later on: You develop a stronger sense of security, data flow, and the system’s limitations. Plus, you spot almost all problems very early on. These rapid feedback cycles help with learning.</em></p><h3>Where are we now and what’s next?</h3><p>Rust is now our standard for production environments. Both our services and our Lambdas run on it. Its lower resource usage, reliability, and strong developer experience have since convinced other teams as well. As a result, what started as a local technology decision has evolved into a development that extends beyond our team. Several teams are now using Rust. They were won over not only by performance and security, but above all by the strong developer experience, the explicit modeling of errors, and the resulting software quality. This combination of safety, clarity, and rapid feedback makes Rust attractive for production-grade backend systems. We now have both intra-team and cross-team initiatives that make knowledge visible, share experiences, and help new teams get started. These include show-and-tells, Rust initiatives at our annual company-wide Tech Quality Days, and collaboratively developed closed-source libraries.</p><p>Of course, we are continuing to evolve our setup. New tooling, new architectural approaches, and better patterns help us make the code safer and more maintainable through refactoring and iterate faster. Next, we want to standardize core business objects from a domain perspective. To this end, we’ve developed a model that maps requirements directly to Rust’s type system and prevents invalid states in the code. For us, Rust has evolved from an experiment to our default production language: in production, across teams, and increasingly as a shared engineering practice. Our experience thus contradicts a common assumption: for backend teams, Rust is productive not in spite of its strict compiler, but precisely because of it.</p><p>We hope you enjoyed the article! Feel free to share your thoughts in the comments. And if you’d like to learn more about “Rust at OTTO,” be sure to check out the following article: <a href="https://www.otto.de/jobs/en/blogs/techblog/recap-of-the-eurorust-2023-conference-in-brussels/">https://www.otto.de/jobs/en/blogs/techblog/recap-of-the-eurorust-2023-conference-in-brussels/</a></p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/en/blogs/techblog/">Techblog</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rNeqDpbpA-MMRCZtFVWvrg.jpeg" /><figcaption>The Authors: Falk, Nico &amp; Ren<em>é</em></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19a55df35aed" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/rewriting-otto-in-rust-oxidizing-our-codebase-one-service-at-a-time-19a55df35aed">Rewriting OTTO in Rust: 
oxidizing our codebase, one service at a time</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Prompt to Product: Spec-Driven Development with Agent Workflows]]></title>
            <link>https://medium.com/otto-tech/from-prompt-to-product-spec-driven-development-with-agent-workflows-ac883854c87e?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac883854c87e</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[spec-driven-development]]></category>
            <category><![CDATA[ai-automation]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 11:01:15 GMT</pubDate>
            <atom:updated>2026-07-21T11:01:15.039Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, we show how <em>Spec-Driven Development</em> with <em>agent workflows</em> works in practice and why this approach goes <em>beyond classic vibe coding</em>. Instead of generating code directly from prompts, software is created step by step from <em>clear requirements, precise specifications, and specialized agents</em>. The focus is on an experiment that explores the Story, Plan, Implement, and Review workflow as well as the effects of<em> AI-assisted development, TDD, and structured specifications</em>. Finally, we present key learnings, typical pitfalls, and solution strategies for working with <em>AI agents</em>.</p><p>More on agentic AI at OTTO can be found here:</p><ul><li><a href="https://www.otto.de/jobs/de/blogs/techblog/ai-software-development/">AI Software Development — How AI Agents Are Transforming Our Engineering</a></li><li><a href="https://www.otto.de/jobs/de/blogs/techblog/ki-assistent-von-vektordatenbanken-zu-multimodalen-agenten/">AI Assistant: From Vector Databases to Multimodal Agents</a></li></ul><h3>On Vibe Coding and Spec-Driven Development</h3><p>In the fast-moving world of software development, we are constantly looking for ways to optimize our processes and improve the quality of our work. At the moment, we are seeing two opposing approaches:</p><ul><li>“Vibe coding” is an intuitive and creative approach in which developers quickly get into the “flow” in order to achieve results quickly.</li><li>“Spec-Driven Development” with agent workflows is a structured approach that delivers reproducible and scalable results through precise specifications and the use of agents.</li></ul><p>With the emergence of powerful tools such as OpenCode, working with agents and subagents is becoming especially important. We wanted to find out whether software development can work completely without “writing code ourselves” and how far a consistent agent-based approach can take us. That is why we started an experiment and are sharing our learnings here.</p><h3>Unser Use Case</h3><p>At OTTO, numerous AI initiatives are currently underway. The AI Engineering Excellence (AIEE) team provides cross-team enablement along the entire Product Development Lifecycle (PDLC). To test the potential of agents in a real project environment, we set up a two-week experiment together with the AIEE team:</p><ul><li>Goal: Bring an internal frontend to MVP (Minimum Viable Product).</li><li>Constraint: Do not use a single manually written line of code.</li><li>Additional constraint: Consistently avoid vibe coding.</li></ul><h3>Approach &amp; Collaboration</h3><p>To run the experiment efficiently and with a clear focus, we defined clear roles and a structured process:</p><p>AIEE Team</p><ul><li>Took on the enabler role and provided the necessary know-how on agent skills.</li><li>Supported the project by advising on architectural decisions and handled quality assurance tasks.</li></ul><p>Our Team</p><ul><li>Was responsible for implementing the project and steering the agents.</li><li>Created the required specifications and ensured that requirements were clearly defined and documented.</li></ul><p>Daily syncs, intensive pairing sessions, and fast iteration cycles complemented the setup. These measures promoted continuous exchange within the team and enabled us to solve challenges together. The result was a high level of knowledge sharing and a steep learning curve for everyone involved.</p><h3>Our Approach: Spec-Driven Instead of Vibe Coding</h3><p>We deliberately decided against “just prompting away” and instead used spec-driven development with agents.</p><h4>What exactly is Spec-Driven Development?</h4><p>Specification-driven development is a methodological approach in software development in which software is implemented on the basis of detailed and clearly formulated specifications. Requirements are documented in writing before implementation begins and serve as the binding foundation for all subsequent development steps — in the context described here, also for the use of agents.</p><h4>What are the benefits?</h4><p>The spec-driven approach offers a number of benefits that have a positive impact on both the development process and the final result:<br>✓ More precise implementation of requirements<br>✓ Reproducible results<br>✓ High code quality<br>✓ Less implicit knowledge<br>✓ Greater consistency in the code</p><h4>The Agentic Engineering Workflow</h4><p>The core idea:<br>Instead of generating code directly, specifications are created first and then used to generate the code in a deterministic and traceable way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/0*Vh_MtQEPzU95uuzJ.png" /></figure><p><em>Figure 1: Our Agentic Engineering Workflow — from requirements to approval.</em></p><p>This workflow helped us move faster while also improving code quality. By refining stories thoroughly, critically questioning plans, and clearly documenting decisions from the start, we avoided time-consuming correction loops. A solid planning phase ensured that our implementation was focused and efficient from the outset.</p><p>As shown in the diagram, our workflow follows a clear sequence:</p><ul><li>Story: We start with a precise user story (problem, acceptance criteria, context).</li><li>Plan: In planning mode with agents, we refine the story into an actionable roadmap, identify risks, and document decisions.</li><li>Implement: In line with the reviewed plan, we write only small, verifiable code sections and commit at short checkpoints.</li><li>Review: Finally, we check whether the code and the plan match and whether the plan was sufficient.</li></ul><p>This “Story -&gt; Plan -&gt; Implement -&gt; Review” cycle creates transparency, high quality, and fast iterations.</p><h3>Learnings, Pitfalls &amp; Solutions</h3><p>During the experiment, we encountered several key insights, typical pitfalls, and proven solution strategies, which we summarize here.</p><h4>1. Specification Is Everything</h4><p>One of our most important learnings: A precise story (problem, acceptance criteria, boundaries) forms the foundation. A carefully reviewed plan builds on it and is challenged before the work begins.</p><p>Pitfall: Without this process, agents quickly get lost in unclear changes. In our experiment, we had not defined all return services, so not all of them were listed in the dropdown menu.</p><p>Solution strategy: Recording all artifacts (stories, plans, decisions) and consistently working according to the Story-Plan-Commit-Review cycle ensure transparency, quality, and speed.</p><p><strong>The most important learning:</strong><br>The quality of the specification largely determines the quality of the result: unclear requirements lead to unclear results, while precise specifications lead to remarkably good outputs.</p><h4>2. Context Is Limited</h4><p>Pitfall: There is often a tendency to use agents as universal problem solvers and assign them many different tasks at the same time. The problem: the context window fills up, causing quality to drop significantly (from about 70% utilization).</p><p><strong>Solution:</strong></p><ul><li>Use subagents specifically where tasks are independent of one another and can be worked on in parallel.</li><li>Clear responsibilities for each subagent keep the overview intact and ensure the quality of the results.</li></ul><p>Here is an example prompt for implementation via subagents:<br>“<em>Implement. Go task by task. Spawn a subagent for each task. Use TDD Red-Green-Refactor. Create a commit. Ask me questions if anything is not clear enough</em>”</p><h4>3. TDD is a Game Changer</h4><p>Our learning: tests from the start are essential. They catch errors early and provide confidence with every change. Without automated tests, undetected bugs crept in — for example, buttons that did not work or missing validations.</p><p>Pitfall: Agents generate code, but without tests there is no feedback channel for quality assurance, and regressions creep in.</p><p>Solution strategy: Require every subagent to create a test stub (unit or snapshot test) before implementation. With the “Red — Green — Refactor” process, we ensure that every change is verified before it moves into the main branch.</p><p><strong>Why TDD matters:</strong></p><ul><li>By validating functionality early, potential bugs can be identified and fixed during the development process.</li><li>Automated tests help prevent regressions by ensuring that new changes do not affect existing functionality.</li><li>Iterations become safer and more controlled because continuous tests enable stable further development.</li></ul><h3>Our Conclusion</h3><p>Our experiment was not only a lot of fun but also gave us many valuable insights. The combination of spec-driven development and agent/subagent workflows has the potential to fundamentally change software development.</p><p><strong>We are already observing:</strong></p><ul><li>Faster development</li><li>Better scalability</li><li>More consistent codebases</li></ul><p>But the role of developers is also changing noticeably: it is increasingly less about writing code oneself and more about thinking in architectures, assessing quality, and orchestrating complex systems. Our recommendation is therefore: try this approach yourself, start small, think consistently in specifications, and use subagents deliberately for implementation.</p><p>And above all: Stay curious. We look forward to hearing about your experiences, opinions, and questions! 👇</p><p>By the way, you can find more exciting insights into AI initiatives at OTTO in Jan Vesper’s article on <a href="https://www.otto.de/jobs/de/blogs/techblog/ai-software-development/">AI Software Development (at OTTO)</a> and Alexander Kranz’s post about <a href="https://www.otto.de/jobs/de/blogs/techblog/ki-assistent-von-vektordatenbanken-zu-multimodalen-agenten/">AI Assistants — From Vector Databases to Multimodal Agents</a>. Enjoy reading!</p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/en/blogs/techblog/">Techblog</a>.</p><figure><img alt="The picture shows Techblog-Author Nina in her working desk at OTTO while writing the article on Spec-Driven Development." src="https://cdn-images-1.medium.com/max/1024/1*dtCSxk5u_f9A-egsyLmQXg.jpeg" /><figcaption>The Author: Nina Braunger (Software Developer)</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac883854c87e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/from-prompt-to-product-spec-driven-development-with-agent-workflows-ac883854c87e">From Prompt to Product: Spec-Driven Development with Agent Workflows</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Secure Service Tokens with Keycloak Token Exchange — Automated with Terraform]]></title>
            <link>https://medium.com/otto-tech/secure-service-tokens-with-keycloak-token-exchange-automated-with-terraform-83bcf775df59?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/83bcf775df59</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[keycloak]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[cloud-security]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 10:39:19 GMT</pubDate>
            <atom:updated>2026-06-30T10:40:38.394Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, you’ll learn how to make service-to-service communication in microservice architectures more secure using Keycloak Token Exchange. It demonstrates how to generate service-specific tokens with the appropriate audience and limited permissions according to the OAuth 2.0 standard — and how the necessary Keycloak configuration can be automated reproducibly with Terraform.</p><p>In modern software development, shaped by microservices and distributed systems, secure authentication and authorization for service-to-service communication are critical. This introduction shows how to secure service tokens using Keycloak’s Token Exchange feature and how to manage the required infrastructure efficiently with Terraform. Keycloak acts as a central identity and access management solution, enabling identity management and orchestrating token exchange for access to protected resources. Automating these complex configurations with Terraform ensures consistency and reproducibility while also supporting agile deployment and maintenance of the security infrastructure.</p><h3>Token exchange explained</h3><p>A token is a digital security certificate that contains the electronic keys required for authentication and authorization. These keys define the rights and access permissions granted to the user, thereby enabling secure access to digital systems.</p><p>Token exchange involves replacing an existing token with general permissions with a new token that is specifically tailored to the requirements of a specific application or service. This aligns with the “need-to-know” principle, as the new token contains only the permissions required for the respective service. If this service is compromised, the new token cannot be used for authorization in other applications or services. The token exchange takes place via a trusted client without requiring any user interaction.</p><h3>Introduction</h3><p>As the central infrastructure team, we provide Keycloak to our development teams to support secure and efficient application development in the context of authentication and authorization. Keycloak handles centralized user identity management. Within Keycloak, we provide each development team with an isolated environment known as a “realm.” In this realm, users, applications (clients), roles, and all associated security and authentication data are managed separately.</p><h4>Standard Token Exchange (RFC 8693)</h4><p>The Token Exchange feature has been available in Keycloak for some time, but until now it has only been available as a preview feature. With the release of Keycloak 26.2, the standard Token Exchange is now officially supported and is fully compliant with the OAuth 2.0 Token Exchange (RFC 8693). Below, I’ll show how the process can be set up with Terraform and executed via a script. (This example demonstrates how Keycloak configurations can be implemented automatically and reproducibly with Terraform. You can find more fundamentals and best practices on this topic in our Terraform series <a href="https://www.otto.de/jobs/de/blogs/techblog/terraform-tipps-skalierbare-und-zuverlaessige-infrastructure-as-code-teil-1/">“Scalable &amp; Reliable Infrastructure-as-Code</a>”)</p><p>In this example, we’ll start a local Keycloak Docker container. A bootstrap script creates a client realm named “web-app” with the client “terraform_client.” This client allows our clients to fully configure their realm using Terraform.</p><p>The following example shows an <em>id_token</em> issued by Keycloak after a successful login, and an <em>access_token</em> used to authorize access to APIs or protected resources.</p><pre>id_token:<br>{<br>  &quot;exp&quot;: 1763711539,<br>  &quot;iat&quot;: 1763711239,<br>  &quot;jti&quot;: &quot;cdbd39ba-f49d-4dbe-98e9-17180f1ededb&quot;,<br>  &quot;iss&quot;: &quot;http://localhost:8080/realms/web-app&quot;,<br>  &quot;aud&quot;: &quot;frontend&quot;,<br>  &quot;sub&quot;: &quot;f817130a-3eea-4c7a-82cd-294d7c29810a&quot;,<br>  &quot;typ&quot;: &quot;ID&quot;,<br>  &quot;azp&quot;: &quot;frontend&quot;,<br>  &quot;sid&quot;: &quot;5d6e3640-8ed6-41e8-896d-415b0a4a949d&quot;,<br>  &quot;at_hash&quot;: &quot;4MUB7cfW_PdsSP2Bj0Y3Lg&quot;<br>}<br><br>access_token:<br>{<br>  &quot;exp&quot;: 1763711539,<br>  &quot;iat&quot;: 1763711239,<br>  &quot;jti&quot;: &quot;onrtro:eb92b411-1619-45c0-91a4-2c2d6a681f26&quot;,<br>  &quot;iss&quot;: &quot;http://localhost:8080/realms/web-app&quot;,<br>  &quot;aud&quot;: &quot;api_gateway&quot;,<br>  &quot;typ&quot;: &quot;Bearer&quot;,<br>  &quot;azp&quot;: &quot;frontend&quot;,<br>  &quot;sid&quot;: &quot;5d6e3640-8ed6-41e8-896d-415b0a4a949d&quot;,<br>  &quot;scope&quot;: &quot;openid audience-scope&quot;<br>}</pre><p>Keycloak makes it possible to specify an audience (“aud”) in the token payload (claims), in addition to the issuer (“iss”), the user (“sub”), and the expiration time (“exp”).</p><p>This audience determines which application the token is intended for. The token is therefore only valid for the service that matches the specified audience and cannot be misused for other services.</p><p>To demonstrate the Token Exchange principle, the following clients are configured in the realm: a frontend client, an API gateway client, and three service clients (Booking, Customer, and Order Service). In addition, an Admin User is created with the corresponding permissions for all client services.</p><h4>Frontend client</h4><p>The frontend client is configured as PUBLIC, which means that no client secret is required for authentication. Full scope is disabled because the required permissions are assigned exclusively via the audience:</p><pre>resource &quot;keycloak_openid_client&quot; &quot;frontend&quot; {<br>    realm_id                     = data.keycloak_realm.web_app.id<br>    client_id                    = &quot;frontend&quot;<br>    name                         = &quot;Frontend&quot;<br>    access_type                  = &quot;PUBLIC&quot;<br>    direct_access_grants_enabled = true<br>    full_scope_allowed           = false<br>}<br><br>resource &quot;keycloak_openid_audience_protocol_mapper&quot; &quot;audience_mapper&quot; {<br>    realm_id                = data.keycloak_realm.web_app.id<br>    client_id               = keycloak_openid_client.frontend.id<br>    name                     = &quot;audience-mapper-api&quot;<br>    included_custom_audience = keycloak_openid_client.api_gateway.name<br>    add_to_access_token      = true<br>    add_to_id_token          = false<br>}</pre><h4>API gateway client</h4><p>The API gateway client is configured as confidential (CONFIDENTIAL) and uses the new Standard Token Exchange feature. This means that authentication requires both the <em>client_id</em> and the <em>client_secret</em>.</p><pre>resource &quot;keycloak_openid_client&quot; &quot;api_gateway&quot; {<br>  realm_id                     = data.keycloak_realm.web_app.id<br>  name                         = &quot;api gateway&quot;<br>  client_id                    = &quot;api_gateway&quot;<br>  client_secret                = &quot;secret&quot;<br>  description                  = &quot;A API gateway client on the<br>destination realm&quot;<br>  access_type                  = &quot;CONFIDENTIAL&quot;<br>  standard_token_exchange_enabled = true<br>}</pre><p>All service clients are configured identically as confidential clients through the Terraform module named service.</p><h4>Admin user</h4><p>For the demo script, an admin user is created and assigned all roles that have been configured:</p><pre>resource &quot;keycloak_user_roles&quot; &quot;user_roles&quot; {<br>  realm_id   = data.keycloak_realm.web_app.id<br>  user_id    = keycloak_user.admin_user.id<br><br>  role_ids = concat(<br>    [for s in local.services : module.service[s.name].service_role_id],<br>    [keycloak_role.frontendAdmin.id]<br>  )<br>}</pre><h3>Demo script</h3><h4>Get frontend token</h4><p>An access token for the user <em>admin </em>with password is requested by the frontend client from the Keycloak server:</p><pre>TOKEN_FRONTEND=$(curl -s $KC_URL \<br>  -H &quot;Content-Type: application/x-www-form-urlencoded&quot; \<br>  -d &#39;username=admin&#39; \<br>  -d &#39;password=realmAdmin&#39; \<br>  -d &#39;grant_type=password&#39; \<br>  -d &#39;client_id=frontend&#39; \<br>  -d &#39;scope=openid&#39; )</pre><p>The received token is decoded and relevant fields are displayed:</p><pre>{<br>  &quot;sub&quot;: null,<br>  &quot;azp&quot;: &quot;frontend&quot;,<br>  &quot;aud&quot;: &quot;api_gateway&quot;,<br>  &quot;resource_access&quot;: null,<br>  &quot;scope&quot;: &quot;openid audience-scope&quot;<br>}</pre><p>The access token contains <em>azp </em>(Authorized Party); <em>sub</em>, as the user’s unique <em>ID</em>, is no longer included by default to keep the token smaller and more efficient. <em>aud </em>(audience) is only <em>api_gateway</em> here, as <em>full scope</em> was not permitted.</p><h4>Token Exchange for the Customer Service</h4><p>The frontend token is exchanged for a new token with the Customer Service audience using the <em>webapp_client</em>.</p><pre>TOKEN_EXCHANGE=$(curl -s $KC_URL \<br>  -H &quot;Content-Type: application/x-www-form-urlencoded&quot; \<br>  -u &quot;api_gateway:secret&quot; \<br>  -d &quot;grant_type=urn:ietf:params:oauth:grant-type:token-exchange&quot; \<br>  -d &quot;subject_token=$TOKEN_FRONTEND&quot; \<br>  -d &quot;subject_token_type=urn:ietf:params:oauth:token-type:access_token&quot; \<br>  -d &quot;requested_token_type=urn:ietf:params:oauth:token-type:access_token&quot; \<br>  -d &quot;audience=CustomerService&quot; | jq -r .access_token)</pre><h4>Access Token</h4><pre>{<br>  &quot;sub&quot;: &quot;0384647c-51d7-4999-a534-cb09c67dda1d&quot;,<br>  &quot;azp&quot;: &quot;api_gateway&quot;,<br>  &quot;aud&quot;: &quot;CustomerService&quot;,<br>  &quot;resource_access&quot;: {<br>    &quot;CustomerService&quot;: {<br>      &quot;roles&quot;: [<br>        &quot;write&quot;<br>      ]<br>    }<br>  },<br>  &quot;scope&quot;: &quot;profile email&quot;<br>}</pre><p>The exchange token now includes the audience <em>CustomerService</em> and only grants write access to that service. With “<em>sub</em>,” it can be uniquely assigned to a user.</p><h4>Token Exchange for the Booking Service</h4><p>The frontend token is exchanged for a new token with the audience Booking Service using the <em>webapp_client</em>.</p><pre>TOKEN_EXCHANGE=$(curl -s $KC_URL \<br>  -H &quot;Content-Type: application/x-www-form-urlencoded&quot; \<br>  -u &quot;api_gateway:secret&quot; \<br>  -d &quot;grant_type=urn:ietf:params:oauth:grant-type:token-exchange&quot; \<br>  -d &quot;subject_token=$TOKEN_FRONTEND&quot; \<br>  -d &quot;subject_token_type=urn:ietf:params:oauth:token-type:access_token&quot; \<br>  -d &quot;requested_token_type=urn:ietf:params:oauth:token-type:access_token&quot; \<br>  -d &quot;audience=BookingService&quot; | jq -r .access_token)</pre><p>In this example, <em>BookingService</em> is the audience, which enables write access to this service.</p><pre>{<br>  &quot;sub&quot;: &quot;0384647c-51d7-4999-a534-cb09c67dda1d&quot;,<br>  &quot;azp&quot;: &quot;api_gateway&quot;,<br>  &quot;aud&quot;: &quot;BookingService&quot;,<br>  &quot;resource_access&quot;: {<br>    &quot;BookingService&quot;: {<br>      &quot;roles&quot;: [<br>        &quot;write&quot;<br>      ]<br>    }<br>  },<br>  &quot;scope&quot;: &quot;profile email&quot;<br>}</pre><h3>Conclusion</h3><p>The current Keycloak Terraform provider, which is updated regularly, makes it easy to implement new features such as Standard Token Exchange. Token exchange provides important security benefits: it replaces a token with broad permissions with a service-specific token that contains only the permissions required by the target service (need-to-know principle). This reduces the potential impact of a compromise, as the token cannot be reused for other applications or services.</p><p>We welcome feedback and suggestions in the comments. ⬇️</p><p>And if you’d like to learn more about secure infrastructure and the protection of sensitive information, we also recommend taking a look at our article <a href="https://www.otto.de/jobs/de/blogs/techblog/sensible-daten-sicher-verwalten-mit-hashicorp-vault/">“Securely Managing Sensitive Data with HashiCorp Vault</a>.”</p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/en/blogs/techblog/">Techblog</a>.</p><figure><img alt="Image of the author Andreas Nacke in a blue shirt in front of a green natural background" src="https://cdn-images-1.medium.com/max/1024/1*e5h1xN6p7dXnHCNybVWcog.jpeg" /><figcaption>The Author: Andreas Nacke (Senior IT Administrator)</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83bcf775df59" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/secure-service-tokens-with-keycloak-token-exchange-automated-with-terraform-83bcf775df59">Secure Service Tokens with Keycloak Token Exchange — Automated with Terraform</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Software Development –
How AI Agents Are Transforming Our Engineering]]></title>
            <link>https://medium.com/otto-tech/ai-software-development-how-ai-agents-are-transforming-our-engineering-3851b8d247c8?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/3851b8d247c8</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[agentic-ai-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Fri, 15 May 2026 09:40:59 GMT</pubDate>
            <atom:updated>2026-05-15T09:43:00.092Z</atom:updated>
            <content:encoded><![CDATA[<p>The article demonstrates how OTTO is transforming its software development from traditional coding to <strong>AI-assisted engineering: Spec-driven development, Git-controlled architecture (ADRs, C4 models)</strong>, and an ecosystem of s<strong>pecialized AI agents (Copilot, LLMs) are creating</strong> more efficient development processes for <strong>microservices</strong>. The focus is shifting from code creation to <strong>system design, precise specifications, and AI-assisted review</strong>, resulting in significant improvements in quality, speed, and scalability.</p><h3>Do you still have a Stack Overflow tab open? Or the AWS SDK documentation?</h3><p>In the past, software developers who wrote code were constantly stuck poring over documentation, Stack Overflow, and similar sites. Today, those tabs are usually closed — not because we suddenly know every library by heart, but because the way we develop software has fundamentally changed.</p><p>In the logistics domain, we design and operate event-driven microservices on AWS: Lambda, API Gateway, DynamoDB, SNS, SQS, Kafka, and S3 — completely serverless, optimized for runtime, and closely integrated with the AWS SDKs. To illustrate the scale of this architectural challenge: Through just one of our synchronous HTTP APIs, we process several billion updates every month. These are rudimentarily validated in the API (Do we recognize the ID? Is the value within the valid range?) and acknowledged immediately with qualified feedback. The data then flows asynchronously into our underlying domain logic and is processed further in a matter of milliseconds.</p><p>How we scale this system landscape and operate it in a fail-safe manner could fill an entire article on cloud architecture. But this post focuses on something else: how we, as an engineering organization, develop these services.</p><p>Pure <em>AI software development</em> has evolved into true <strong>AI-assisted engineering </strong>— and along the way, AI has shifted from a tool to being a partner.</p><h3>Hi, AI. Nice to meet you.</h3><p>The first real change was subtle. We worked in the classic pair programming setup: two developers, one problem, one screen. At some point, a third partner joined us. The pair became a mob —<strong> human, human, AI.</strong></p><p>The countless browser tabs for SDK documentation disappeared because it was simply more efficient to type the question directly into the Copilot chat. The cognitive disruption caused by constant context switching was eliminated. That alone noticeably accelerated our development speed and significantly shortened time-to-market.</p><h3>Vibe Coding — The agent takes over</h3><p>With GitHub Copilot and Agent Mode — which is a standard at our company — we’ve entered what is often called “vibe coding” today, marking the next stage of AI software development. We work with the AI in an iterative and exploratory manner, selecting the LLM (ChatGPT, Gemini, Claude, etc.) directly within the IDE based on the task at hand: one model excels at system design, while another is better suited for writing scripts.</p><p>At first, we had a clear rule: <strong>blindly adopting AI results is not an option</strong>. Nothing has changed in that regard — our company guidelines are unambiguous on this point. However, with increasingly powerful models, our focus is shifting noticeably: from writing code ourselves to critical review. The decisive lever here lies not in the code, but in the way we communicate our requirements to the AI.</p><h3>The Five Pillars — How we bring architecture to life</h3><p>At some point, vibe-coding reached its limits. The realization: <strong>AI is only as good as the context we provide it with</strong>. This is where spec-driven development comes in. For us, this means more than just “first a ticket, then code.” It is the connecting element between architecture, code, and AI.</p><p>To make these standards scalable, we solved a long-standing problem: architectural decisions used to be scattered across Confluence — without versioning, without integration into the review process. Today, our architecture is entirely in Git. It is no longer documentation <em>about the </em>system, but <strong>part of the system itself</strong>.</p><p>A crucial factor here: All these documents — especially our Architecture Decision Records (ADRs), C4 models, and ACCs — follow a strict structure and a fixed nomenclature. Only when terms and formats remain consistent can the AI process the context without room for misinterpretation.</p><p>Our architecture rests on five pillars:</p><h4>1. Engineering Constitution — “What we believe”</h4><p>At the heart of our architecture repository lies <em>basis-constitution.md</em>: our binding constitution. It defines global architecture and security standards, such as “serverless-first” and compliance with the OWASP Top 10. Its most important rule: <em>Write the specification before you write code</em>. Each service constitution may expand upon this constitution, but must never weaken it.</p><h4>2. Architecture Decision Records (ADRs) — “Why we made this decision”</h4><p>Every significant decision — whether it’s migrating from SNS to Kafka or switching technologies — is documented in Git as Markdown following a strict template. Thanks to this consistent, structured format of the ADRs, the AI agent accurately interprets the technical context and trade-offs. Every principle in the Constitution refers directly to these underlying ADRs — transparent for both developers and the AI.</p><h4>3. C4 Models — “As it looks”</h4><p>We visualize our architecture using C4 and have automated this process at the context, container, and component levels using PlantUML and our pipeline. In doing so, we deliberately distinguish between <em>the current state and our vision</em>: the diagrams show not only where we are now, but also where we want to go. (<em>Recommended reading: </em><a href="https://www.otto.de/jobs/de/blogs/techblog/softwarearchitektur-visualisieren-mit-c4-modell/"><em>You can read </em></a><em>on how we generally use C4 models at OTTO </em><a href="https://www.otto.de/jobs/de/blogs/techblog/softwarearchitektur-visualisieren-mit-c4-modell/"><em>in this tech blog article.</em></a>)</p><h4>4. Architecture Communication Canvas (ACC) — “The value we deliver”</h4><p>Not every stakeholder wants to read diagrams. ACCs translate technical systems into business value: value proposition, quality requirements, stakeholders. Thanks to this standardized template, the AI agent knows exactly where to find the technical context for each service.</p><h4>5. Service Specs — “What we’re building right now”</h4><p>Before any code is written, features are described in detailed service specifications: user stories, acceptance criteria, data models, and tasks. The sequence is mandatory: <strong>tests first, then implementation</strong>. Only on this structured foundation does the AI generate production-ready code — without having to guess.</p><h3>Specialized agents as the next level</h3><p>Building on this structured foundation, we no longer work solely with a generic assistant, but with a small ecosystem of specialized agents.</p><p>An Architecture Agent validates architectural decisions against the Constitution, ADRs, C4 models, ACCs, AWS Well-Architected Pillars, and domain boundaries. Building on this, an Implementation Agent implements spec-driven development and guides the process from Specify through Clarify and Plan to Implementation. A Review Agent checks the generated code against specifications, plans, architecture, and security requirements before a PR is created. And a general Story Agent can formulate new Jira stories from existing knowledge or improve existing stories.</p><p>The benefit lies not only in automation, but in the clear division of responsibilities. Architecture, implementation, review, and story formulation speak the same language while operating in specialized roles. This increases quality without making the workflow more cumbersome, and it allows knowledge to be reused and scaled more effectively.</p><figure><img alt="Eine KI-Agenten-Architektur mit Orchestrator, Architektur-Agent, Code-Agent, Review-Agent und Jira-Integration, die eine spezifikationsgesteuerte Entwicklung und automatisierte Software-Engineering-Workflows ermöglicht." src="https://cdn-images-1.medium.com/max/780/0*JNqPRqB5Souj05fy.png" /><figcaption><em>A look inside our architecture repository: Constitutions, ADRs, C4 models, and ACCs exist as versioned code in Git</em></figcaption></figure><h3>The AI angle — Copilot as an Architecture Guardian</h3><p>How does this work in practice? In every service repository, the agents access the same structured knowledge base via ‘copilot-instructions.md’, the Constitution, C4 models, and ACCs. This not only provides spec-driven development with better inputs, but also enables the agents themselves to perform architecture, implementation, and review within a shared set of rules.</p><p>Our set of rules is clear: When fundamental changes are made — for example, to infrastructure via Terraform or to domain boundaries in the context of Domain-Driven Design — the corresponding architectural artifacts must be updated. This ensures that the architecture remains not only documented but also consistent with the actual implementation.</p><p>GitHub Copilot can act as a reviewer in this process. If a specification or documentation is missing, the AI doesn’t simply block the process; ideally, it generates a draft directly. As a result, governance doesn’t become a hindrance, but an integral part of the development flow.</p><h3>A real-world example from our engineering practice</h3><p>A live incident was detected due to anomalies in API behavior: elevated 4xx error rates were observed in the AWS API Gateway. Our goal was to enhance monitoring and receive proactive alerts through existing channels should this issue recur. No further context was available at first.</p><p>From this point on, the specialized agents worked together:</p><ul><li><strong>Analysis</strong>: The Story Agent used the Architecture Agent and the Code Agent to examine the existing architecture and metrics.</li><li><strong>Solution Proposal</strong>: The agents recognized that the API Gateway already provides suitable standard metrics and proposed two CloudWatch alarms: one for 4xx, one for 5xx errors.</li><li><strong>Technical Clarification</strong>: The appropriate thresholds were determined in consultation with the experts and documented directly in the ticket.</li><li><strong>Implementation &amp; Approval</strong>: The finished story was sent to the Implementation Agent, including an AI review. A final human review approved the changes for automatic deployment.</li></ul><p><strong>The result</strong>: from live incident to production deployment, including documentation, the process took less than 30 minutes — and all code was generated by AI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/182/1*_r5OguS9Rvsob_bnyLKFtw.png" /><figcaption><em>AI-powered workflow for responding to a live incident</em></figcaption></figure><h3>Outlook — Specialized Agents and networked context</h3><p>While we have established architecture governance using Git, the next level of automation is already on the horizon: no longer a single general-purpose agent, but a small ecosystem of specialized agents that are already being tested in practice.</p><p>One agent possesses comprehensive architectural knowledge and can reliably integrate ADRs, C4 models, and ACCs. Another specializes in formulating clean Jira stories and specifications from domain-specific input or improving existing stories. Yet another can derive the technical plan based on this, while taking our architectural guidelines into account.</p><p>MCP is a potential integration layer for connecting these agents to our knowledge sources in a structured way. For me, however, the decisive factor is not the individual technology, but rather that the agents access the right sources in a networked manner and, by working together, deliver better results than a general-purpose assistant.</p><p>The actual work then takes place in the background via the networked context:</p><ol><li>The agent reads the ticket and jumps to the parent ticket — that is, the epic — to understand the business context.</li><li>If necessary, it pulls in linked Confluence pages to incorporate business value, KPIs, or diagrams.</li><li>At the same time, it takes into account the relevant architecture artifacts from Git: base constitution, service-specific constitution, and ADRs.</li><li>Based on this knowledge, it generates or refines the formal specification.</li><li>Based on the specification, the technical plan can then be developed, with us as developers and architects intervening only where there is genuine room for decision-making.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l-UK6a5jF9x8EjVgLZT7Cg.png" /><figcaption><em>AI agent architecture with an orchestrator, architecture agent, code agent, review agent, and Jira integration</em></figcaption></figure><h3>Conclusion: What this means for us — and for other OTTO teams</h3><p>The key takeaway: <strong>the era of simply writing code is over</strong>. AI software development is becoming the new standard — <strong>and is evolving into true AI-assisted engineering</strong>.</p><ul><li>From<strong> implementer to system designer and reviewer</strong>. The focus is shifting: it’s about getting to the heart of technical problems, clearly defining system boundaries, and reviewing the code generated by AI as a critical quality control measure.</li><li>Precise <strong>specifications as the most important programming language</strong>. If you set vague requirements, you get vague code — or, in the worst case, AI hallucinations (<em>Recommended reading: </em><a href="https://www.otto.de/jobs/de/blogs/techblog/technical-writing-gegen-ki-halluzinationen/"><em>we’ve described here how good technical writing helps with this</em></a>). Actively use your Jira tickets and architectural decisions as input for your LLMs.</li><li>Establish clear <strong>guardrails</strong>. Don’t assume that AI knows company policies or security standards on its own. Document your architecture and security rules in a machine-readable format so they serve as a reliable framework for developers and agents alike.</li><li>Invest in <strong>automated testing pipelines</strong>. Whether you use strict trunk-based development or take a different approach: a high degree of test automation and reliable CI/CD pipelines are the best way to safely bring AI to the forefront.</li></ul><figure><img alt="CI/CD-Pipeline für KI-generierten Code mit automatisierten Test-, Build- und Bereitstellungsabläufen, die für Zuverlässigkeit in serverlosen AWS-Mikroservice-Umgebungen sorgt." src="https://cdn-images-1.medium.com/max/1024/1*U9YdHpro4CIKuU1xDec3VA.png" /><figcaption><em>No trust in AI code without safeguards</em></figcaption></figure><p>Our job as tech experts is to set clear guidelines that ensure the code we generate delivers real, scalable business value for OTTO. AI doesn’t make us obsolete — it makes us more effective. The technology is ready. Now it’s our turn.</p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/de/technology/techblog/?navid=925027925027%3Futm_source%3Dmedium&amp;utm_medium=organic&amp;utm_campaign=techblog">Tech Blog</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NXNvs3f1bfivAinQbOXx4g.jpeg" /><figcaption>The Author: Jav Vesper (Software Developer, Architect and Technical Lead)</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3851b8d247c8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/ai-software-development-how-ai-agents-are-transforming-our-engineering-3851b8d247c8">AI Software Development –
How AI Agents Are Transforming Our Engineering</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why AI Hallucinates — and
What Technical Writing
Can Do About It]]></title>
            <link>https://medium.com/otto-tech/why-ai-hallucinates-and-what-technical-writing-can-do-about-it-d7dc78a41b6b?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7dc78a41b6b</guid>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[ai-hallucination]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Wed, 22 Apr 2026 06:42:44 GMT</pubDate>
            <atom:updated>2026-04-22T06:59:46.341Z</atom:updated>
            <content:encoded><![CDATA[<p>Technical documentation is often a tedious chore that gets put off indefinitely. But in an era where AI is rapidly integrating into our workflows, the quality of our content is taking on a whole new meaning. What if the “AI hallucination problem” is actually a “content problem” at its core? This post provides insights into how the special skills of technical writers are no longer just “nice to have,” but essential for the successful and reliable use of artificial intelligence.</p><p>What makes technical documentation good? For decades, the answer was clear: it must work for humans. Now, Artificial Intelligence is on the rise. And suddenly, technical writing is clearly becoming an efficiency factor.</p><p>Because when AI encounters poor documentation, what everyone knows but no one wants happens: AI hallucinates. Someone asks the AI assistant for the deployment process. What comes back is an instruction cobbled together from three different, partly outdated documents. It sounds plausible, but it doesn’t work. This isn’t an AI problem. This is a content problem.</p><h3>Better content for everyone</h3><p>The principles that technical writers have always applied to make documentation usable for humans are precisely what AI systems need to work accurately: consistent terminology, clear structure, comprehensible hierarchies, and explicit metadata.</p><p>But what is good for humans doesn’t automatically work the same way for AI. As technical writers at OTTO, we are currently seeking the balance: What should content look like so that humans want to read it and machines can process it? We are still experimenting, but we are heading in the right direction.</p><h3>What technical writers do and why AI loves it</h3><h3>Consistent terminology</h3><p>Consistent language helps humans read and AI find information. If one document speaks of “user,” the next of “client,” and a third of “customer” and “end-user” — all meaning the same thing — then the AI will only find a fraction of the relevant information. Consistency is key: one term, one concept, consistently applied. Inconsistent terms are one of the most common drivers for AI hallucinations, because the model doesn’t recognize that four words mean the same thing.</p><h3>Structured hierarchies</h3><p>Without a clear structure, documentation is useless, no matter how good the content is. Structured hierarchies mean: meaningful headings, logical sections, and a well-thought-out document design. Each topic gets its own section.</p><p>Example: Instead of “Our service does A, B, and C and is deployed this way, and if there are problems, you do X,” it’s better like this:</p><ul><li>Purpose: What the service does</li><li>Architecture: How the service is built</li><li>Deployment: How to deploy the service</li><li>Troubleshooting: What to do in case of problems</li></ul><p>This allows humans to easily skim through the text instead of having to read everything laboriously. AI can process the context and jump precisely to the relevant section.</p><h3>Standardized formats and metadata</h3><p>The AI’s nightmare: freestyle Markdown here, a Word document there, screenshots in chat, and all without a version number or timestamp. Instead, defined templates, for example, for READMEs, decisions, and runbooks, work well. If all READMEs have the same structure (e.g., Purpose — Structure — Requirements — Development), humans know where to look, and AI can specifically find the relevant information.</p><p>In addition, there are metadata: timestamps, status labels such as “outdated” or “to be reviewed,” and thematic tags. Without this information, AI is left in the dark. With metadata, it can classify: Is this still current? Does it fit the use case? Humans use it for filtering, AI uses it to decide.</p><h3>Precise code examples with context</h3><p>It’s not: “Run Terraform, replace the values”,<br>but instead: A structured code block with syntax highlighting, explanations, and precise placeholders:</p><pre># Run Terraform with the desired environment<br>terraform apply -var=&quot;ENVIRONMENT={YOUR_ENV}&quot;</pre><p>AI understands syntax, context, and can provide correct code suggestions. Humans can use “copy-paste.”</p><h3>What we are learning at OTTO</h3><p>Documentation is often an afterthought in the development process and, like in many other companies, frequently neglected. It exists, sometimes well, sometimes not. Each team has its own structure, its own storage location, its own processes, and its own writing styles. Over the years, people have found their ways: they knew whom to ask, where to search, and how to piece together information the hard way. That somehow worked.</p><p>Of course, many want to use AI as an aid and efficiency boost. But it doesn’t work that easily yet. AI hallucinates, doesn’t find information, or searches in places where nothing is stored. What people with enough experience could still manage, AI mercilessly exposes: the gaps, the inconsistencies, the fragmentation.</p><p>Technical writers use their skills to make technical documentation AI-ready. Some things already work: clear structures, consistent terms, and current content. Others don’t: Short sentences? Good for humans, but AI sometimes needs more context. Avoiding repetitions? Annoying when reading, but helpful for AI. How do we reconcile this? These are open questions we are working on.</p><h3>What this means in practice</h3><p>An example from our daily work as technical writers: We originally created our how-tos and templates for humans. First insight: AI can already work really well with them. So we are currently testing building prompts and agents based on this to do preliminary work for us: gathering information, suggesting structures, and pre-filling templates. Authors can then concentrate on the technical content instead of starting from scratch. Boom: time saved!</p><p>We also notice that structure and documentation are correct through things like this:</p><ul><li>Familiarization with a new service: Devs ask GitHub Copilot for a setup process; AI finds the structured README and provides precise answers.</li><li>Retrieving knowledge: Instead of chat archaeology, the AI finds the information in a central location in a document.</li><li>Consistency: AI generates according to uniform standards because the guidelines are clearly written.</li></ul><p>Technical writers create a solid foundation here.</p><h3>Is your AI still hallucinating, or have you already started structuring?</h3><p>The question is not whether AI will become part of our daily lives. It already is. The question is: Is the content ready for it? These signs indicate a need for action:</p><ul><li>AI systems deliver inconsistent results, even though relevant knowledge exists within the company.</li><li>Onboarding and information gathering take weeks instead of days because documentation is fragmented.</li><li>Knowledge transfer depends on individuals instead of accessible documentation.</li></ul><p>Technical writing is not a fix for bad AI models. But it is a lever: Do you remember the bewildered person at the beginning of the post who was looking for the deployment process? With structured documentation, they no longer get a hallucinated patchwork, but the current instructions. Not because the AI got smarter, but because the content already was.</p><p>Technical writers don’t just write. They develop knowledge that works — for humans and AI. Those who invest in structured documentation today will be ready for what comes tomorrow.</p><p>Find this one and more interesting articles in our <a href="https://www.otto.de/jobs/de/technology/techblog/?navid=925027925027%3Futm_source%3Dmedium&amp;utm_medium=organic&amp;utm_campaign=techblog">Tech Blog</a>.</p><figure><img alt="author Birgit in front of a industrial wall, wearing a blazer" src="https://cdn-images-1.medium.com/max/1024/1*Jch_EbZN_140IjGIEGQtpQ.jpeg" /><figcaption>Author: <a href="https://www.otto.de/jobs/de/blogs/techblog/autoren/birgit/">Birgit</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7dc78a41b6b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/why-ai-hallucinates-and-what-technical-writing-can-do-about-it-d7dc78a41b6b">Why AI Hallucinates — and
What Technical Writing
Can Do About It</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Terraform Tips: Securing Infrastructure-as-Code with Terratest
 — Part 3]]></title>
            <link>https://medium.com/otto-tech/terraform-tips-securing-infrastructure-as-code-with-terratest-part-3-8795cc339714?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/8795cc339714</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 16:14:36 GMT</pubDate>
            <atom:updated>2026-05-15T09:46:58.694Z</atom:updated>
            <content:encoded><![CDATA[<p>The third part of the Terraform series focuses on testing <strong>Terraform Infrastructure-as-Code (IaC)</strong>. At OTTO IT, many teams use Terraform to effectively orchestrate, automate and manage their <strong>cloud infrastructure</strong>. As with normal application code, it is crucial <strong>not to neglect testing</strong>, especially when it comes to Terraform modules. This ensures that deployments are stable and error-free. In this article, you will learn the basics of <strong>testing with Terraform</strong> and get practical best practices for your workflow.</p><h4><strong>Terraform Tips Series:</strong></h4><ul><li><a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/terraform-tips-scalable-and-reliable-infrastructure-as-code-part-1.php">Part 1: Scalable &amp; Reliable Infrastructure-as-Code</a></li><li><a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/terraform-tips-scalable-and-reliable-infrastructure-as-code-part-2.php">Part 2: Terraform Best Practices: Structure for Scalable Infrastructure as Code</a></li></ul><h3><strong>Why is testing IaC important?</strong></h3><p>Testing in the IaC context ensures that Terraform modules work as intended before they are deployed in production. It helps to:</p><ul><li>Detect errors early on</li><li>Improve code maintainability</li><li>Increase the reliability of deployments</li></ul><p>Automated testing prevents changes to the infrastructure from leading to unexpected problems — and thus to costly downtime.</p><h3><strong>How does testing Terraform differ from classic application testing?</strong></h3><p>While traditional testing focuses on business logic, testing infrastructure code often requires the provision of real cloud resources. However, a complete end-to-end test is usually too time-consuming and costly. Pure unit tests, on the other hand, are not sufficient.<br> <br>The solution: divide your architecture into modules and test them individually. This creates an iterative, cost-efficient development approach that detects errors early on and ensures quality.</p><h3><strong>What tools are available for testing infrastructure-as-code?</strong></h3><p>There are many testing frameworks that can assist with testing infrastructure-as-code. In addition to the Hashicorp variant, these include Terratest and Kitchen-Terraform. In this article, we will focus on Terratest, a popular Go-based framework for automated testing of Terraform modules.</p><h3><strong>Testing Terraform files — step by step</strong></h3><h4><strong>Determine your test environment</strong></h4><p>During testing, resources are created and deleted. To avoid accidental deletions, it is<br>recommended to use a separate development environment that is separate from Dev, Stage, and Live.<br> <br> Best practices:</p><ul><li>Each test should be independent and not use a shared state.</li><li>Use separate service accounts for each test run.</li><li>Example directory structure:</li></ul><figure><img alt="white computercode on black background: Terraform module structure with Terratest tests" src="https://cdn-images-1.medium.com/max/534/1*I1G_fjTKpFCn_CyzMXIJWg.jpeg" /><figcaption>Terraform module structure with Terratest tests</figcaption></figure><h4><strong>Start with “go test”</strong></h4><p>First, install Go and set up Terratest according to <a href="https://terratest.gruntwork.io/docs/getting-started/quick-start/">QuickStart</a>. Then you can run your tests with the command “go test” and check whether the infrastructure is provisioned as expected.</p><h4><strong>Write your tests</strong></h4><p>In your test files, you define assertions that check the resources created — similar to manual checks (e.g. “Is port 22 open?”).<br> <br>Typical assertions:<br> <br> • Existence of certain resources (e.g., EC2 instance, security group)<br> • Properties of the resources (e.g., SSH access allowed)<br> • Validation of the module’s outputs<br> <br> Examples for AWS, Google, and Azure can be found <a href="https://github.com/gruntwork-io/terratest/tree/main/test">here</a>.</p><h4><strong>Run your tests</strong></h4><p>After writing the tests, they are executed using go test. The tool provides immediate feedback on<br> whether the infrastructure has been deployed correctly. Errors are displayed immediately, which<br> makes troubleshooting much easier.</p><h4><strong>Automate your tests with CI/CD</strong></h4><p>To make tests an integral part of your workflow, integrate them into your CI/CD pipeline — e.g.<br> with GitHub Actions.</p><h3><strong>Best practices for integrating Terratest into CI/CD:</strong></h3><ul><li>Use unique prefixes/suffixes for resources to decouple parallel test runs.</li><li>Use a remote backend (GCP Storage or AWS S3) for the Terraform state.</li><li>Set fixed test timeouts to avoid hanging jobs.</li><li>Automate clean-up with “terraform destroy” to avoid unnecessary costs.</li></ul><p><a href="https://github.com/gruntwork-io/terragrunt-action">Here</a> is a simple example of a GitHub Actions configuration.</p><h3><strong>Outlook</strong></h3><p>Testing is a key component of a reliable and scalable infrastructure-as-code strategy. Whether you are just getting started with Terraform or want to optimise existing processes, automated testing and its integration into CI/CD ensure the quality and stability of your infrastructure.</p><h3><strong>FAQ</strong></h3><p><strong>What is Terratest?</strong><br>Terratest is a Go-based framework for automated testing of Terraform modules and<br> infrastructure-as-code deployments.<br> <br><strong> How do you test Terraform modules?</strong><br>Terraform modules can be tested with tools such as Terratest by deploying, verifying, and then destroying infrastructure.<br> <br><strong>Why is Terraform testing important?</strong><br>Automated testing detects errors early and prevents faulty infrastructure deployments.</p><p><strong>Further links</strong></p><ul><li><a href="https://cloud.google.com/docs/terraform/best-practices/testing">Best Practices for testing</a> (Google)</li><li><a href="https://terratest.gruntwork.io/docs/#testing-best-practices">Documentation — Learn how to work with Terratest.</a> (Terraform)</li><li><a href="https://developer.hashicorp.com/terraform/tutorials/configuration-language/test">Write Terraform Tests</a> (HashiCorp)</li></ul><p>👉 Read this one and more interesting articles on our <a href="https://www.otto.de/jobs/en/technology/techblog/?navid=925027925027">Tech Blog</a>.</p><figure><img alt="Nina, Tech Blog Autor on her Desk" src="https://cdn-images-1.medium.com/max/1024/1*dtCSxk5u_f9A-egsyLmQXg.jpeg" /><figcaption>Author: <a href="https://www.otto.de/jobs/de/technology/techblog/autoren/nina-braunger.php">Nina</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8795cc339714" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/terraform-tips-securing-infrastructure-as-code-with-terratest-part-3-8795cc339714">Terraform Tips: Securing Infrastructure-as-Code with Terratest
 — Part 3</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data-Driven Team Development — How OTTO Leads Tech Teams to Success]]></title>
            <link>https://medium.com/otto-tech/data-driven-team-development-how-otto-leads-tech-teams-to-success-dedad888d30f?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/dedad888d30f</guid>
            <category><![CDATA[team-effectiveness]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[team-development]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 08:33:21 GMT</pubDate>
            <atom:updated>2026-02-04T07:35:33.334Z</atom:updated>
            <content:encoded><![CDATA[<h3><em>Data-Driven Team Development</em> — How OTTO Leads Tech Teams to Success</h3><h3>How To Masure Team Effectiveness</h3><p>In today’s working world, teams are essential to the success of companies and organizations. Therefore, there has always been an effort to support teams in their development towards greater effectiveness in order to make them more efficient. In large organizations in particular, this can be a challenging task due to the large number and diversity of teams. OTTO is not the only company thinking about meaningful approaches to measuring and developing team effectiveness. So how can team effectiveness be measured in a scaled environment? What role can measurement play in identifying specific areas for action in team development? At OTTO, we have developed and established a tool for this purpose in recent years, which enables us to take a data-based look at the topic of team development and drive the development of our tech teams in a target-oriented manner.</p><h3>Why a Custom Approach? Team Development Between Theory and Practice</h3><p>A very well-known model that has been widely used for many years is Tuckman’s team clock model (Tuckman, B. W. (1965). Developmental sequence in small groups.<em> Psychological Bulletin, 63</em> (6), 384–399.), which describes team development as a sequence of different phases. According to this model, an initial formation phase in teams is followed by a storming phase in which conflicts and tensions arise, before common values and norms are developed in the norming phase. Only then, according to this model, does the phase in which a team actually performs come. The classification of a team in the “team clock” is not based on quantitative measurements, but solely on observations. Phase models such as Tuckman’s offer qualitative guidance, but leave the concrete effectiveness of teams in the work context largely open. Accordingly, approaches that focus more on measurability, productivity, and working conditions of teams have become established in recent years.</p><h4>Established Frameworks to Measure Team Effectiveness</h4><p>A more technical perspective and starting point for team development is provided by the <strong>DORA </strong>framework (<a href="https://cloud.google.com/resources/content/2025-dora-ai-capabilities-model-report">https://cloud.google.com/resources/content/2025-dora-ai-capabilities-model-report</a>). This approach, which is specifically geared toward software development teams, is based on a model that predicts organizational performance using four technical metrics. The standardized collection of these key figures offers a number of advantages, but completely ignores the consequences of ongoing stress within the team and the influence of collaboration practices. This fact has led to a number of further developments.</p><p>One of the resulting developments is the <strong>SPACE </strong>framework (Forsgren, N., Storey, M.-A., Maddila, C., Zimmermann, T., Houck, B., &amp; Butler, J. (2021). The SPACE of Developer Productivity. <em>Communications of the ACM, 64</em>(6), 46–53.) for measuring team productivity. Based on the findings of the DORA framework, SPACE includes metrics on efficiency and performance as well as well-being and satisfaction, communication and collaboration, and the quantity of work results to ultimately assess team productivity. This framework therefore takes into account various dimensions of team productivity, not only those that can be measured quantitatively. In particular, the emphasis on the importance of employee satisfaction and well-being was a novelty and is being intensified in the work of subsequent frameworks.</p><p>One example of this is the <strong>DevEx </strong>framework (Noda, A., Storey, M.-A., Forsgren, N., &amp; Greiler, M. (2023). DevEx: What actually drives productivity? <em>Communications of the ACM, 66</em>(11), 44–49.). DevEx stands for “Developer Experience.” This approach focuses specifically on the work experiences of software developers and pursues the thesis that anything that makes the work of software developers more enjoyable or their environment more suitable increases overall productivity. Three components are recorded: flow state, feedback loops, and cognitive load. Outputs or outcomes are not recorded within the DevEx framework. The entire “developer experience” is recorded using qualitative surveys. In contrast to DORA and SPACE, the DevEx framework focuses on recording the quality of the framework conditions for software developers. Instead of directly measuring performance in terms of output or outcomes, the framework thus focuses entirely on factors that determine this performance.</p><h4>From Established Frameworks to a Model of Our Own</h4><p>The findings from DORA, SPACE, and DevEx have now been combined and further developed in DX’s Core 4 framework. Core 4 is a mixture of the previous approaches and identifies four core constructs: speed, effectiveness, quality, and impact.</p><p>At OTTO, we have made use of these findings and established frameworks, combining them with extensive literature research on the current state of team development and team effectiveness to develop our own team development model. This model now serves as the basis for regularly measuring the effectiveness of over 100 teams and forms the basis for decisions within the teams and for organization-wide processes for the distribution of team developers. We would like to describe these two aspects, our team development model and the process for measuring team effectiveness and the team development measures derived from it, in more detail below.</p><h3>The OTTO IT Team Development Model</h3><p>The development of a team does not usually follow a linear progression, nor can we ensure that our international IT teams will work together in the same constellation for long enough to go through all the phases up to “performing” as defined by Tuckman’s team clock. It is therefore very important for us to systematically and specifically assess the current development status of our teams in each phase of team development so that we can use these findings to focus on the strengths and potential of each team. We have therefore decided against a phase model and, similar to the SPACE and Core 4 frameworks, focus on the results and effects of teamwork, which we describe as effectiveness. As in these models, we focus on the well-being of employees and their performance in terms of work results. In addition, our definition of effectiveness also includes the viability of the team, as in today’s complex working world, the adaptability of teams is a key success factor for long-term economic success.</p><p>Furthermore, we believe that results and employee satisfaction in our work context cannot be predicted solely on the basis of technical metrics, as envisaged by the DORA framework. Instead, at OTTO, we pursue a mixed assessment approach similar to the DX Core 4 productivity framework.</p><p>Our team development model, which is shown in <strong>Figure 1</strong>, is based on the <em>Input-Mediator-Output (IMO)</em> framework, as are numerous other team effectiveness models.</p><figure><img alt="Graphic with three vertical colored columns. On the left is a green column with three white boxes arranged one below the other. In the middle is a blue column with four white boxes. On the right is a red column with three white boxes. Thin lines connect the boxes from left to right. To the left outside the graphic is a box labeled “Organization,” and to the right is a box labeled “Team Effectiveness.”" src="https://cdn-images-1.medium.com/max/1024/1*6551AI75TVDCoXbbIa2U_w.png" /><figcaption>Team Development Model © 2024 by OTTO GmbH &amp; Co. KGaA is licensed under CC BY-NC-SA 4.0</figcaption></figure><p>The model comprises three pillars: the <strong>framework </strong>conditions of the team as<em> input </em>variables, <strong>performance factors</strong> as <em>mediators</em>, and <strong>effectiveness </strong>as <em>output</em>. This representation of the impact structure is based on the assumption that the framework conditions determined by the organization influence the effectiveness of a team through various processes (e.g., <em>teamwork and taskwork</em>). Since the mediators are not exclusively processes (cf.<em> I-P-O model</em>), but also states within the teams (e.g., trust or psychological safety), the underlying model can be described as an IMO model. This structure underlies numerous scientifically researched models on the effectiveness of teams (Ilgen, D. R., Hollenbeck, J. R., Johnson, M., &amp; Jundt, D. (2005). Teams in organizations: From input-process-output models to IMOI models. <em>Annual Review of Psychology, 56</em>, 517–543.; Mathieu, J., Maynard, M. T., Rapp, T., &amp; Gilson, L. (2008). Team effectiveness 1997–2007: A review of recent advancements and a glimpse into the future. <em>Journal of Management, 34</em>(3), 410–476.), the content and findings of which have been incorporated into our team development model.</p><h3>How Do We Measure Team Effectiveness?</h3><p>After presenting the scientific approach behind our team development model, we would now like to discuss how we use our <em>team development tool</em> <strong><em>Check’n’Swarm</em></strong> to collect data on the effectiveness of our teams.</p><p>With Check’n’Swarm, we measure team effectiveness using quantitative questionnaires that mainly contain subjective assessments. In order to avoid basing effectiveness solely on the purely subjective assessments of team members, we evaluate team effectiveness from multiple perspectives. In addition to the assessments of the team itself, there is the option of external assessment by stakeholders and users. Furthermore, an assessment of the team is made by a person in the role of team developer, and the team’s direct manager is also given the opportunity to provide feedback on the team’s effectiveness. Although surveys are generally subjective measurement methods, our multi-perspective approach and standardized data collection enable us to increase the objectivity of the data. In addition, in line with state-of-the-art practice, we are planning to combine survey-based measurement methods with data from automated monitoring systems (cf. DORA) in order to obtain a holistic overview of a team’s effectiveness.</p><h3>Overview of the Check’n’Swarm Process</h3><p>However, conducting the survey from different perspectives alone does not represent added value, either for the team itself or for the organization. In order to generate impact with the help of the collected data, it is essential to also work with the collected data. This is done initially within the teams, once a quarter in a workshop based on a retrospective format, which is usually conducted by a team developer from the respective department. With the aim of identifying relevant areas of action for the team, the results of the respective perspectives are discussed in this workshop. If necessary, so-called “in-depth modules” can be used to support the teams in delving deeper into individual identified areas of action and learning. This allows aspects of teamwork that are relevant to the team to be examined and discussed in more detail before the team decides on specific team development measures.</p><p>This process is illustrated in <strong>Figure 2 </strong>below using an OODA loop:</p><figure><img alt="Alt text: Circular process with four steps: Observe — effectiveness check, Orient — effectiveness retrospective, Decide — in-depth modules, and Act — implementation of measures. Arrows indicate the cyclical process. Brief explanations of the check and in-depth modules are provided on the right." src="https://cdn-images-1.medium.com/max/1024/1*qjt_6NM2_awUqoDeYGFfUA.jpeg" /><figcaption>Check’n’Swarm process for data-driven team development in the OODA loop</figcaption></figure><p>The measures are implemented either in the area of performance or they address the team’s framework conditions. As part of team development, work is therefore carried out precisely in the areas of action that have been identified from the analysis of the effectiveness data. To improve performance, the focus is either on work processes, teamwork, the team’s ability to learn, or the team’s conditions. In terms of the framework conditions, the focus is on the team’s tasks, the team itself, or the leadership of the team and within the team. The teams are supported by a team developer in selecting and implementing the appropriate team development measures. In addition to the work within the teams, organizational cross-team processes are also initiated on the basis of the data to ensure the systematic distribution of team development capacities among the teams according to their needs for action. In addition to the quantified effectiveness of the team (based on the assessments of the team developers), information on the relevance of the team’s contribution to the achievement of current corporate goals is also incorporated into this mechanism. Based on these criteria, effectiveness, and the team’s contribution to corporate goals, team development capacity allocations are reviewed and adjusted every 3 months.</p><h3>Outlook</h3><p>Even after successfully establishing the systematic team development process and the underlying theoretical model, we strive to continuously develop our tool further. The next priorities include validating the theoretical model based on our data and developing a custom GPT that can support our tech teams and their team developers in their work and make them more effective, based on our model and an extensive Check’n’Swarm knowledge base.</p><h3>Conclusion</h3><p>At OTTO, we strive to develop effective teams that are able to achieve their goals with enthusiasm and flexibility. To meet this goal, we also rely on data-driven decisions in team development — in line with our mantra #ThinkAndActData.</p><p>Check’n’Swarm is OTTO’s answer to the question of a suitable tool for measuring team effectiveness and serves to systematically measure the development status of a team. Check’n’Swarm is based on a theoretically sound model and comprises a standardized process for working with the collected data from multiple perspectives, aiming at the sustainable development of teams. In the future, the development of the tech teams will also be supported by the integration of an AI tool.</p><p>Hopefully this article was useful — and perhaps it gave you one or two ideas for thinking about team development in a more data-informed way. 😉</p><p>👉 Read this one and more interesting articles on our <a href="https://www.otto.de/jobs/en/technology/techblog/?navid=925027925027"><strong>Tech Blog</strong></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pFovRHJ-Sj-KBWVqaSIJUw.jpeg" /><figcaption>The Authors: <a href="https://www.otto.de/jobs/en/technology/techblog/author/klingelhoefer_lippke.php">Aemilia &amp; Svenja</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dedad888d30f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/data-driven-team-development-how-otto-leads-tech-teams-to-success-dedad888d30f">Data-Driven Team Development — How OTTO Leads Tech Teams to Success</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning to Rank is Rocket Science: How Clojure accelerates Our Machine Learning with Deep Neural…]]></title>
            <link>https://medium.com/otto-tech/learning-to-rank-is-rocket-science-how-clojure-accelerates-our-machine-learning-with-deep-neural-f8efe33ad851?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8efe33ad851</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[deep-neural-networks]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[learning-to-rank]]></category>
            <category><![CDATA[clojure]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 14:18:22 GMT</pubDate>
            <atom:updated>2026-01-02T14:56:42.882Z</atom:updated>
            <content:encoded><![CDATA[<h3><em>Learning to Rank is Rocket Science</em>: How <em>Clojure a</em>ccelerates Our <em>Machine Learning</em> with <em>Deep Neural Networks</em></h3><p>In <strong>e-commerce search</strong>, decisions made in seconds determine whether customers stay or leave. At <strong>OTTO</strong>, we rely on <strong>learning to rank</strong>: instead of fixed rules, our models learn from millions of real interactions which products are truly relevant.</p><p>In this article, we explain why <strong>Clojure </strong>is crucial to our production stack in the field of <strong>machine learning</strong> — and how <strong>Clojure </strong>and <strong>Polylith </strong>help us run complex <strong>machine learning pipelines</strong> in a stable, efficient, and maintainable way.</p><h3>From Deep Space 1 to Learning to Rank at OTTO</h3><p>For years, Gradient Boosted Decision Trees (GBDTs) were the undisputed champions when it came to producing precise rankings for our customers. They are reliable, interpretable, and remarkably capable. Yet with our <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/learning-to-rank-otto.php">Deep Neural Network</a>, we were able to outperform our champion.</p><p>Our goal: take our customers’ search experience to the next level, efficiently and cost-effectively. To do this, we use Clojure, a programming language that makes it easy for developers to maintain and extend code. A language that’s fun to use.</p><p>What is Clojure? A programming language based on Lisp. Lisp (short for “List Processor”) is a language developed in 1958 by John McCarthy at MIT. It is known for its unique syntax, powerful metaprogramming capabilities, and strong influence on the development of other programming languages.</p><p>Lisp has already been used in space. More precisely, Lisp was an important part of the software used on Deep Space 1 (DS1). The system for autonomous control of the spacecraft (Remote Agent) was written in Lisp.</p><figure><img alt="the spacecraft Deep Space 1 floating in space" src="https://cdn-images-1.medium.com/max/1024/1*0r0R_KZSItRaM5zCmMmXdA.jpeg" /><figcaption>Deep Space 1 spacecraft in space/ Source: NASA</figcaption></figure><p>A remarkable aspect of using Lisp on DS1 was the ability to run a Read–Eval–Print Loop (REPL) on the spacecraft. This proved extremely valuable when debugging issues in space, as engineers were able to inspect and adjust code on the spacecraft, solving problems “in flight.”</p><p>Python is the first-class citizen for machine learning. Nevertheless, we deliberately chose the Lisp dialect Clojure to implement our Deep Neural Network–based Learning to Rank service. That may sound unusual at first. But Lisp can operate complex, fault-tolerant systems in one of the most demanding environments. This was already demonstrated on Deep Space 1, which makes it an ideal tool for AI and autonomous systems. That’s more than enough reason for us to explore it further.</p><h4>What makes Clojure special?</h4><p>Clojure is a dynamic, functional programming language that operates on the Java Virtual Machine (JVM). It was designed to combine the strengths of functional programming with the reliability and rich ecosystem of the JVM.</p><p>The language is based on Lisp, one of the most important languages in the history of computer science. Its innovative ideas and concepts have profoundly shaped many other languages and continue to do so today. Showing that good ideas are timeless — still relevant and valuable decades later.</p><figure><img alt="a comic sketch in black and white on a programming language called lisp" src="https://cdn-images-1.medium.com/max/780/0*uEtQEnJFRu1ON1du.png" /><figcaption>Comic sketch about lisp/ Source: xkcd</figcaption></figure><p>Released in 2007 by its creator, Rich Hickey, Clojure was developed with an emphasis on simplicity, clarity, and pragmatism. Hickey highlighted features like immutability, higher-order functions, and metaprogramming. All while keeping the language practical and approachable.</p><p>Beyond its elegance, Clojure offers many advantages:</p><p>• <strong>Concurrency</strong>: It was designed from the ground up for parallelism and concurrency, allowing it to take full advantage of modern hardware.</p><p>• <strong>Immutability</strong>: By default, Clojure’s data structures are immutable, keeping application state clear and traceable.</p><p>• <strong>JVM Interop</strong>: Running on the JVM gives Clojure direct access to the huge and mature ecosystem of Java libraries. This means developers can utilize proven solutions for things like database access, networking, and more.</p><p>• <strong>REPL-driven development</strong>: Clojure’s REPL (Read-Eval-Print Loop) offers an interactive, incremental development style. This allows engineers to write, test, and debug code on a running application, which provides fast feedback and makes prototyping more efficient.</p><p>• <strong>Functional programming</strong>: The foundation of Clojure is its use of pure functions, computations that operate without side effects. This improves testability, enables parallelization, and leads to better software design.</p><h4>Why Clojure for Machine Learning?</h4><p>In the world of Machine Learning (ML), Python and R are the leading languages. They offer an easy entry point, numerous tools, and extensive documentation, which simplifies exploratory and prototyping work. However, in our business environment, we must focus more on operational stability and the cost efficiency of the solution. That is why we rely on Clojure and benefit from the following advantages:</p><p>• <strong>(Cost-)Efficient Data Pipelines and Modular Feature Engineering</strong>: <br>Transformations in our data pipelines are inherently functional. Large datasets must be manipulated, filtered, and aggregated to obtain new data. Most operations are independent and can be processed as a stream. This leads to better parallelization, improved testability, and reduced memory usage.</p><p>• <strong>Operational Resilience</strong>: Running on the JVM means we gain excellent performance in terms of runtime speed and memory footprint. Its comprehensive suite of application monitoring tools allows us to accurately diagnose and eliminate both performance and memory-related issues.</p><h3>How we operate our Neural Network</h3><p>Our architecture is built around a PostgreSQL database containing all queries and its products. At serving time, Clojure microservices access this data to rank incoming search results (Retrievals) based on the relevance scores.</p><p>The scores are generated by predictions from our Deep Neural Network. It operates on relevance signals, interaction data of our customers, as well as the product data. Our machine learning pipelines are built as Clojure jobs and run on AWS. They prepare data for model training and prediction.</p><figure><img alt="two dimensional architecture overview of a learning-to-rank pipeline, including colored blocks and buckets with tags" src="https://cdn-images-1.medium.com/max/1024/0*KtAOM7qukB8FEEF1" /><figcaption>Architecture overview of our learning-to-rank pipeline</figcaption></figure><p>Our ETL pipelines are designed around the UNIX pipe concept. Each pipeline is composed of small, specialized jobs that handle tasks, like reading raw data from Kafka or transforming it. The output of each job is written to S3 as a file, which then serves as the input for subsequent jobs.</p><h4>From Data Blocks to Data Streams: Streaming Pipelines with core.async</h4><p>Inspired by UNIX pipes as well, our jobs treat data as a stream. Individual items flow through a series of processing steps like reading, filtering, and mapping. We use core.async channels to connect these steps, creating a continuous data flow.</p><figure><img alt="two dimensional architecture overview of a Clojure job, including colored blocks and buckets with tags" src="https://cdn-images-1.medium.com/max/1024/0*yhJ7si-zB76l_PtX" /><figcaption>Streaming architecture of a Clojure job</figcaption></figure><p>Clojure channels let us process data in parallel, with multiple threads working on the same channel. By tuning thread counts per step, we use CPU cores efficiently.</p><p>The -&gt;&gt; threading macro connects functions in a clean pipeline, improving code clarity and data flow traceability.</p><figure><img alt="multicolored code with pipeline functions on black background" src="https://cdn-images-1.medium.com/max/779/0*8OBRgq7Fnhz9EehP.png" /><figcaption>Clojure code with pipeline functions</figcaption></figure><h4>Schema-based Data Storage with Protobuf</h4><p>Our jobs process files in Protobuf format compressed with lz4 or zstandard, which results in the following advantages:</p><p>•<strong> Self-documenting data</strong>: Protobuf is a schema-based format and therefore documents the content of each record. When requirements change, we must update the schema and ensure the description remains up to date.</p><p>•<strong> Built-in validation</strong>: Schemas enforce correct data types and mandatory fields. Jobs validate these constraints automatically when processing files.</p><p>• <strong>Higher efficiency</strong>: By using the binary format, our jobs spend much less time on string processing and need significantly less time for reading and writing files.</p><p>• <strong>Streamable format</strong>: Protobuf’s streaming capability lets us read and write files record-by-record, keeping memory usage low even with large datasets.</p><h4>Easy Code Sharing with Polylith</h4><p>We used to share code through libraries, resulting in complex dependency chains. For this project, we wanted to simplify dependency management significantly. So we decided to give the monorepo approach a try and use Polylith to organize the project and manage dependencies.</p><figure><img alt="two dimensional architecture of sharing with Polylith" src="https://cdn-images-1.medium.com/max/1024/0*BFgP17hlVgUVm-Zy" /><figcaption>Architecture of sharing with Polylith</figcaption></figure><p>The benefits we have realized:</p><p>• <strong>Directories instead of separate projects</strong>: We organize libraries, jobs, and services as “building blocks” in separate directories within a single repository. Dependencies are just references to building block directories. This eliminates cross-repository management overhead.</p><p>• <strong>Transparent dependencies</strong>: Because applications always work with current shared code, no library-style versioning is needed, which entirely eliminates the possibility of outdated dependencies. Furthermore, development tooling finds all code references automatically, allowing us to refactor safely and confidently.</p><p>• <strong>Safety during changes</strong>: When we change functionality, we run all tests in the monorepo and immediately validate all affected components.</p><p>• <strong>Automated CI/CD with GitHub Actions</strong>: Polylith automatically determines which projects have changed and require a rebuild. Once identified, a single pipeline runs all tests, creates artifacts, and deploys them to development and production environments.</p><h3>Summary</h3><p>True, we’re not launching rockets here. But Lisp and Clojure’s proven advantages remain relevant today. They power efficient machine learning pipelines, enable fast iteration cycles, and deliver predictable costs.</p><p>If you’re pursuing a similar direction, these topics are worth exploring:</p><p>• <a href="https://clojure.org/">Clojure</a>, a data-centric, simple, and performant language<br>• <a href="https://monorepo.tools/">Monorepo</a>, for clear source code organization<br>• <a href="https://protobuf.dev/">Protobuf</a>, for documentation, validation, and efficient processing</p><p>And if you want to delve deeper into the basics of learning to rank, you will find the right introduction in our previous articles:</p><p>• <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/learning-to-rank-otto.php">Learning to Rank — To the Moon and Back (-propagation): Deep Neural Networks That Learn to Rank What You Love</a><br>• <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/1-learning-to-rank-for-e-commerce-search.php">Part 1: Introduction in Learning to Rank for E-Commerce Search</a><br>• <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/2-data-collection-for-learning-to-rank-.php">Part 2: Data Collection for Learning to Rank</a></p><p>The journey continues for us as well. 🚀 We are planning personalized rankings that need to be calculated in real time and can no longer be pre-calculated. Clojure provides the foundation to meet this challenge effectively.</p><p>👉 Read this one and more interesting articles on our <a href="https://www.otto.de/jobs/en/technology/techblog/?navid=925027925027">Tech Blog</a>.</p><figure><img alt="a group of it-authors in front of a big OTTO-sign" src="https://cdn-images-1.medium.com/max/1024/1*BrT98RsT-9VmuQCN8ptXQg.jpeg" /><figcaption><strong>Authors: </strong><a href="https://www.otto.de/jobs/en/technology/techblog/author/team-jarvis.php"><strong>Team Jarvis</strong></a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8efe33ad851" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/learning-to-rank-is-rocket-science-how-clojure-accelerates-our-machine-learning-with-deep-neural-f8efe33ad851">Learning to Rank is Rocket Science: How Clojure accelerates Our Machine Learning with Deep Neural…</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Open Source at OTTO: Transparency, Community & Innovation]]></title>
            <link>https://medium.com/otto-tech/open-source-at-otto-transparency-community-innovation-11d0d4e5e8c0?source=rss-a4d9b275e3bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/11d0d4e5e8c0</guid>
            <category><![CDATA[open-source-communities]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[it]]></category>
            <dc:creator><![CDATA[OTTO Tech]]></dc:creator>
            <pubDate>Wed, 30 Jul 2025 14:01:01 GMT</pubDate>
            <atom:updated>2025-07-30T14:01:01.662Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is Open Source?</h3><p><strong>Definition Open Source Software (OSS): </strong>OSS refers to software whose source code is<strong> publicly accessible</strong> and can be used free of charge. It refers to programs whose source code is publicly accessible and free to use. This is in contrast to proprietary software, where users have no insight into or control over the code. Open Source Software offers full control over the algorithms it contains, and therefore over the data entrusted to it. It can reduce dependency on commercial software. For those willing to delve deeper, it also provides the opportunity to make adjustments, enhancements, and bug fixes, which can then be shared with the community.</p><p>OTTO has relied on <strong>Open Source</strong> for years, not just as a user, but also as an active contributor. In this article, we explain how we contribute to the <strong>Open Source community</strong>, the benefits this brings our <strong>developers</strong>, and why we consider open source to be an integral part of our <strong>tech strategy</strong>. Curious how OTTO is actively shaping the future of software development and what opportunities this holds for you? Then read on.</p><h3>What are the advantages of Open Source Software?</h3><p><strong>Open Source Software </strong>offers numerous <strong>advantages</strong> — both for <strong>developers </strong>and for companies like OTTO. The most important at a glance:</p><ul><li><strong>Transparency and Quality Assurance: </strong>By open-sourcing one’s own code in public repositories, external peer reviews and public feedback can be used to identify weaknesses early and improve code. This promotes the security and stability of the software and strengthens trust in our systems.</li><li><strong>Cost savings and strategic advantage: </strong>For many, the most important reason for choosing Open Source is that it can be used free of charge, provided that the licence conditions are complied with. This saves directly on acquisition costs. A <a href="https://www.heise.de/jobs/en/news/Harvard-study-Open-source-has-an-economic-value-of-8-8-trillion-dollars-10322643.html">Harvard Business School study</a> recently revealed that companies without OSS would have to spend about 3.5 times more money on their software.</li><li><strong>Learning and Development Opportunities:</strong> The open exchange with the community fosters continuous learning. Developers benefit from insights into other projects and can adopt new techniques and best practices.</li><li><strong>Network and Reputation: </strong>Publishing one’s own projects allows one to establish oneself in the open-source community. This not only strengthens personal and employer profiles but also opens doors for exciting collaborations and personal professional development. Our developers should be proud of their code and happy to show it.</li><li><strong>Creativity and Fast Problem Solving:</strong> Open source creates space for creative solutions. With the help of the global community, problems can be solved faster and new ideas developed — benefiting both individual projects and the entire company.</li><li><strong>Promoting Internal Collaboration:</strong> When developers provide their tools as OSS, other teams within OTTO also benefit. They can rely on proven solutions and work together on further development, which creates synergies and saves resources. Open Source also enables easy access to our shared resources.</li><li><strong>Documentation: </strong>Anyone who makes code openly available on the internet is motivated to add good documentation on the purpose and use of the software. This makes it easier for others to use and ensures that it is found in search engines.</li></ul><p>Authorities and companies are increasingly recognizing that it can be a good idea to consider open-source solutions as an alternative to closed systems. The keyword of the hour is “<strong>Digital Sovereignty</strong>”. <a href="https://www.zdnet.com/article/why-denmark-is-dumping-microsoft-office-and-windows-for-libreoffice-and-linux/">Denmark</a> and <a href="https://www.connect-professional.de/software-services/schleswig-holstein-verzichtet-auf-microsoft.332210.html">Schleswig-Holstein</a> are turning their backs on Microsoft and switching to <strong>Linux </strong>and <strong>LibreOffice</strong>, while the <a href="https://www.heise.de/jobs/en/news/Framework-agreement-MS-365-alternative-OpenDesk-to-conquer-the-Bundeswehr-10342383.html">Bundeswehr</a> (German Armed Forces) and the <a href="https://www.heise.de/jobs/en/news/Sovereignty-Public-health-service-increasingly-relies-on-open-source-10443654.html">healthcare sector</a> are increasingly relying on <strong>OpenDesk </strong>in the future. OTTO was also recently featured in the <a href="https://www.ndr.de/nachrichten/info/Wie-der-Abschied-von-Microsoft-und-Co-gelingen-kann,opensource102.html">media</a> regarding technology dependence and has long relied on open-source software.</p><figure><img alt="Excerpt from codes in the GitHub profile “otto_de”" src="https://cdn-images-1.medium.com/max/633/0*mXh-55PhtDRYWWlI.png" /></figure><h3>Open Source at OTTO: Our approach and motivation</h3><p>Some well-known <strong>open-source products </strong>form the backbone of our <strong>shop platform</strong>, which is operated jointly by many teams with individually different tech stacks. An overview is provided by the many articles in our Tech Blog, which report, for example, on the <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/ottos-future-ready-event-exchange-platform.php">introduction of Apache Kafka</a>, <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/terraform-tips-scalable-and-reliable-infrastructure-as-code-part-1.php">Terraform</a>, or the <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/continuous-delivery-with-feature-toggles_2013-09-09.php">Togglz-Library</a> that we use.</p><p>However, this article is not about the use of open source as a free alternative to purchased <strong>closed-source software</strong>, but rather about how OTTO contributes to the community as an OSS provider and to what extent this represents a motivating addition for our developers to their daily work on internal systems.</p><figure><img alt="Excerpt from Github profile “otto_de”" src="https://cdn-images-1.medium.com/max/641/0*cMKmsY6iO707BRPW.png" /></figure><h3>Guidelines and governance</h3><h4>Tech Rules of Play</h4><p>Our internal <a href="https://www.otto.de/jobs/en/technology/techblog/blogpost/ottos-it-tech-manifest.php"><strong>„Tech Rules of Play“</strong></a> stipulate that self-created libraries used across teams should be published as <strong>Open-Source projects</strong>. This is done to ensure the quality and documentation of these tools. The consuming teams should be able to rely on finding the same quality as with other OSS projects. In some cases, where libraries relate to purely internal systems, an Inner Source project may also arise, to which we apply the same quality standards.</p><h4>Shared-Nothing Concept</h4><p>Interestingly, this regulation represents a deliberate exception to the otherwise strongly anchored Shared-Nothing concept. Normally, we rely on this principle to minimize dependencies between teams and thus mutual blockages. This brings us high independence and speed. However, in cases where the shared use of software offers added value in terms of <strong>quality </strong>and <strong>maintainability </strong>and leads to avoiding duplicate work, the step towards open-source publication is a win — for the entire company, for other interested parties, and for the individual development of our developers.</p><h3>The Role of the Open Source Advisory Board</h3><p>To better manage these diverse open-source efforts, we have established the <strong>Open Source Advisory Board (OSAB) </strong>at OTTO. The OSAB currently consists of eight developers from various departments, primarily working within their functional teams. Many of them manage one or more OSS projects and share the common vision of further promoting Open Source at OTTO and maximizing the benefits for developers and the company. The OSAB takes on the following tasks:</p><ul><li><strong>Contact Point for Teams and Developers: </strong>The OSAB serves as a contact point for teams and developers who want to publish software at OTTO. The OSAB also actively tries to identify interesting internal projects and motivate their publication. And, of course, the colleagues are happy to handle external inquiries at <a href="mailto:opensource@otto.de">opensource@otto.de</a>.</li><li><strong>Provision of Practical OSS Guidelines:</strong> The OSAB ensures that open-source guidelines remain current and understandable and are easily accessible to all developers.</li><li><strong>Optimization of Administrative and Security Processes:</strong> By coordinating OSS projects, regularly reviewing compliance with our minimum standards, and maintaining uniform and documented release processes, the OSAB significantly contributes to sustainable quality assurance.</li><li><strong>Consultation on OSS Licensing Issues: </strong>Developers are supported with legal questions regarding open-source publication to ensure that all activities comply with legal requirements.</li></ul><h3>Outlook: Together into an Open Future</h3><p>Our Open Source Advisory Board is still quite young; we founded it in autumn 2023. We are convinced that it can make an important contribution to OTTO. For our developers, publishing their own tools not only offers a platform for <strong>self-presentation</strong> and <strong>professional development</strong>, but it also represents clear added value for <strong>collaboration </strong>and <strong>employee satisfaction</strong>.</p><p>By publishing code, we signal transparency and quality, which will long-term promote not only the software landscape at OTTO but also the reputation and expertise of our developers. It must also be clearly emphasized that active participation of the teams is required to create and maintain attractive open-source projects. Successful OSS does not arise “on the side” or “all by itself.”</p><p>Want to get involved in our Open Source initiatives? Contact us: <a href="mailto:opensource@otto.de">opensource@otto.de</a>.</p><p>👉 Read this one and more interesting articles on our <a href="https://www.otto.de/jobs/en/technology/techblog/?navid=925027925027">Tech Blog</a>.</p><figure><img alt="photo of tech blog author Marco who is sitting on a bench in our OTTO headquarter" src="https://cdn-images-1.medium.com/max/1024/1*6wxGAx71O2Iu-3-4i47YDQ.jpeg" /><figcaption>Author <a href="https://www.otto.de/jobs/en/technology/techblog/author/marco-geweke.php">Marco</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11d0d4e5e8c0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/otto-tech/open-source-at-otto-transparency-community-innovation-11d0d4e5e8c0">Open Source at OTTO: Transparency, Community &amp; Innovation</a> was originally published in <a href="https://medium.com/otto-tech">OTTO Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>