
About us
A group for experienced and aspiring data professionals.
Join our Slack: https://datatalks.club/slack.html
Upcoming events
10

Stock Markets Analytics Zoomcamp 2026 Pre-Course Live Q&A
·OnlineOnlineInterested in applying Python and data analytics to the stock market? Join Ivan Brigida for an interactive live Q&A session ahead of the third edition of the Stock Market Analytics Zoomcamp.
During this session, Ivan will walk through the full course curriculum, highlight real-world projects built by previous students, and share insights from this year’s participant registrations. It is dedicated for answering your questions live to ensure you are fully prepared before the course kicks off on August 24th!
We’ll cover:
- In-depth breakdown of the core learning modules and what to expect across each stage of the course.
- Showcase of top student projects from past cohorts demonstrating practical financial analytics skills.
- Brief analysis of participant survey data offering an overview of the incoming cohort's diverse backgrounds.
- Live interactive Q&A session answering all your questions regarding prerequisites, tools, and course logistics.
About the speaker:
Ivan Brigida is the creator of PythonInvest.com and a retail investor. He has worked as an analyst for over 15 years and applies those skills to enhance his own investment strategies and research methods.He also runs a free course on Stock Market Analytics, which will launch for its third edition in August 2026.
Join our Slack: https://datatalks.club/slack.html
11 attendees
DevOps and Observability for AI-Built Apps
·OnlineOnlineThis is the 4th workshop in our series to update the AI Dev Tools Zoomcamp content.
This workshop updates Module 4: DevOps and Observability for AI-Built Apps.
The previous workshop ended with an app that deploys automatically when the tests pass. That gets it online. It doesn't tell you whether it still works.
In this hands-on session, Alexey Grigorev will build the loop that closes that gap: observe user impact, alert with context, investigate from evidence, authorize a bounded response or escalate, verify recovery, and audit both the code and the response trail.
We also put a coding agent inside that loop as the first line of support. It collects the same evidence you would, compares it with recent changes, and proposes an action. What it doesn't get is production credentials. A model supplies confidence. Code outside the model enforces permission.
## What You'll Learn
- Which questions you can't answer about your own deployed app right now, and why a dashboard full of CPU graphs isn't observability
- How to instrument one important endpoint end to end with OpenTelemetry, so a metric, a trace, and a log all describe the same failed request
- What must never reach your telemetry: passwords, tokens, request bodies, user names
- How to run the pipeline behind a Collector instead of exporting from the app to each backend, with Prometheus for metrics, Loki for logs, Tempo for traces, and Grafana on top
- How to write one alert you would want to be woken up for, with a payload that includes the symptom, the dashboard link, the deployed version, and the runbook
- Why forty alerts you've learned to ignore are worse than one you trust
- How to collect a bounded evidence packet with allowlisted read-only queries before any model is involved
- How to run Codex or Claude Code headless as a read-only investigator that returns facts, ranked hypotheses, a proposed action, and its own uncertainty against a fixed schema
- Why authorization belongs outside the model, and what an action allowlist and autonomy levels look like in practice
- How to run the same incident twice and watch the policy force an escalation the second time, with no change to the agent
- How to layer a security audit: a deterministic scanner for evidence, a model for context and abuse paths, a person to decide
- How to inventory the responder's own capabilities in a permission table, because a prompt that says "read only" isn't a read-only token
- Where PR-Agent, Semgrep MCP, Snyk Agent Scan, K8sGPT, HolmesGPT, LiteLLM, and Ollama fit once the problems have names
By the end, you'll know how to tell whether your deployed app still works. You'll also know how to put an agent in the incident loop without giving it production access, and how to audit both the code it ships and the agent that responds.
Like the other workshops, this will be a live demo with practical tips and time for Q&A.
## All Events in This Series
- How to Work with AI Coding Agents: Spec-Driven Development, Context and Loop Engineering, Workflows
- Build and Ship an AI-Assisted Full-Stack App
- Test, Containerize, and Deploy an AI-Assisted App
- Open-Source AI Tools for Security, Audit, and DevOps
- AI Dev Tools Zoomcamp 2026 Pre-Course Live Q&A
- AI Dev Tools Zoomcamp 2026 Course Launch
## Thinking About Joining AI Dev Tools Zoomcamp?
This workshop covers the updated content for Module 4 of AI Dev Tools Zoomcamp, our free course on using AI tools in practical software development workflows.
The course covers AI-assisted planning, coding, review, testing, coding agent capabilities, MCP, skills, plugins, security, audit, DevOps, and a complete final project.
The new cohort of AI Dev Tools Zoomcamp starts on August 31, 2026. You can join it by registering here.
## About the Speaker
Alexey Grigorev is the Founder of DataTalks.Club and creator of the Zoomcamp series.
Alexey is a software and ML engineer with over 10 years in engineering and 6+ years in machine learning. He has deployed large-scale ML systems at companies like OLX Group and Simplaex, authored several technical books, including Machine Learning Bookcamp, and is a Kaggle Master with a 1st place finish in the NIPS'17 Criteo Challenge.
Join our Slack: https://datatalks.club/slack.html
73 attendees
Running Durable Agents in Production
·OnlineOnlineAgent demos often fail at the exact moment they become useful, due to a process crashes, interrupted deployments, or approvals that never trigger. This workshop shows how to turn working LLM agents into durable production workflows. You will learn how to persist state outside the agent process, resume agents after failure, retry tool calls, pause safely for approvals, inspect every step of execution, and deploy real multi-agent apps to real infrastructure.
We’ll cover the following steps:
● Understand why agent demos break in production - Explore the common failure modes of LLM agents, including lost state, brittle long-running tasks, unreliable tool calls, unclear recovery paths, and lack of operational visibility.
● Design agents as durable workflows - Learn how to structure agentic systems so each step is stateful, observable, retryable, and recoverable instead of being trapped inside a single fragile process.
● Build a production-oriented agent pattern - We’ll walk through an example agent that uses planning, tool execution, decision points, and external services while preserving execution history and state across failures.
● Add reliability controls for real-world execution - See how retries, timeouts, compensation logic, human approval, and event-driven continuation can make agents safer and more dependable.
● Handle human-in-the-loop requirements - Learn where human review, approval, escalation, or correction should be inserted into agent workflows without breaking the overall execution.
● Observe, debug, and improve agent behavior - Understand what needs to be visible when an agent runs in production, including execution paths, intermediate decisions, failed steps, tool responses, and recovery attempts.
● Leave with a reusable production blueprint - By the end, participants will have a practical mental model for building durable agents that can be adapted to RAG systems, workflow automation, customer operations, data tasks, and enterprise AI applications.
By the end of the workshop, attendees should be able to explain and implement the execution layer that separates a clever agent loop from a reliable agent service.
● Recognize the production failure modes of in-process agent loops: process death, deploys, flaky tools, slow approvals, missing history, and distributed state.
● Convert a basic tool-calling agent into a durable workflow with server-side state and per-step execution history.
● Add a human approval step that can wait safely and resume without losing context.
● Use execution traces to debug tool calls, LLM calls, timing, token usage, and failures.
● Understand where durable agent execution fits alongside RAG, evaluation, monitoring, and capstone project expectations.
About the Speaker:
Nicholas Lotz is a DevSecOps Engineer and technical enablement specialist dedicated to removing the organizational barriers that keep engineers from shipping great software. Currently a Technical Marketing Engineer at Voxel51 and a freelance DevSecOps consultant, Nick has built a career at the intersection of infrastructure automation and product education, including impactful roles at GitLab and Harness.He is the author of the second edition of Automating DevOps with GitLab Pipelines and is a recognized expert in Kubernetes, Terraform, and CI/CD modernization. With a unique academic interest in applying control theory to digital networks, he focuses on building transparent, secure software stacks that solve real-world business problems.
This post is sponsored by Orkes. Thank you for supporting our community!
Join our Slack: https://datatalks.club/slack.html
54 attendees
Past events
404


