Discover the Talks at PyCon Colombia 2026 ✨
Browse every accepted session—titles, tracks, levels, and speakers—before you plan your days in Medellín.
Future-proof Engineers with AI-DLC
The Problem Today, many engineers have fallen into a trap: they are using Artificial Intelligence simply as a "glorified autocomplete" to write code faster, leaving architectural design aside. The real challenge arises in the real world: technical teams often do not know how to take an AI-based idea to production safely, scalably, and maintainably. The Solution: Future-proof Engineers with AI-DLC This is a practical, intensive workshop designed to break that stagnation. Our goal is for you to stop being a passive consumer of AI tools and become an architect capable of applying the AI Development Lifecycle (AI-DLC) as a structured work framework. We will teach you to take control and increase ownership in your projects. Who is it for? Mid and Senior software engineers looking to evolve their skills, master modern system design, and lead AI integration in their work teams.
Carlos Alberto Riveros Varela
Senior Software Engineer @ EPAM Systems
Jesús Alfredo Reyes Vargas
Lead Software Engineer @ EPAM Systems
Employability in the Age of AI
Artificial intelligence is changing the job market faster than ever. Many developers wonder: will AI replace me or empower me? In this talk I'll share my real experience going from being a developer in Latin America to working for companies in the United States—facing interviews, optimizing my professional profile, and adapting to an environment where AI is already part of daily life. We'll explore how AI doesn't replace the developer but redefines the value we bring: from writing code to solving real problems, communicating ideas, and building complete solutions. The talk will cover the future of programming, how to shift your mindset toward AI, which skills really matter today, how to stand out in international hiring processes, the role of AI tools in your professional growth, and common mistakes that hold back your employability.
Structured Learning: An AI-powered platform that transforms academic papers into interactive learning experiences.
Structured Learning: The AI Platform That Other AI Agents Build" Subtitle: A real platform that converts academic papers into interactive learning modules, built as a solo developer with an agent pipeline that takes every GitHub issue to a merged PR, on pure Python, async FastAPI, and AWS What do you do when you need to understand and implement a research paper, and existing tools force you to jump between five tabs — PDF viewer, ChatGPT, IDE, notes, a search engine — and every jump breaks context? And what happens when, on the other side of the problem, you're a solo developer trying to build something serious to solve it, with AI agents that usually work well in demos but fall apart in production? This talk is the engineering story of Structured Learning: a platform that converts a research paper into a complete learning module — chapter-by-chapter explanations, incremental executable code, RAG chat, FSRS spaced-repetition flashcards, equation derivations, and a Neo4j knowledge graph connecting concepts across the user's entire library. Nineteen of forty-two features delivered as a solo developer. The product is the visible half. The interesting half is how it was built. The first topic is the product. Where a static tool promises "upload the PDF, get a summary," Structured Learning accompanies the three phases of working with a paper — researching it, understanding it, and applying it — across four custom AI agents in async FastAPI and LiteLLM, with multi-provider support across Anthropic, OpenAI, Google, DeepSeek, and Ollama. The second topic is engineering: an agentic development workflow pipeline that takes a GitHub issue to a merged PR — planning, implementation, tests, review, automatic patching, conflict resolution, documentation, and release. Each phase runs in an isolated git worktree with its own port range, so agents actually run in parallel without checkout contention. Commands in GitHub comments (/plan, /patch, /conflict) trigger background workflows that post phase-by-phase progress back to the same issue, creating a human-readable audit trail. Adaptive routing sends trivial classification to fast, cheap models, and heavy review or debugging to stronger models. PR creation is deferred until all quality gates are green — unit tests, end-to-end tests, and review. When review finds blockers, the pipeline automatically launches a patch workflow to fix them in place and re-runs verification. Real self-repair, no human in the loop for the common "almost right" case. The third topic is production: how this runs on AWS without breaking, and how we develop it locally without paying for cloud. The entire stack — S3 for PDF uploads and TTS audio cache, ECS Fargate for FastAPI backend and GROBID service, RDS PostgreSQL 16 with pgvector extension consolidating application DB and vectors, Secrets Manager for credentials, ECR with immutable image promotion — lives on Terraform with per-environment directory separation. The key to maintaining dev↔prod parity is LocalStack plus a single variable (S3_ENDPOINT_URL): the same boto3 client runs identically on both sides, no code branches, no mocks in tests. docker compose up reproduces the full AWS topology locally, enabling end-to-end flows — paper upload, audio generation, caching — without real credentials or cloud costs during development. You'll leave with a clear view of the product — a platform that covers the three phases of working with an academic paper. For research, it offers conversational search over arXiv and OpenAlex, and a Neo4j graph that detects shared concepts, knowledge gaps, and optimal reading order across your entire library. For explanation, it generates chapter breakdowns with key concepts and diagrams, step-by-step equation derivations that demystify the math, RAG chat and Socratic mode that answers with the paper's full context, and an annotatable PDF reader with "Ask AI" on any selection. And for practical application, it produces executable code that builds incrementally with dependency tracking, FSRS flashcards for measurable long-term retention, and comprehension quizzes that validate understanding chapter by chapter. And with three concrete engineering recipes to reproduce in your own stack. One for building serious AI products without magic frameworks: typed contracts with Pydantic, SSE streaming with cancellation, prompt caching, and per-task cost accounting. Another for scaling a solo developer to team velocity by applying agentic discipline to your own development cycle: isolated worktrees, resumable pipelines, auto-patching after failed review, GitHub as the agents' API. And a third for eliminating "works on my machine" from AWS infrastructure using LocalStack as a local S3 mirror. The thesis: agents don't replace engineers, they replace the glue between engineers and the boring 80% of the SDLC — and that's where compound returns live.
Provenance by Default: AI Media Pipelines in Python
A model can now generate a video that looks indistinguishable from one your camera recorded. The same is true for an image, a voice, or a song. As Python developers, we are building those pipelines — and we are also the ones who will be asked, very soon, to prove what came out of them. This talk is about building generative media pipelines in Python in a way that answers that question by default. We'll walk through Genblaze, an open-source SDK (github.com/backblaze-labs/genblaze, MIT licensed) that I work on at Backblaze, and use it as a vehicle to talk about the design problems any team faces when wiring AI generation into a real product. We will cover, with live code: 1. The Pipeline pattern. A fluent Pipeline → Step → Run → Manifest API built on Pydantic v2 and Runnable[In, Out] ABCs. Sync, async, and streaming runners share a single mental model. We'll see how chain=True propagates assets, how input_from=[0, 1] enables fan-in for AV compositing with FFmpeg, and how fallback_models=[...] retries automatically when a provider drifts. 2. One API, eleven providers. OpenAI Sora, Google Veo, Runway, Luma, Decart, Replicate, ElevenLabs, Stability Audio, LMNT, GMICloud, NVIDIA NIM — all behind the same submit / poll / fetch_output lifecycle. We'll see how a thin provider ABC plus a runtime-extensible ModelRegistry lets you adopt a model the same week it's released, without waiting for a library update. 3. Provenance that survives the file. Every run produces a canonical, SHA-256-verified manifest (deterministic JSON, sorted keys, NFC unicode, normalized floats) that gets embedded into the media itself PNG iTXt, JPEG/WebP XMP, MP4 UUID box, MP3 ID3v2, WAV LIST/INFO. We'll extract and verify a manifest from a real .mp4. We'll talk about what the hash does prove (integrity) and what it doesn't (authentication), and why that distinction is the entire point. 4. Privacy and policy. EmbedPolicy lets pipelines redact prompts, strip parameters, or swap to pointer-mode sidecars. SSRF protection on webhook and asset transfers. Trust modes for adversarial verification. 5. Storage and replay. Durable B2 / S3-compatible URLs, content-addressable layouts, and a CLI (genblaze extract / verify / replay / index) that turns any manifest back into an executable pipeline. 6. Agent loops with lineage. AgentLoop composes a pipeline factory with an evaluator; every iteration is linked via parent_run_id, so refinement chains are first-class in provenance — not a side note in your logs. By the end, attendees will have a clear, opinionated reference for how to architect generative-AI features in Python so that "what did this system actually produce, and can I prove it?" is a one-line answer instead of a ticket.
Lessons Learned Reporting Vulnerabilities in the Python Ecosystem
You've surely received that notification telling you to update a dependency due to a security flaw. But have you wondered what happens from when someone discovers that vulnerability until the patch reaches your project? In this talk I'll share my experience reporting vulnerabilities in the Python ecosystem. We'll explore the behind the scenes: from the technical finding and reporting process to collaboration with maintainers and patch publication. We'll address not only technical aspects but also the human factor—both crucial for effective vulnerability resolution. The challenges maintainers and the community face, especially in this new era of open source software security where artificial intelligence plays an increasingly relevant role.
