Three days of focused opportunities for learning and networking.
DevConf is one of Poland's premier annual conferences dedicated to software development. It's based on principles we believe are the success factors of an ultimate conference experience. Regardless of technology, we strive to spark inspiration by exchanging ideas. We facilitate learning as a process occurring at talks and during informal conversations. Knowing that great sessions are not enough we're also eager to provide excellent networking opportunities. People and interactions are what we value the most.
The whole event is divided in two parts:
pre-conference workshops happening on 08 Oct 2025
and the conference itself on 09-10 Oct 2025.
Meet our professionals.
More speakers still to be revealed.
Some of you join us also for more in-depth and hands-on knowledge. As a response, we organize workshops a day before the conference.
Tickets are being sold separately, regardless of the conference ones.
Conference opening by the organizers, city of Łódź representative Mateusz Sipa and our Platinum Sponsor - ABB.
JavaScript was famously created in 10 days as a proof-of-concept for Netscape Navigator 2.0. Today it is one of the most-used languages in the world. Some people even like it.
In this talk we will chart the path from the dark days before programming languages, through the ups and downs of the early pioneers, all the way to 1995 and the creation of JavaScript.
We will meet the giants on whose shoulders Brendan Eich stood, and speculate about what they might think of modern JavaScript. You will learn interesting things about language design (good and bad), computer internals (weird), and committees (just bad). You’ll see FizzBuzz implemented at least a dozen times. It’ll be fun.
In a world where everyone talks about Microservices, containers and Kubernetes, it can be very inviting to jump on this bandwagon, no matter your actual need for it.
In this talk, we’ll look at a real-life story of scaling back from an over exaggerated Microservices architecture, in an e-com solution for an European leader within their industry. For them, Microservices was way overkill for the needs of the company and the technical organization. We’ll look at a reverse approach, where you start as simple as possible and start making things more complicated only when needed.
There are some good mental guidelines that you can think about, step by step, as a checklist for when it’s time to move forward. This might eventually end up in a Microservice architecture, but that’s very rarely the most balanced starting point.
Modernization of .NET Framework applications is usually a complex task, requiring many code changes in all project areas. Most teams prefer going the safe way - making the smallest possible number of changes to prevent the introduction of bugs or incompatibilities. Sadly, there are numerous applications where poor code quality is a much larger problem than the old libraries being used - I am sure everyone has seen thousand line long methods combining data access, business logic, and presentation concerns.
In this session, I will show a real-world example of migrating a complicated room reservation routine written entirely in the ASP.NET Web Forms code-behind file. Using the advantages of the new .NET, such as dependency injection, I'll transform the spaghetti code into a bunch of testable classes. Subsequently, I'll use GitHub Copilot to generate test data when covering the functionality with unit and integration tests.
While this approach takes slightly more effort than just copy-pasting the old code, it greatly improves code quality, simplifies further code maintenance, and makes the code reusable.
Many teams organize their software around data structures and entities, assuming that their data(base) models naturally define the right boundaries for their modules. This data-focused way of thinking often leads to fragile architectures and modularization that don’t match how the business actually evolves. As a result, teams skip the important step of Strategic Design and jump straight into technical solutions, which causes their systems to become difficult to change and grow over time.
To create software that can adapt and last, we need to move away from data-oriented approach (designing system around nouns, data normalization, no redundancy etc) and instead define boundaries based on Business Capabilities, Business Processes and Domain Archetypes.
In this talk, we’ll see the above, illustrated within the logistics domain, using practical examples to clear up common misunderstandings and show why strategic DDD is key for building better software.
I've been a Microsoft field engineer for fourteen years—learn from my experience and mistakes. Today’s landscape of architectural choices for enterprise solutions is vast, with real problems to solve and real issues that come with those solutions. Big enterprises or small, problems are problems. There are plenty of tools and frameworks, but what really sets enterprise solutions apart from one-off applications are the fundamental patterns. In this session, we’ll break down a typical enterprise architecture piece by piece, focusing on the decisions engineers and architects make when tackling common problems and requirements. We’ll dive into areas like scalability, security, integration, and maintainability, giving you practical insights whether you’re new to the field or just need a refresher.
Step into the time machine and journey back to the late 80ies and early 90ies with Anders Norås as he delves into the genre defining era of the 16-bit demoscene.
These were the glory days where human ingenuity clashed with machine capabilities in a perpetual battle of digital creativity.
In this talk, attendees will be treated to a nostalgic exploration of the subculture's pinnacle, witnessing firsthand the relentless competition and boundless innovation that defined this epoch.
Whether you're a seasoned enthusiast or completely new to the scene, prepare to be entertained and inspired by the timeless ingenuity and artistic fervor that characterised the early days of the.
Join us for a journey through time and witness the enduring legacy of creativity that still makes its marks on popular culture.
After Agile, DevOps, SRE and product management, a new trend called platform engineering has recently dominated our software industry. During the presentation, we will discuss its concept and the problems it solves that previous solutions did not. Katarzyna, who works as Director of Platform Engineering, will also talk about how the platform engineering approach was adopted in Fedex Dataworks Poland among her engineering teams to implement a new cloud-based platform from scratch.
How does a highly functional development team manage enterprise data engineering? They focus on the core principles of Schema Management, Standards Enforcement, Database Testing, and Automated Incremental Deployment. Microsoft brings an agonizing menu of choices to architects and engineers; they can be a challenge to wade through. This session can help. Let’s review how some of the world’s largest and most critical app & data engineering teams handle change management, observability, and quality at enterprise scale.
Goals:
Manual dependency checks are no longer sufficient. The software supply chain faces an evolved threat: Slopsquatting. In this talk I’ll expose the nature of AI-driven Slopsquatting, a technique exploiting subtle naming variations and developer habits to inject malicious code.
I will dissect why this threat vector is particularly insidious, how AI enhances its effectiveness, and the high probability that your current practices leave you vulnerable.
In this talk I’ll show concrete examples from the real world on how to counter this behaviour.
Learn how to integrate automated checks, enhance vetting processes, and adopt DevSecOps strategies crucial for safeguarding your applications and understanding the collective responsibility we share in securing the open-source landscape.
Define Slopsquatting and how AI transforms it into a scalable, sophisticated threat.
Analyze the specific vulnerabilities exploited by AI-driven Slopsquatting.
Evaluate the risks associated with inadequate dependency management in CI/CD pipelines.
Implement robust, automated strategies to counter Slopsquatting threats.
Understand the broader implications for software supply chain security.
Imagine a self-healing system that handles surprises, letting you sleep peacefully. If that sounds appealing, chaos engineering could be the answer. Trusted by Netflix, LinkedIn, Google, and Facebook, it’s key for business resilience. In this session, we’ll explore its history, learn how to apply its principles to stress-test applications, and review tools for fault injection in real-world scenarios.
Explore the frontier of software development with "Code Complete: The Day AI Writes Your Next App!" This engaging session dives into how artificial intelligence (AI) is revolutionizing the coding process, making it possible for machines to assist in, and sometimes even take over, the creation of software. We'll cover the latest AI tools that are transforming development workflows, significantly reducing error rates and development times. A highlight of this session is a live demo, illustrating AI's capability to write code. This presentation is essential for anyone interested in the future of software development, from seasoned developers to tech enthusiasts. Discover how AI is not just a tool but a game-changer in building the applications of tomorrow.
This talk outlines an open-source project for smart gardening and small-scale agriculture. The project aims to collect sensor data, display it in real-time, store it long-term, and control processes like irrigation and lighting. The system is divided into a local (field) deployment and a remote cloud deployment.
The local environment uses low-power IoT technologies and relies on a Raspberry Pi as the cloud gateway and local controller. Zigbee is the chosen local communication standard due to its open nature and established device market. Data from Zigbee sensors is relayed via a custom-made Zigbee Hub (Raspberry Pi Zero 2W with Zigbee2MQTT and Mosquitto MQTT broker) to OpenHAB running on the Raspberry Pi 4B. OpenHAB stores this data in a local InfluxDB instance. A Wireguard VPN ensures secure communication with the cloud and a static IP address for the Raspberry Pi.
The cloud environment provides long-term data storage and visualisation. Data is replicated from the local InfluxDB instance to a cloud-based InfluxDB. Grafana is used to visualise and analyse the collected data, using the cloud replica of InfluxDB as its data source. A future goal is to implement machine learning for data analysis. The project was partially funded to develop a locally produced product. The developer's background includes full-stack web development and open-source contributions. The personal motivation stems from family land requiring remote automation.
Every engineering team I’ve worked with believed the same myth: if we just clean up the backlog, structure the sprints, and polish the requirements — the product will somehow build itself.
Then I joined a team that had everything going for it: senior engineers, solid processes, a roadmap, leadership support. And still — for eight months, they delivered nothing meaningful for a real user.
The product was ambitious: Bitcoin-collateralized loans. The market was unstable, the regulations unclear, and the team was paralyzed. Everyone assumed someone else had already figured it out. That we weren’t allowed to ask. That we had to wait. That it was safer to stay silent.
Until one question changed everything: “What are we truly not allowed to do — and what have we just never dared to test or ask?”
That question unlocked momentum. We realized we didn’t need the whole system to talk to regulators. We didn’t need a finished product to start learning. We didn’t need permission to start thinking. Within three weeks, we delivered an MVP that had been stuck for nearly a year.
This talk is not about frameworks or best practices. It’s the story of how a team stopped coding on autopilot and started thinking. You’ll learn how assumptions quietly kill productivity, how to build teams that understand the why behind their work, how to coach engineers to ask the questions that matter, and how to break decision paralysis in a world full of fear, noise, and conflicting signals.
I combine psychology, engineering, and hands-on leadership to help teams deliver products that matter — faster, smarter, and with courage. If you lead people and feel like something’s blocking them, this talk will help you unlock not just the code, but the mindset.
The one who rules the quantum computer rules the world. We have all heard and maybe already worked with AI but what about Quantum computing? Is this the next "best thing"? Quantum world can be intimidating, so let me take you on a journey where we will try to find a sweet spot between explaining quantum by mathematical equations that leave you more confused than smarter and the superficial statements that "quantum computers are just faster computers". We will start by introducing basic concepts from the quantum realm like entanglement or superposition, then we will focus on main differences between a quantum and a digital computer. We will answer the question "what are quantum computers good for?" and "when can I buy my own quantum computer?". We will look at the market predictions and the impact of quantum on the cyber security and the current encryption protocols.
Agenda:
Ah code reviews. We need them, but we dread them. We do them, but not well. How do we deal with gigantic PRs? Why can't we write effective code review comments? How do we make code reviews shorter? Is SSDaaRB (Single Senior Developer as a Reviewer Bottleneck) something we just have to accept? In this talk, I'll not only answer these questions, but give you actionable advice on how to improve your code review today!
I want to tell you:
Let's change the way we do code reviews. Let's do better than LGTM 👍 – let's make the code review processes on our teams great!
Over the years, I’ve written all kinds of code—bad code, good code, and a lot that falls somewhere in between. I’ve worked in many roles, hired people, sometimes fired people, and mentored others along the way. Through it all, I’ve stayed pretty happy with what I do.
Lately, though, I keep hearing the same questions from developers: “Do I have to become a manager to grow my career?” “What if I’m happy just writing code?”
If you’ve ever felt that way, this talk is for you. I’d like to share my perspective on what career growth can look like for developers who love coding and don’t want to "climb the ladder" in the traditional sense.
This is about finding success, satisfaction, and progress without feeling like you’re stuck or missing out.
In the world of software development, programming languages and frameworks are more than just tools—they can become badges of identity and sources of near-religious devotion. In this talk, we explore how developers often form "dev tribes" around their favorite languages, complete with rituals, jargon, and fierce loyalty.
Drawing from themes in anthropology and tech culture, this session will examine both the positive and negative consequences of these tribal affiliations. On one hand, they foster community and innovation, but on the other, they can lead to exclusion, gatekeeping, and rigid dogma.
Through humor and ethnographic analysis, this talk will shed light on how the lines between culture and code blur, offering an amusing and thought-provoking look at the world of programming fanatics. Expect to laugh, reflect, and maybe even recognize yourself in these "dev tribes" by the end!
Remember when we built systems without spinning up seventeen microservices before breakfast? This session is your permission slip to step off the cloud hype treadmill and breathe again. We'll explore how the "cloud all the things" mentality has led us into a labyrinth of unnecessary complexity where simple problems now require doctoral dissertations to solve. Through humor, war stories, and uncomfortable truths, we'll rediscover the radical notion that boring technology often works better than the shiny new thing everyone's tweeting about. Attendees will learn practical strategies for cloud detox: when to embrace cloud services that genuinely add value, when to choose the simplest possible solution, and how to explain to your CTO why you're not containerizing the company blog. Join us for this intervention on cloud addiction and leave with a renewed appreciation for intentional tech choices that won't require weekend pager duty.
Most of modern software design and programming is characterised by tension and trade-offs. Making the wrong decisions often casts long shadows over a system and dooms it's maintainers to endless toil and strife. This leaves us stuck in a pendulum swing of system design techniques that are reduced to conversations about monoliths and microservices, rather than about the characteristics of the systems we're really building.
In this session, we'll cover techniques for understanding context, designing with trade-offs in mind, and building software that survives inevitable change, in non-controlled environments.
With examples from real-world systems, we will learn language that we can use to talk about design, so that we can design systems with Intentionality that are sympathetic to the humans that need to build them.
Finally, we'll cover the eternal relationship between design, architecture and programming - along with the different aesthetic viewpoints you need to help them coexist and evolve together.
"Intentional Code part 2: This time for architecture and design!"
Why are code changes simple nowadays? Because we write code to be self-documented, use versioning to keep a whole history of changes, developed methods to test code instantly. Thus, we may change code more easily, the software development life cycle became faster and effective. These foundational techniques and 'as-code' practices are now possible to utilize in Software Architecture and System Design. Mature tools are right there, like C4 modeling tools, PlantUML, Marmaid, DSLs like CNCF Serverless Workflow, interactive diagrams, code generation with OpenAPI Generator or AsyncAPI Modelina. And because of generative AI, the agile architecture and architecture as code could be among the fastest trends of the next decade.
When dealing with large-scale software solutions, several limitations to growth may appear. One of them is outdated documentation, incomplete communication of requirements, reasons for previous decisions, or behaviors of the system's parts. As businesses extend their processes, the variety of utilized processes, teams and technologies increases rapidly. The web of dependencies grows between our services or subsystems, but more critically among various groups of stakeholders, specialists and target customer groups.
Within the lecture we will explore and evaluate specification standards like OpenAPI, AsyncAPI, OpenRPC, Arazzo. We dive into emerging text-to-diagram tools like Sequencie Diagram, PlantUML, Mermaid, more advanced D2. Also tools to automate documentation like ArchUnit, EventCatalog, Kogito, Docusaurus, Backstage from Spotify. And of course, we would touch Infrastructure as Code (IaC) and GitOps as proven weapons of automation.
Having a background of the generative documentation landscape we will go towards practices to build collective knowledge about our systems. On real-world examples we will explore use cases for automatically updated context maps from Domain-Driven Design practices. System design with Architecture as Code (AaC) and API versioning with Specification as Code (SaC) and Generative Contract Testing.
After four years of building, breaking, and learning at iBOOD, we’ve discovered what makes a development team truly successful. No frameworks, no dogma—just seven practical habits that help teams ship great software, stay motivated, and keep improving.
This talk is based on real experiences, not theory, nor agile BS. We’ll dive into:
I’ll share stories from the trenches—what worked, what failed, and what we’d never do again. If you’ve ever wondered how to build a team that doesn’t just survive but thrives, this talk will give you concrete ideas to take back to your team.
This talk offers a brutally honest, experience-based look at what makes software teams successful, without buzzwords, silver bullets, or agile theater. Backed by four years of hands-on learning at iBOOD, it distills real-world lessons into seven practical habits any team can adopt.
Attendees will walk away with fresh insights, concrete takeaways, and war stories they can relate to—whether they’re scaling up, starting over, or just trying to survive the chaos of modern software development. It’s equal parts inspiration, reflection, and practical advice—and it’s precisely the kind of talk developers wish their managers had heard.
WebAssembly has been buzzing for a couple of years now. You have likely heard about some of WebAssembly's proclaimed superpowers like security, performance, and cross-platform interoperability. Yet, you may still be unsure of where and how WebAssembly fits into the broader ecosystem. In this talk, I want to share with you the picture that has emerged for me through my research and experiments.
Join me to see how this buzz has paved the way for WebAssembly beyond the browser and into cloud-native environments. We will take a look at how Azure attempts to tap into this potential through experiments in the Azure Kubernetes Service space. We will also explore third-party projects that can enable us to harness it, like SpinKube or Kwasm.
Sometimes the best Git tricks aren’t in the docs — they’re on the battlefield.
In this session, I’ll share the guerrilla tactics, creative workflows, and unexpected hacks I’ve learned from real-world Git battles. I’ll show you how I’ve used Gists not just to share snippets, but to automate tasks, collaborate faster, and build lightweight workflows. I'll walk you through how I bent GitFlow to fit messy, real-life projects where urgency beats perfection. And I’ll show you how I turned Git into a personal productivity engine — managing not just code, but knowledge, experiments, and even my daily workflow.
This isn’t a textbook session. It’s a field guide: full of fast demos, practical ideas, and survival moves you can start using right away.
Feature flags have revolutionized the software delivery lifecycle, enabling teams to decouple releases from deployments and create a more agile development process. They're often hailed as one of the key practices in modern software development—at least in theory.
However, as systems grow in complexity, so do the challenges associated with feature flagging. From supporting multiple languages and managing targeted evaluations to avoiding vendor lock-in and safely decommissioning obsolete code, what initially seems like a straightforward problem can quickly become daunting.
The OpenFeature community is tackling these challenges head-on by providing vendor-agnostic SDKs and a suite of powerful tools designed to simplify the feature flagging experience. Join me as we explore the common pitfalls of feature flagging and discover how OpenFeature can help bring the fun back into this critical aspect of software development.
As the famous Phil Karlton quote goes: "There are only two hard things in Computer Science: cache invalidation and naming things". This talk focuses on one of those things: naming!
Why is naming so difficult? How do we craft concise, clear, and consistent variable names? What makes a variable name concise, clear, and consistent? In this talk, I'd like to discuss the importance of naming, walk through examples of variable names and improve them, and set some clear guidelines and tips on how to name things.
By the end of this talk, you'll leave with the indispensable skill of effectively naming things!
The IT industry often promises a land of opportunities, but reality can feel more like a fast track to burnout. Research shows that burnout doesn’t discriminate—affecting everyone, regardless of gender, age, or experience (though how we experience it can differ).
In this session, we’ll unpack the work-related factors that fuel burnout in IT, including workload, long hours, and even the stress of commuting. You’ll discover practical strategies to address these risks and learn how to create a healthier balance between productivity and mental well-being.
Grounded in the latest scientific research and expert recommendations, this talk will also include personal insights from my own burnout journey, along with field-tested strategies that have helped my clients thrive.
If you’ve ever wondered if there’s a better way to work in IT—this session is your starting point.
Get yours while they're still available.
* All listed prices do not include 23% VAT
See what we did in the past.
Take a look at 2024, check out the full gallery or see our short video clip.
Companies that support us.
If you or your company would like to reserve a spot as a sponsor, contact us because we might have a good deal for you.
Communities we love.
Łódź Expo, aleja Politechniki 4
Łódź, Poland
From the very beginning we've been focused on people, not on companies. Being developers ourselves we thrive to provide the ultimate experience that will be remembered. We'd like to connect awesome speakers with the willing-to-learn-and-share community. It's not only about sessions - it's also about meeting with like-minded people - it can result in great ideas, is that right?
DevConf Team
Dev Events Sp. z o.o.
ul. Wielicka 91/4
30-552 Krakow, Poland
VAT ID/NIP: PL6793284690
