Dev Summit 2026

As software ecosystems grow more complex, Software Supply Chain attacks are evolving from manual exploits to AI-driven automation. This session explores the rising trend of attackers compromising packages and extensions to bypass traditional corporate defenses. We will deep-dive into:
- Corporate Risks: Understanding the impact of automated dependency poisoning.
- Case Study: A concrete analysis of Shai-Hulud 2.0 and how AI scales these threats.
- Strategic Vision: Our roadmap to harden our development lifecycle and prevent such scenarios from impacting our infrastructure.

For years, the industry's motto has been simple: collect and store as much data as possible, believing that immense value will emerge from this accumulation. This vision, driven by tech giants like **GAFAM** that collect petabytes of data daily, isn't always practical for every company. At the same time, single computing instances on the cloud have become exponentially more powerful, allowing us to handle large amounts of data on a single machine.

This new way of thinking is captured by the **Small Data Manifesto**, which states that more data doesn't always equal better results, modern hardware is often underused, and data topics should be developed locally first. In the data department of Decathlon, we discovered this is more than just a theory. More than 90% of the data tables in our datalake (Decathlon's centralized data repository) was less than 50 GiB. This finding inspired us to define a new approach to data transformation.

After setting the context and introducing the Small Data Manifesto, we will present **Light Computing**, which brings these principles to life. Instead of spinning up expensive clusters to transform data, we use powerful single-node tools and only scale up when the data truly requires it. The leading tools of this field are **Polars** and **DuckDB**. We'll cover two main aspects: what technically defines these tools and what they bring in terms of concrete cost and architectural benefits.

The session will conclude with a live demonstration of Polars, showing how we can easily compute 50 GB of data on a small computing instance on Databricks.

RAGEdito was born from a simple observation: when a customer types "how to change a window" into the Leroy Merlin France search bar, they are not looking for a product — they are planning a project. Currently live in production on French traffic, RAGEdito generates real-time DIY tutorials with contextualised shopping lists, directly from the search bar.

This session delivers a hands-on retrospective from a three-person Product Owner / Data Analyst / Data Scientist team on building, steering, and continuously improving a RAG system in real production conditions.

Product angle: how to translate a user signal into a structured product vision — from defining meaningful business KPIs to aligning stakeholders across a multi-product Search & Publication domain. How RAGEdito fits into a coherent, scalable roadmap with group-wide deployment ambitions.

Analytical angle: how production query analysis identified a significant share of editorially-intentioned traffic going unaddressed, segmented customer needs by intent type (repair, installation, construction, inspiration), and converted these insights into concrete growth levers and roadmap decisions.

Technical angle: how user feedback feeds a custom evaluation pipeline, refines LLM generation, and drives architectural evolution toward a reusable API component scalable across the group.

Key takeaway: how to align product vision, analytical intelligence, and technical robustness to turn a RAG prototype into a product with measurable business impact.

In 2011, Marc Andreessen famously declared: *"Software is eating the world"*. Today, with the massive adoption of Generative AI, a new existential question is echoing through the tech industry: is AI eating software... and our jobs along with it?

Fueled by mind-blowing code generation demos, the myth of the disappearing Software Engineer is stubbornly persistent. Yet, the reality on the ground is far more nuanced. While AI excels at generating simple solutions or writing code in languages heavily represented in open-source repositories (like Python or JavaScript), its limitations become glaringly obvious when faced with complex algorithms or languages with limited training data.

In this talk, as Directors of Engineering, we will look past the hype to analyze what the future truly holds for our industry. We will tackle the real challenges awaiting our development teams, which are far removed from simply being replaced by machines.

**Key Takeaways:**

* **The Myth of the Obsolete Engineer:** Why the end of software engineering is an illusion, and where the real limits of AI lie (algorithmic complexity, lack of training data for specific or proprietary tech).
* **The Vendor Lock-in Trap:** How reliance on large AI models is redrawing the landscape of technological lock-in for our architectures.
* **The New Skill Matrix:** How to rethink the career path from Junior to Senior in an era where AI handles writing the "easy" code.
* **The Impact on the Broader Ecosystem:** Engineering doesn't operate in a vacuum. How does the AI era redefine the roles and interactions of QA, Support, Product Management, and Ops?

Whether you are a Software Engineer seeking direction for your career, an Engineering Manager preparing your team for the future, or a stakeholder in the tech ecosystem, join us to map out the true challenges of this new era. Code isn't dead, but the way we build it has changed forever.

Overview

As AI models converge on strong reasoning capabilities, the differentiator for effective
agentic systems is increasingly not the model itself, it's the context you provide it.
Context engineering — the discipline of delivering the right information, at the right
granularity, at the right time — is becoming a core competency for teams building agents
that work reliably in production. In this talk, we define the problem, share practical
principles for context architecture, and walk through how we've approached it with our
own products.

Outline
I. The Context Problem
- As agents take on longer, multi-step tasks with real-world consequences,
the quality of their context becomes the primary driver of output quality

- Most agent failures in practice aren't reasoning failures — they're context
failures: the model was missing information, working with outdated
information, or overwhelmed by irrelevant information

- Context engineering as a discipline: distinct from prompt engineering,
closer to systems design. It's about pipelines, infrastructure, and
information architecture — not just what goes in the system prompt.

II. What Good Context Looks Like
- Relevance is the measure that matters – The goal of context engineering
isn't to maximize information available to the model — it's to maximize
relevance. Everything else follows from this.

- You can't always predict relevance in advance – Agentic workflows are
dynamic. What's relevant at step five depends on what the agent discovered
at step three. Pre-curated context assumes you know the path before the
agent walks it.

- Explorability is how you achieve relevance at scale – Rather than
pre-identifying the right context, the more resilient approach is making your
knowledge base easy for the agent to traverse and explore on the fly. The
design question shifts from "build a better retriever" to "make your
knowledge navigable."

- This is where most teams are under-investing – The default
embed-index-retrieve pattern optimizes for static similarity. It doesn't
support an agent that needs to follow threads across systems, discover
adjacent context, or refine its understanding as a task unfolds.

- Measure whether agents are finding what they need – Without this, you
can't tell whether a bad output is a reasoning problem or a context problem.

III. Turning Enterprise Knowledge into Agent-Ready Context

- Enterprise environments are where context engineering is both most
difficult and most impactful — the knowledge exists but it's scattered,
siloed, inconsistently structured, and constantly changing

- The untapped goldmine: docs, wikis, tickets, CRMs, codebases, Slack
threads — most enterprise knowledge is already there, just not accessible
to agents

- Strategies for ingesting, indexing, and surfacing enterprise knowledge at
inference time

- Handling permissions, access control, and data sensitivity in context
pipelines

- How we achieve this with Kong Context Mesh: a walkthrough of our
approach to transforming enterprise resources into agent-ready context

1/ Our architecture for ingesting, indexing, scoping, and serving
enterprise context at inference time

2/ Assumptions we made early on that turned out to be wrong, and
what we learned

3/ What measurably improved when we got context right, and where
we're still iterating

Speaker Bio

Christopher Tam is the Product GM for Kong’s Agentic AI Infrastructure offerings,
including AI Gateway, Context Mesh, and KAi. A veteran in the AI and infrastructure space,
Chris previously founded Substrates.ai, an agentic infrastructure startup, and held
product leadership roles at Google and Verily, where he applied cutting-edge AI
technologies to business applications. He was also a VP at Leap Motion, an early pioneer
in computer vision.

Last-mile delivery operations face increasing pressure to balance service quality with cost efficiency, given highly variable demand densities and heterogeneous territories. We present an optimization framework that jointly designs territorial delivery districts and customer booking calendars, treating delivery slot availability as decision variables. In remote or low-demand areas, the system restricts booking availability to a limited number of weekly delivery slots, enabling order consolidation and reducing inefficient travel. Conversely, high-demand districts are offered a larger set of booking slots, supporting more frequent delivery routes. **By shaping demand in time, the system aligns customer delivery choices with operationally efficient routing patterns**. The underlying mathematical formulation is based on a Mixed-Integer Linear Programming (MILP) model that optimizes booking calendar configurations while minimizing fleet size and traveled kilometers under company-specific operational constraints.
Deployed by Golilla, the Italian last-mile logistics operator within the Adeo ecosystem, the tool was tested over six months at a regional hub in Emilia-Romagna, replacing the previous experience-based scheduling approach. The result was a 15% increase in gross margin. It is now live in production and being rolled out across the full Italian territory.

This session details the transformation journey of Leroy Merlin Brazil (LMBR) as it adopts **Critical User Journeys (CUJ)** as the foundation for operational excellence. We will share how we unified technology and business teams to map the critical journeys of **Marketplace, Credit Platform, Payment, and Arc+ Loyalty**, establishing clear indicators and defined consequences for each stage.

We will present the practical process of identifying these journeys, which was essential for pinpointing critical areas and primary personas, resulting in a drastic reduction in errors and unavailability. Furthermore, we will discuss the current expansion to eight additional teams including **E-commerce, Assisted Sales, and Flash-Sales** where journeys are already in the draft phase. The main goal is to demonstrate how CUJs evolved from a technical concept into a **strategic performance KPI**, set to replace APDEX to better align with market practices and ADEO’s global digital maturity goals.

### Why choose our talk? 😄

This talk presents a success case of digital maturity from a BU outside the European Union, serving as an incentive for global collaboration. It demonstrates how synergy between technical and business communities can generate tangible results in resilience and efficiency. By elevating *Critical User Journeys* to a global KPI, LMBR is not just solving infrastructure issues but leading a cultural shift that prioritizes the "persona experience" over synthetic metrics like APDEX. This content is highly relevant for both *Dev-Tech* and *Product Management-UX* streams, offering a replicable framework for other ADEO and Decathlon units seeking customer-centric innovation and positive impact.

At Decathlon, based on years of experience, we’ve completely revamped how we do forecasting by building a "forecasting pipeline factory." Thanks to this approach, we are now building and shipping pipelines in producion in less than two months. Our solutions are based on modern data manipulation tools (dbt), in-house python libraries for machine learning abstractions, and modern models such as Time Series Foundation Models (Chronos2).

This technical stack, combined with an “extreme programming” mindset, has greatly accelerated our developments and deployment velocity. It’s been a real cross-functional enabler to deliver actual business value across several units at Decathlon.

# A quarter of Spec Driven Development: 5 lessons I learned as a PM.

> "What if the incessant back and forth between product and tech wasn't a fatality, but a symptom of an outdated work method? At a time when AI can generate code in seconds, the bottleneck has shifted: it's no longer in execution, but in the precision of intention."

## Core idea
After a quarter of experimenting with Spec Driven Development (SDD), I'm offering you an unfiltered feedback. How to transform a product vision into a robust specification so that it becomes a vector for acceleration? With SDD, the product manager role takes on a very important part, particularly in the upstream phase of discovery and design. During this period, between vibecoding, SDD, and the use of different frameworks, I was able to learn 5 lessons that seem essential for a PM.

Through this talk, I want to show you how upstream technical and functional specification is not a return to waterfall execution but an accelerator of agility thanks to SDD. We will talk about tools, methods, change management, successes, but also failures (because there can be some).

---

## Key message
AI does not replace the PM, but forces them to become an expert in design again! With this new mindset, we talk about the role of the product builder who not only defines the product strategy but also builds, prototypes, and iterates directly using AI and no-code/low-code tools.

---

## Central questions
How does the product manager integrate team dynamics when they can experiment and build?
How can we ensure that SDD and this role transformation are not blocked by shadow IT and organizational tech radars?
What are the roles of SIGs and Offices within digital domains to accelerate SDD at scale?

---

## Talk promise
At the end of the talk, participants will leave with:

- **A mindset shift:** why "thinking" and "building" are no longer distinct phases in the AI era but a single, unified block.
- **Vibecoding and SDD:** two complementary approaches: vibecoding prioritizes speed and exploration, while SDD prioritizes precision and traceability.
- **The product builder's "TechRadar":** A list of tools (no-code, low-code, AI agents) to accelerate your discovery cycles.
- **The augmented PM's to-do list:** A roadmap to transition from the data-centric PM 2.0 to the AI-augmented Product Builder PM 3.0.

---

## Target audience
Product managers, designers, and engineers curious about the future of product creation in an AI-first world.

---

We are hearing a lot about agentic AI right now. Every developer is testing it, looking to implement it, and some are even pushing it to production. However, the ecosystem is still highly uncertain; the surrounding technologies (ADK, LangGraph, CrewAI, etc.) are very young. Ultimately, picking one right now feels more like a gamble than an informed choice.

**So, what solution would allow us to both set a clear framework and ensure agentic sovereignty? Small Agent!**

Within the LMFR AI team, we have built a framework that empowers any developer to implement agents in just three lines of code. All the underlying complexity is managed by the framework itself. Thanks to A2A, we standardize the interfaces so that, in the end, whether you choose LangGraph, ADK, or another tool behind the scenes, it simply doesn't matter.

It features two operating modes:
* Low-Code: If you want minimal code to run a V0 agent, let the framework do the heavy lifting.
* Advanced: If you are experienced in orchestration, you have full control. For example, if you use LangGraph, you can manage the graph directly. Everything is defined as classes, leaving you completely free to use code overrides as your imagination dictates.

This framework will enable us to:
* Accelerate everyone's daily workflow.
* Centralize complexity within the AI team, allowing every developer to implement easily.
* Achieve true technological sovereignty.
* Guarantee agentic consistency across the company.

**Additional Notes / Context:**

And yes, this really exists! We are already starting to implement it in specific areas. We also have our sights set on deploying an operational agent directly onto Turbine, using the A2A protocol to standardize communications with the agents.

As AI coding assistants accelerate software development, the volume of pull requests at Datadog has grown to nearly 10,000 per week, increasing the risk that malicious changes slip through due to review fatigue. To address this, Datadog built BewAIre, an LLM-powered code review system designed to identify malicious source code changes introduced by threat actors. By reducing approval fatigue for developers while increasing friction for attackers, BewAIre guides human reviewers to the areas where judgment matters most, without slowing developer velocity.

In this presentation, I will share why BewAIre was built, how it evolved from a hackathon experiment into a production-grade internal system, and the key architectural decisions and trade-offs involved along the way. I will discuss what worked, what didn’t, and the limitations we encountered when applying LLMs to security-critical workflows.

Most AI systems today rely on Retrieval-Augmented Generation (RAG) or APIs to access external knowledge. While
effective in controlled environments, these approaches often fail in production when faced with real-world data: incomplete
coverage, stale information, and unreliable sources.
In this talk, we share practical lessons from building a web-scale retrieval layer designed specifically for AI agents. We’ll
explore the key challenges of working with web data, dynamic content, inconsistent structures, adversarial noise, and the
architectural decisions required to handle them.

Topics include retrieval strategies (search vs direct fetch), ranking signals (relevance vs trust), structuring unstructured data,
and the trade-offs between latency, precision, and coverage.
Through real-world failure cases and design patterns, attendees will gain a clearer understanding of how to build AI systems
that remain grounded, reliable, and useful beyond demos.

Comment transformer nos processus tout en remplaçant un SI historique ? L'Architecture d'Entreprise (EA) est souvent le chaînon manquant pour concilier vision globale et agilité locale.
Je vous propose de découvrir comment l'EA agit comme un catalyseur de modularité. Nous aborderons :
- La clarification des responsabilités : comment l'EA soutient les DL et les Product Managers
- Les critères de décision : comment garantir que nos choix d'aujourd'hui ne deviennent pas les blocages de demain.
- La trajectoire de transformation : passer d'une architecture subie à une modularité choisie.

How do you know if your product assortment is complete, well-structured, and competitively relevant — across **millions of products**, updated weekly, without a team of analysts manually browsing competitor websites?

At Leroy Merlin (ADEO), we faced exactly this challenge. Category managers needed actionable competitive intelligence: a structured view of **assortment coverage** — which product types competitors offer, which attributes they highlight, and where gaps exist. That means extracting structured product attributes — dimensions, materials, capacities, product types — from raw competitor product pages and mapping them onto our own product taxonomy.

We built a fully automated, AI-powered pipeline running on Google Cloud (Vertex AI + BigQuery) that today monitors **31 retailers and marketplaces** — including ManoMano, Castorama, Amazon, CDiscount, Ikea, Bricorama, and even the Leroy Merlin marketplace itself — processing over **26 million products** weekly.

The system combines two complementary AI approaches:
- A **custom ML classification model** — the **PEM (Product Entity Matching) API**, an existing ADEO digital asset reused here for a new purpose — that assigns each competitor product to one of **2,873 product models** within ADEO's internal taxonomy. It successfully classifies **62.7% of all ingested products**, with confidence-score thresholding ensuring downstream data quality.
- **Gemini 2.0 Flash** for structured characteristic extraction from raw product text, using few-shot prompting, self-verification loops, and type-aware validation (closed value sets, numeric measurements with automatic unit conversion). This has produced over **39 million characteristic values** across **80 distinct attributes** on **11.5 million products**.

The results feed a **dbt aggregation pipeline** in BigQuery, stream to a **Vue.js frontend**, and give category managers a live, filterable view of how Leroy Merlin's catalog compares to the market — by product type, characteristic, and price quartile.

In this Tools in Action session, we'll walk through the full pipeline architecture, the AI design choices and their trade-offs (LLM output validation, reuse of internal ML assets, quality filtering), and close with a live demo of the app.

For the dataplatform teams, building high-performance pipelines is only a part of the equation: the real challenge is ensuring that this data is accurate, up to date and usable by business units and AI models on a daily basis. Data quality has thus become the true battle of trust between technical teams and end users.

However, ensuring this quality across an entire organisation is complex, therefore defining and enforcing global data quality rules across an entire company rarely works: only local teams understand the reality and specific nature of their data. Yet, allowing each team to manage its indicators in silos creates chaos in communication, forcing Product Managers (PMs) in particular to manually cobble together their Service Level Indicator (SLI) calculations and user alerts. An unsustainable situation, especially since data of impeccable quality is now an essential prerequisite for deploying artificial intelligence on a large scale.

In this talk, we will present our experience in creating a standardised data model. We will also see why quality measurement must remain the responsibility of the local product team, while standardising its reporting via a ‘Plug & Play’ architecture. We will the explain how to design this layer independently of the underlying technical solution in order to use these unified metrics to generate reliable SLIs. Finally, we will discuss the prospects offered by this formalism, which paves the way for more complex use cases such as feeding a cross-functional Data Cockpit or evaluating real Data Contracts.

The goal isn't to dictate a tool, but to create a universal standard of communication. We will detail this agnostic architecture that acts as the single source of truth for your pipelines. No more mental load for Product Managers: this overlay automatically transforms every test suite into business SLIs and proactive alerts, making your data reliability 100% autonomous.

SQL remains the most widely used language in data engineering.

Yet modern data platforms are increasingly fragmented: warehouses, query engines, lakehouses, streaming systems and AI pipelines often require different tools, different execution environments and different ways to define transformations.

What if SQL pipelines could be **portable across engines**, while also providing built-in guarantees for data quality and testing?

In this talk, I will introduce **RivetSQL**, an experimental project exploring a new approach to **declarative SQL pipelines with multi-engine execution**.

The goal is simple:

> Define your pipeline once, run it anywhere.

RivetSQL allows developers to describe data pipelines declaratively while enabling:

- execution across different SQL engines
- built-in data quality checks
- integrated testing of transformations
- reproducible and portable pipelines

In this session, we will explore:

- why SQL pipelines remain difficult to make portable
- how modern data stacks introduce new execution challenges
- the architecture behind RivetSQL’s multi-engine execution model
- how testing and data quality can be integrated directly into pipeline definitions
- lessons learned from building an early-stage language experiment

Finally, we will discuss how these ideas could impact **future data platforms and AI pipelines**, where portability, reproducibility and data quality become critical.

This talk is aimed at engineers building data platforms, analytics systems or AI pipelines who want to rethink how SQL pipelines should work in modern infrastructures.

Vector Search has quickly moved from a niche ML requirement to a core capability for modern applications. But while "Hello World" tutorials make it look easy, the reality of managing high-dimensional data at scale is a different story. What happens when you change your embedding model? How do you handle the cost of indexing millions of vectors? How do you avoid the "black box" performance trap?

In this session, we move past the AI hype to look at the practical realities of implementing Vector Search. Drawing from real-world experiments to production, we will compare how major players like MongoDB, Elasticsearch, and OpenSearch handle vector workloads differently.


**Attendees will walk away with:**

* **A "Go/No-Go" Framework:** When to use Vector Search vs. when traditional keyword search is actually superior.
* **Managing the Lifecycle:** Strategies for handling breaking changes in embeddings and re-indexing strategies that won’t crash your production environment.
* **Optimization Tactics:** Practical ways to reduce vector dimensionality and latency without sacrificing retrieval quality.
* **The Cost-Benefit Matrix:** A direct comparison of performance vs. infrastructure overhead across different database providers.

Whether you are a Software Developer that is working for RAG / Search / Recommendation systems or an ML Engineer, this talk provides the "missing manual" for building search systems that are as maintainable as they are "intelligent."

Continuing the conversation from Dan Saffer’s conference, this live roundtable brings together Dan Saffer, Simon Leclercq, and Paul Thanasack to tackle the shifting landscape of product design. With new challenges emerging from AI and rapid development tools, we will discuss how to protect and elevate the credibility of our profession. Topics include the evolution of career paths, essential skill development based on field feedback, and how current design education are adapting to technological shifts. An open Q&A session will follow, so feel free to prepare your questions.

AI agents are making their way into designers' and developers' workflows. Standards are shifting fast, and best practices are still being written. That's exactly why we chose to move rather than wait.
This session shares our ongoing thinking around ADS2: how to position a design system as an AI-ready resource, so it remains a reliable anchor in these new ways of working. Without that foundation, vibe coding and vibe design tools — as powerful as they are — generate inconsistency at scale and build up technical and visual debt that's hard to recover from.
We'll walk through what we've built so far: documentation rearchitected to be machine-readable, early use cases around skills, agents and MCP to streamline component integration, support teams on best practices, and generate interfaces grounded in our guidelines. This space moves fast and changes every day — our goal is to make sure the design system is ready at every major turn.

Storage is often treated as an infinite, invisible commodity, until the bill explodes or the Data Lake turns into a swamp. At Decathlon's scale, managing storage isn't just an infra topic; it's a **Product** that requires strategy, value measurement, and a serious cleanup.

In this session, **Lucie** (Senior PM) and **Soufian** (DataOps Engineer) share their unfiltered journey of reclaiming control over their storage zones. From the first discovery interviews to the automated deletion of Petabytes of data, they’ll reveal how they teamed up to turn a growth crisis into a sustainable efficiency model.

In this session, they will provide a deep dive into the practical synergy between:
- **Product Management for Infra**: How to apply PM frameworks to technical topics like storage costs.
- **The DataOps Engine**: A look under the hood of their automated cleanup stack (S3 Lifecycle, Delta Vacuum) and how they mitigated risks.
- **Cultural Shift**: How they moved from "keep everything" to "smart archiving" by design, proving that deleting is also delivering.

Whether you're a PM or a Dev, you'll leave with concrete tips on how to apply Product methodology to technical debt and ensure your Data Lake stays healthy and ready for the AI era.

Increasing automated test coverage is often less about tools and more about creating the right foundations.

In this talk, we will share how our mobile team dramatically increased unit test coverage in a Flutter codebase — **from 8% to 80% in four months** — by combining AI-assisted development and systematic improvements in application testability.

We leveraged shared prompts with GitHub Copilot to help developers generate unit tests across multiple use cases. In parallel, we introduced semantics and tags throughout our UI architecture, from our design system (ADS) to shared component libraries (ACC, ADC) and the application itself.

This instrumentation allowed QA engineers to **gain autonomy** and start preparing UI automation independently, without constantly relying on developers.

We will share the practical lessons from this journey: what worked, what didn’t, and how these foundations enabled us to launch our UI automation strategy. We will also share what are our future plans to give more tools to contributors with a less technical background.

After a decade, the industry has realized that poorly designed microservices can easily turn into a distributed monolith, often more problematic than the spaghetti monolith they aimed to address. To tackle this issue, the concept of a modular monolith is emerging as an alternative approach.

However, the challenge still lies in effectively splitting it without falling into the pitfall of tightly coupled modules. The Hive pattern helps you build a microservices-ready modular monolith, by leveraging multiple hexagonal architectures and vertical slicing, each module is loosely coupled and ready to be extracted as a separate service.

During this live coding session, we will begin with a legacy spaghetti monolith and migrate it step-by-step to a Hived modular monolith, wrapping up with a demonstration of extracting a module and transforming it into a separate micro-service.

The Material Configurator emerges as a strategic solution to professionalize and streamline sales in the construction materials sector. Facing operational challenges such as high employee turnover and the technical complexity of product families like Partition Walls, Ceilings, Roofs, Floors, and ETICS (External Thermal Insulation Composite Systems), this digital tool standardizes the quotation process through a guided flow of key questions.

The configurator eliminates the barrier of lacking technical expertise, enabling any salesperson to recommend complete systems in just a few minutes. This guarantees two critical objectives: Quick Purchase, optimizing customer and collaborator time in the materials yard, and Complete Purchase, ensuring that no accessory or forgotten reference penalizes project execution or sales figures.

Furthermore, the project marks a milestone in our omnichannel strategy. By integrating into the website and app, customers will no longer have to select references in isolation, reducing the risk of error and allowing for a seamless transition from digital pre-sales to final conversion at the warehouse. In essence, the Material Configurator is not just a material calculator, but a lever for professional advice that enhances the customer experience and profitability per operation.

Key Highlights
From Product to System: We prevent the loss of accessory sales by ensuring the customer gets everything needed for their project (ETICS, ceilings, etc.).
Democratization of Expertise: Any employee can quote complex projects from day one, flattening the learning curve.
True Omnichannel: The quote that starts on the sofa at home with the website materializes seamlessly at the physical point of sale.

**When everyone builds part of the experience, keeping it coherent becomes one of the biggest challenges.**

Many customer experiences, such as conversational interfaces cut across product teams in platform, commerce and business units. Yet organizations are rarely structured to manage them that way. As a result, work becomes fragmented, responsibilities unclear, and experience quality inconsistent.

In this talk, we will share how we used **Journeys Management** to bring structure and alignment to one of these transversal topics: conversational experience.

We used the shared Adeo customer framework to allow design teams, commerce teams, platform product teams, and business units to collaborate through the same experience lens. Supported by a journey management tool, this approach made the experience visible across teams and helped harmonize work.

To guide product teams without prescribing solutions, we also introduced **Experience Level Agreements (XLAs)**—textual experience guidance and measurable experience metrics that define what good looks like for customers.

**The result:** clearer collaboration, better-structured requests between commerce teams and products and business units and commerce teams, improved work quality, and a shared direction for evolving the experience.

This talk shows how journey management can become **a practical collaboration and governance layer for complex, cross-team experiences.**

```

The Quotation Generator is an innovative solution designed to fully automate the creation of customer quotes, transforming a traditionally manual, time-consuming process into a seamless digital experience. At the heart of this initiative lies a critical challenge: accurately interpreting free-text inputs and recommending the right combination of products to build a complete and reliable quote.

In the second half of 2025, with the strategic support of Adeo and in partnership with TheOdo, we explored different approaches to address this challenge. In particular, we experimented with several search and matching techniques, including knowledge graph–based methods, to evaluate their potential for improving product recommendation and quote generation.

In this presentation, we will describe the experiments we conducted, the evaluation frameworks we developed to measure performance, and the results obtained across the different approaches. We will also share the key insights and lessons learned from this exploration, including cases where traditional methods proved more effective than more complex alternatives and which experiments performed better in a production environment.

We are going to share the story behind the development and deployment of our Product RAG Agent, a conversational assistant integrated into our Product Detail Pages (PDP) to answer customer inquiries.

The project has been a clear success, driving a 10% increase in average basket value.

Driven by a mindset of continuous improvement, our development cycle was punctuated by three successful A/B tests between July and December. At the core of our architecture lies the vectorization of product manuals and packaging data. However, moving to production revealed unexpected challenges, specifically regarding latency issues and skyrocketing costs.

We will detail how we rapidly tackled these SLO failures and pricing concerns by enhancing our observability.

This session is a comprehensive feedback loop: come discover how we are scaling our architecture to meet tomorrow's challenges.

In many organizations, "agility" has become a synonym for chaos. Teams are caught in a reactive cycle, where the latest request becomes the highest priority, roadmaps are abandoned, and stakeholders are left feeling disconnected and frustrated. This constant firefighting leads to low-value features, developer burnout, and a high risk of failure with every release. But what if the key to true agility wasn't more speed, but **more stability**?

This session challenges the "move fast and break things" mantra, especially in a B2B context where professional users and close business partners demand predictability. We will explore a practical, battle-tested methodology that builds a high-performing product organization on a foundation of **predictable routines and clear commitments**. This system is so effective that it not only created a stable 3-week delivery cadence but also gave me the capacity to **manage two major products simultaneously**. It turns the product owner into a strategic orchestrator who is always one step ahead, protecting the team from chaos and ensuring every release is a non-event.

Ready to dive into modern backend development? Come join our hands-on workshop where we'll show you how to use **Kotlin** to build awesome **server-side apps**! We'll be focusing on how smoothly Kotlin works with the popular **Spring Boot** framework.

### Workshop content

We'll get our hands dirty with lots of practical examples and live coding. First up, we'll get a Kotlin and Spring Boot project running to show you just how clean and simple it can be. Then, you'll learn how to create clear and safe RESTful APIs using Kotlin's handy MVC DSL, which makes setting up routes a breeze.

A big part of our session will be getting the hang of asynchronous programming with Kotlin Coroutines. We'll show you how to handle tricky, long-running tasks and build super-responsive apps without getting tangled up in callbacks. And, of course, we have to talk about one of Kotlin's best features: its null-safety! We'll show you how it helps you wave goodbye to those annoying NullPointerExceptions for good, making your code way more reliable.

### Who is this for? (Prerequisites)

- You should know your way around Java and the Maven build tool.
- It helps to have a basic idea of what Spring Boot is all about.

### Outcomes

By the end, you'll walk away with the real-world skills and confidence to **start building your own backend services with Kotlin and Spring Boot**.
You'll be all set to write code that's cleaner, safer, and way more efficient!

Everyone is writing skills. Almost nobody is testing them and most of them are AI-generated.
Skills might get "vibe-checked" with a handful of manual runs, then shipped.

## You wouldn't ship code without tests, but why ship skills without evals?

As we transition from simple chat interfaces to autonomous AI Agents, equipping LLMs with tools (APIs, functions) has become the new standard.

This talk tackles the critical missing piece in Augmented Development: Skill Engineering and its evaluation.
We will move past the "vibe check" and dive into the methodologies required to build robust, measurable agents based on industry best practices.

## What you will learn in this 30-minute session:

- LLM-Friendly design: How to write semantic schemas and tool descriptions that models actually understand, reducing baseline errors.
- TDD for AI agents: How to define success criteria and build automated tests for non-deterministic systems.
- The evals playbook: Measuring what matters by focusing on routing accuracy (did it pick the right tool?) and argument accuracy (are the parameters valid?), including how to leverage "LLM-as-a-Judge".
- Continuous refinement: Using failed evals and production telemetry to iteratively improve your skill prompts without touching the underlying business logic.

## Stop guessing if your agents work.

Join this talk to learn how to test, measure, and refine your AI skills with the same rigor as traditional software engineering.

In today's digital platforms, security incidents rarely start with hackers, they start with design decisions.

Modern applications are built on complex ecosystems of APIs, microservices, cloud-native infrastructure, and rapidly evolving development pipelines. In this environment, vulnerabilities are often unintentionally introduced during the earliest phases of software design and development.

Yet in many organizations, security is still treated as a final checkpoint rather than a foundational design principle.

This talk challenges that mindset.

We will explore why Security by Design must become a core engineering discipline, embedded directly into software architecture, development workflows, and product innovation. By shifting security earlier into the development lifecycle, organizations can significantly reduce vulnerabilities, accelerate innovation, and build digital platforms that are resilient by default.

Through practical insights and real-world lessons from large-scale digital ecosystems, this session will demonstrate how developers, architects, and security teams can collaborate to transform security from a blocker into an enabler of innovation.

Because in modern digital systems, security is not something you add, it is something you design.

In the world of retail, the "Daily Brief" for a Store Manager is a high-stakes moment of truth. Whether at Adeo or Decathlon, the challenge is identical: how to distill a mountain of data into 15 minutes of operational action. To solve this, both companies launched ambitious AI initiatives—yet our journeys, technical choices, and "Aha!" moments often differed.
In this first-of-its-kind co-presentation, the Adeo and Decathlon AI teams join forces to share their parallel quests in building intelligent assistants. We will move beyond the hype of "Agentic AI" to discuss pragmatism. While Agentic workflows offer incredible power, they come with high costs and complexity. Is a "Ferrari" always the right choice for every retail feature, or can we deliver massive value with more economical, "lean" AI models?
What we will share:
Two Paths, One Goal: A comparison of our architectures—where we aligned and where our specific retail contexts (DIY vs. Sports) forced us to diverge.
The ROI of Intelligence: How we balance the high cost of sophisticated Agents with the need for scalable, low-latency business value.
The Shared "Grit": Common failures in data reliability, interfacing with legacy systems, and the reality of deploying AI in a fast-paced store environment.
This session isn’t about perfect slides; it’s a transparent look at how two of the world's leading retailers are navigating the shift from "Data-Heavy" to "AI-Empowered" operations.

In-store mobile apps live and die by their network. At ADEO, our store associates use a Flutter app to scan barcodes, browse product pages, display loyalty barcodes and serve customers across 500+ stores, where network conditions range from excellent WiFi to near-dead mobile signal in the same building. Even in the biggest stores, the customer may encounter mixed ROPO experience.

In this crucial step to make the CMA a real companion for in-store experience, we will share how we worked on improving the resilience of our mobile application to network conditions in order to protect the user experience.

This talk covers the full arc: the business decision to move beyond online/offline, the UX design of a degradable interface, the technical architecture behind the state machine, the field experiment that broke our assumptions, and the iterative loop that made it all converge.

Attendees will leave with a reusable pattern, real data, and a practical framework for building mobile experiences that stay usable. We're on the road to a 5-star app by ensuring seamless performance and exceptional user experience, even in tough network conditions.

Our software ecosystem is more fragmented than ever as we transition from monolithic applications to dozens of specialized products. Grouped together, these services act as a platform that enables other teams to build upon various use cases.

But what does this mean for you when working within this platform? What are the key changes?

During this session, we will try to cover everything you need to know, starting with the platform engineering mindset and its technical implications (who said APIs and standardization ?).

As leader of the Decathlon Data Platform stack, we will also share the successes and failures of our journey—moving from siloed systems to unified documentation, product catalogs, lifecycles, and APIs. And all of this with one goal : better adoption, efficiency and customer satisfaction !

Data engineers often face a dilemma: use heavy, low-code ETL platforms or maintain a mountain of custom Python scripts for REST APIs and SFTP servers. At Decathlon, we chose a third way.

In this "Tool in Action" session, we will demonstrate how we leveraged dlt to simplify the ingestion of Marketing, SEO, and SEA data from fragmented sources (S3, GCS, SFTP, and various REST APIs) into our Datalake. We will walk through a live-coding-style demo showing how to:
- Turn a simple Python generator into a production-ready pipeline in minutes.
- Handle automated schema evolution and data typing without manual DDL.
- Implement robust monitoring and observability to ensure data quality at scale.

If you are looking to replace "manual" boilerplate code with a Pythonic, "ETL-as-code" approach, this talk is for you.