Skip to content
Artwork for Automatic
TechnologyBusiness

Automatic

Automatic.co

Agentic AI and automation from the perspective of whoever has to maintain it in six months. Where an agent genuinely belongs in a process, where a plain script is enough, how to design a handoff to a human, and what breaks quietly at scale. Each episode takes one automation decision and reasons it through end to end — including the maintenance burden, the failure modes and the honest question of whether the process should exist at all. Written for operators and technical leads, deliberately free of hype. Five or six minutes an episode. Topics include where an agent belongs versus a plain script, designing human handoffs, error handling and observability, maintenance burden, process mapping before automation, measuring what a workflow saves, and knowing when a process should be deleted instead. Produced by Automatic.co, agentic AI and automation consulting. Full details, services and further reading at https://automatic.co
Play
  • 59 episodes
  • a few times a week
  • Avg 7 min
  • English
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • Yesterday · 5 min

    Schema-on-Read: Flexibility or Free-for-All?

    Schema-on-read promises faster data ingestion and exploratory freedom — but without serious governance, flexibility quietly becomes chaos. This episode breaks down when the pattern pays off and when it backfires.

  • Monday · 5 min

    Secrets Rotation: Because Hardcoding Is Career Suicide

    Hardcoded credentials don't just break security rules — they silently multiply across git histories, build artifacts, and Slack screenshots. This episode breaks down secrets rotation: why it matters, how to engineer it, and what "boring" security operatio

  • November 12 · 5 min

    Rollback Strategies: Pressing Undo At Scale

    When things go wrong in production, how fast can you get back? This episode breaks down rollback strategies as a core design discipline — not a last resort — covering blue-green deployments, canary releases, feature flags, and the habits that make recover

  • November 9 · 5 min

    Schema Evolution: The Silent Breaking Change

    Schema changes look harmless in a pull request but can silently corrupt data across entire automated pipelines. This episode breaks down why schema evolution is one of the stealthiest breaking changes in production systems — and how to stop it.

  • November 2 · 5 min

    Prompt Injection: When Your AI Gets Too Chatty

    Prompt injection is the AI security threat hiding in plain text — and it's already causing real harm. This episode breaks down how attackers exploit large language models through ordinary words, and what layered defenses actually look like in production.

  • October 29 · 5 min

    Microservices: Distributed Bliss or DevOps Dumpster Fire?

    Microservices promise speed and independence — but without the right DevOps discipline, they trade one set of problems for a far messier one. This episode breaks down when the architecture delivers and when it implodes.

  • October 26 · 5 min

    Multi-Agent Systems: Herding Cats with Protocols

    When dozens of autonomous agents need to work together, the real bottleneck isn't compute power — it's coordination. This episode unpacks the protocols, trade-offs, and design principles that separate a well-orchestrated multi-agent system from expensive

  • October 22 · 5 min

    Multi-Tenancy with AI Agents: How to Share Without Screwing Everyone

    Sharing infrastructure across AI agent clients sounds efficient — until one tenant's runaway process tanks everyone else's performance. This episode breaks down multi-tenancy architecture patterns, the landmines teams hit, and the guardrails that keep thi

  • October 19 · 5 min

    Overfitting: When Your Model Loves the Past Too Much

    A 99% training accuracy score can be the most misleading number in your ML project. This episode breaks down overfitting — what causes it, why it quietly destroys production performance, and the data, architecture, and training strategies that keep models

  • October 15 · 5 min

    Queue Backpressure: When Your System Says Stop

    Queue backpressure is one of the most misunderstood failure modes in distributed systems — and one of the most dangerous when ignored. This episode breaks down why it happens, how it cascades, and what engineers can actually do to stop it.

  • October 12 · 5 min

    Persistent Queues: When Memory Isn't Enough

    When a server restarts or traffic spikes, in-memory queues can silently drop messages at a rate that would alarm any engineering team. This episode breaks down how persistent queues change the failure calculus — and why that difference is worth building f

  • October 1 · 4 min

    Predictive Autoscaling: Smarter Infrastructure Before the Storm Hits

    Predictive autoscaling provisions infrastructure before demand spikes arrive — not after. This episode breaks down how teams can move from reactive firefighting to quiet, forecast-driven capacity management that cuts compute costs and on-call pages alike.

  • September 24 · 4 min

    Multi-Region Deploys: Resilience or Ruin?

    Multi-region deployments promise near-zero downtime and global resilience — but the operational cost can quietly spiral. This episode cuts through the hype to help teams decide when multi-region is the right call and when it isn't.

  • September 21 · 5 min

    Model Versioning: Because Final_Final_v2 Isn't Cutting It

    Stop naming models "final_FINAL_v2" and hoping for the best. This episode breaks down the real costs of skipping model versioning and shows how automation turns reproducibility from a headache into a strategic edge.

  • September 17 · 4 min

    Memory Leaks in Serverless: Still a Thing

    Serverless promised fewer headaches — but memory leaks didn't get the memo. This episode unpacks why leaks are sneakier than ever in serverless environments and what engineering teams can actually do to catch them.

  • September 15 · 4 min

    Machine Learning Models: Overhyped or Just Underfed?

    Most machine learning projects don't fail because the algorithm is wrong — they fail because the model is starved of good data. This episode breaks down the real culprits behind ML underperformance and what teams should fix first.

Showing 1–20 of 59 episodes