VIGCON2026

This talk is an unfiltered post-mortem of a company-wide, enforced AI rollout across the entire SDLC — from analysts and developers to testers, DevOps, and L2 support.

We will show:

• ●real before/after metrics,
• ●role-specific performance and quality benchmarks that cannot be met without AI,
• ●measured productivity gains of top performers in the hundreds of percent,
• ●how role-specific AI toolchains, skill-based agents, and AI guidelines were built,
• ●and why our 2026 goal is a company-wide 50% productivity increase, not just "feeling better about AI".

We won't avoid the uncomfortable parts:

• ●massive developer resistance,
• ●frustration and the collapse of the myth of "seniority without changing habits",
• ●broken metrics, bad calls, and internal fuckups.

No slides about "the future of AI".
Hard data. Real processes. Measurable impact.

If you want to see what the world looks like when AI is no longer an advantage but the minimum standard, this talk is for you.

In this session, we will explore how modern AI workflows can significantly speed up software development and enable a "one-shot" approach to delivering business requirements.

In the first half, we will introduce key AI concepts and building blocks used in today's AI-driven solutions, such as rules, guidelines, sub-agents, AI skills, slash commands, and MCP servers.

In the second half, we will shift to a hands-on perspective and demonstrate how these AI features are implemented in our frontend development AI workflow. Using a real-world example, we will show how a business request can be transformed into a working solution in a single shot — faster, more consistently, and with minimal manual effort.

Hashtags: #AIWorkflow #AIAgents #Windsurf

What does it take to replace Camunda in a real enterprise environment?

This talk is a case study of why and how we built ZenBPM — now an approved strategic direction for workflow orchestration across our platform landscape.

In projects like Neuron, Experta, and EOP, one thing became clear: platform applications cannot stay truly universal while remaining tightly bound to one BPM product, its pricing model, and its operational constraints.

We will show how we changed that:

• ●from Camunda-specific implementation to platform-agnostic architecture,
• ●from workflow lock-in to adapter-based flexibility,
• ●from fragmented UI patterns to a more universal model based on micro frontends, shared search, and unified task visibility.

ZenBPM is our answer to Camunda 8 pricing, operational complexity, and the need for a BPM foundation that gives architects more freedom and management more financial control.

No theory.
No generic BPM talk.
A real replacement story — with architectural impact, platform consequences, and business relevance.

This talk shows how AI changes software delivery when specifications stop being static documents and become the real engine of development.

Starting from a single business sentence, we demonstrate how AI can expand intent into a business specification, compare solution variants, produce an AI-optimized technical specification, and prepare the exact context needed for high-quality AI-assisted implementation.

We will show:

• ●how AI helps remove ambiguity before coding starts,
• ●how contrasting solution options make architectural trade-offs explicit,
• ●how technical specifications can be structured specifically for AI-driven delivery,
• ●and why guidelines and standards are essential if AI is expected to produce scalable, maintainable enterprise code.

The result is not just faster coding.
It is faster understanding, better decisions, higher-quality specifications, and a delivery model where AI becomes predictable instead of improvisational.

No generic prompt engineering.
No "AI will solve everything" slogans.
A practical model for turning business intent into implementation-ready structure at much higher speed and quality.

Manual test creation does not scale well enough for modern delivery. This talk shows how AI changes that.

Using Junie and a defined set of testing guidelines, we demonstrate how test generation can move from slow, repetitive manual work to a faster, more structured, and far more scalable model for enterprise automation.

We will show:

• ●how AI generates tests from implementation context and structured inputs,
• ●why strong testing guidelines are the difference between useful automation and AI-generated noise,
• ●how API, database, and Kafka test scenarios can be produced in a consistent way across technologies,
• ●and how AI helps convert test intent into executable automation with much less effort.

This is not about generating more tests for the sake of volume.
It is about generating better tests faster — in a way that is controlled, reviewable, and aligned with real engineering standards.

The talk also includes a practical example of transforming Jira Xray test cases into an automation test framework, showing how AI can help close one of the most persistent gaps in enterprise testing: the distance between documented test scenarios and real executable tests.

No hype about "AI replacing testers".
No fantasy about one-click quality.
A real case of how guided AI test generation can reduce effort, improve consistency, and make test automation scale better than manual creation ever could.

In this session, you will see how a mature design system can be effectively used as a foundation for AI-driven prototyping.

We will demonstrate how AI can generate realistic prototypes directly from requirements and analysis, enabling fast visual validation of solutions. How this approach helps uncover specification gaps early, reduces feedback loops after implementation, and accelerates the end-to-end delivery process. We will also show how complex data models and datasets can be quickly transformed into interactive prototype scenarios and multiple design variants.

Real project examples will illustrate different AI prototyping approaches, including structured generation with real React components and frontend rules that can serve as a direct foundation for further development.

Robotic Process Automation (RPA) is now a well-established technology used across many industries, and it has taken root within VIG as well. Thanks to RPA, colleagues at Kooperativa and ČPP are freed from repetitive, tedious tasks that software robots can perform faster, more reliably, and virtually 24/7.

In this talk, we will explore how RPA works in practice, which types of processes we automate, how our approach may differ from that of other companies, what impact AI and large language models may have on the future of RPA, and how the role of software robots might evolve in an AI-driven world.

As a microservice grows, it can slowly start to feel like a monolith — bloated codebase, unclear boundaries, and teams stepping on each other's toes. This talk explores how we tackled a fast-growing microservice developed in parallel by three teams, introduced strong modular boundaries, enabled effective collaboration, and laid foundations for a future split into independent microservices without stopping feature delivery.

Efficient scheduling and routing of field technicians is essential for delivering timely vehicle inspections, both before new insurance contracts and after claims. Today, this planning is completely manual, time‑consuming, and often results in suboptimal routes and unnecessary travel.

The *Rozdělovač* project aims to replace this manual effort with a data‑driven optimization system capable of automatically generating daily plans for handling hundreds of inspection tasks. In this talk, we will guide you through the PoC phase of the project, including the development of testing tools and the complete data-science workflow — from data cleaning all the way to solving a Workforce Scheduling and Routing Problem using an optimization engine.

Our results show significant reductions in total travel distance, demonstrating strong potential for operational efficiency gains, and more importantly, enabling a completely new way of working.

Keywords: Optimization, Data Science, Scheduling and Routing, Task Allocation, Cost Minimization

Kafka scales well, until the way you manage it doesn't.

For a long time, our Kafka ecosystem was managed centrally. Topics, users, ACLs, and schemas were provisioned through Python scripts executed in CI/CD pipelines. This approach gave us consistency and control, but as adoption grew, its limitations became clear: slow onboarding, operational friction, increasing coupling between teams, and a deployment model that did not scale with the organization.

In this talk, We will share our journey from this centralized deployment model to a decentralized, Kubernetes-native approach powered by a custom Kafka Operator.

We will focus on:

• ●Which problems the operator solved immediately and which ones it did not
• ●New challenges we had to address along the way, including security, validation, guardrails, multi-tenancy, and governance
• ●How responsibilities shifted between platform teams and application teams
• ●What surprised us during the transition, both positively and negatively

Managing insurance contracts means dealing with a complex data model — combining contract instances with rich product definitions while preserving strict referential integrity. We show how we redesigned data loading, leveraged caching, and introduced batch persistence to improve read/write performance while keeping the domain model consistent and robust.

Web Application Security in Practice

This presentation introduces Content Security Policy (CSP) as a practical security mechanism for protecting against XSS and other client-side attacks. We will show how CSP works, what real-world problems it addresses, and how to deploy it in a production application with more than 8,000 active users, without any noticeable impact on user experience. Don't just aim to satisfy an audit - configure CSP headers thoughtfully and actually protect your users.

Introduction

• ●CSP as an additional layer of defense
• ●Protection against XSS and execution of unauthorized JavaScript
• ●Limiting data exfiltration and abuse of external resources

Overview of the most important CSP directives

• ●Most commonly used directives (default-src, script-src, connect-src, ...)
• ●Server-Side Rendering (SSR) vs React Front-End (SPA / CSR)
• ●Nonces as a powerful tool for SSR
• ●Error handling, report-sample

CSP in our practice

• ●Delivery CSP rules to real application - KNZ/SUSP (8,000+ active users and 5,000+ contracts agreed daily)
• ●Monitoring as a never-ending process - APM, Dynatrace
• ●Using Report-Only mode