Datadog Scout 1.0: Cheaper AI SRE Investigations, Run More Often
Datadog Scout 1.0 is an SRE model Datadog says matches frontier models at 3 to 8 times lower cost. What it changes for on-call teams using Bits AI.
GitHub Star History API: From 2,500 Requests to 24
GitHub's star history API cuts react/react's full curve from about 2,511 requests to 24 with no stargazer identities. How filtering by time first made it cheap.
Kueue Pending Jobs: A Headlamp Checklist for Admission Failures
Kueue pending jobs often aren't a scheduler problem. A Headlamp-first checklist from the Kubernetes blog for tracing admission, quota and queues, and limits.
GitLab AI Credit Caps: Three Levers for Controlling Agent Spend
GitLab AI credit caps, open-weight models and Orbit target agent spend. What each lever controls, GitLab's benchmarks, and the order to use them.
Google SRE Book Second Edition: What Changed in 10 Years
Google's SRE book second edition is a full rewrite for AI and platform engineering. What changed in SLOs, observability and team models, and who should read it.
kagent Agent Builder: Three Guardrails a Prompt Can't Replace
A kagent agent builder on Kubernetes turns one sentence into a running AI agent. A CNCF lab shows why allowlists, approval and RBAC, not prompts, keep it safe.
Cloudflare Buys Deno: Self-Hosted Workers Finally Get a Team
Cloudflare's Deno acquisition ends Deno Deploy and puts Ryan Dahl on self-hosted Workers. What merging workerd and Celld means for lock-in and migration.
Datadog Retired Its Host Scanner: 4 Lessons From the Migration
Datadog swapped its SSH host scanner for the Datadog Agent after a six-month parallel run. Its vulnerability management lessons apply to any scanner swap.
GitHub ReviewBench: Copilot Wins Its Own AI Code Review Test
Copilot tops GitHub's ReviewBench but ranks fourth on an independent leaderboard. What that gap means when choosing an AI code reviewer for CI/CD.
Valkey-Proxy: Percona Targets the Last Redis Migration Blocker
Self-hosted Valkey lacked the proxy managed Redis provides. Percona's open source Valkey-proxy lets platform teams cluster without app rewrites.
AWS Digital Sovereignty Lens: A Well-Architected Framework for Regulated Cloud Workloads
AWS's Digital Sovereignty Lens adds 21 questions and 37 best practices for data residency, access control, continuity, and auditability on regulated workloads.
Datadog CI/CD Optimization: The Case for Treating Your Pipeline as a Production Service
Datadog's CI/CD Optimization combines pipeline telemetry, flaky test detection, and test impact analysis. Betterment cut builds from 40 minutes to under 10.
Datadog Observability Pipelines Now Routes Security Logs to Exabeam — Without Blinding Your SIEM
Datadog Exabeam Packs filter Cisco ASA, CrowdStrike, and Palo Alto logs before SIEM ingest — cutting costs while keeping threat-relevant signals intact.
One MCP Server Burned 18,000 Tokens Before Your Agent Did Anything. Here's the Fix.
One MCP server burned 9% of a 200K context window at initialization. Pi's Codemode pattern cuts that overhead to under 2% — and applies beyond Pi.
Databricks Monitoring: The 7 Dimensions Most Teams Only Partially Cover
A Datadog framework for Databricks monitoring across seven dimensions, from queue wait time as a warehouse-exhaustion signal to GPU memory on serving endpoints.
AWS Open-Sources Two Tools for Self-Hosted Regional Availability Intelligence
AWS open-sourced two self-hosted tools that track which services and features exist in which regions, tailored to the services you actually use.
CircleCI's Intent-Driven Development: A Six-Step Framework for Steering AI Agents from Idea to Ship
CircleCI's intent-driven development gives AI coding agents explicit constraints and success criteria via intent documents. A six-step framework.
Distributed DataFusion: Datadog Open-Sources a Framework for Running One Query Across Many Machines
Datadog open-sourced a framework that runs one Apache DataFusion query across many machines, reporting 10x speedups on long queries versus one node.
Kiro Compresses AS/400 Business Rule Extraction from 6 Weeks to 3 Days
AWS's Kiro agent extracts business rules from RPG and COBOL codebases, cutting AS/400 discovery from 4-6 weeks to about 3 days. How the three phases work.
Guardrails, Not Gates: A Better Framework for Platform Team Policy
CNCF argues platform policies fail as gates. Its framework of validation, mutation, generation, and verification makes developer experience the primary metric.
How Datadog Built an Async-Aware Python Profiler — and Why Traditional Profilers Fail Async Code
Python profilers can't follow asyncio tasks. How Datadog rebuilt task dependency trees and cut overhead over 60% in its async-aware profiler.
Why Coding Agents Need a Cloud-Native Harness — and What Mecatl Does About It
Desktop coding agent harnesses bundle UI, loop, sandbox, and tools in one process. How Stacklok's Mecatl splits them with cloud-native architecture.
AWS EventBridge's Enhanced Event Buses Add Ordering, Deduplication, and Org-Wide Sharing — What Changed
EventBridge enhanced event buses add org-wide sharing, ordering, deduplication, JSONata transforms, and throughput pricing. What changes for AWS teams.
Datadog Extends RUM to Shopify and Salesforce — Monitoring Revenue Flows You Don't Control
Datadog RUM now covers Shopify and Salesforce Experience Cloud, so teams can monitor checkout funnels and errors on frontends they can't instrument.
Datadog Tap to Parse: Click a Log Field, Get a Grok Parser — No Regex Required
Datadog Tap to Parse is GA: click a log field and get a generated parsing rule to review, no Grok syntax needed. Where it fits in the log lifecycle.
Terraform Google Cloud Provider 8.0 Is GA — Three Breaking Changes That Will Affect Your Infrastructure
Terraform's Google Cloud provider 8.0 changes the default load balancer scheme and removes deprecated resources: three breaking changes to plan for.
CircleCI Can Now Run Your GitHub Actions Workflows Without Rewriting Them
CircleCI can now run existing GitHub Actions YAML on its own infrastructure with no rewrite, citing 40% faster builds. Linux-only, in open preview.
Equinix Cut Kubernetes Operational Overhead by 40% With a Shared Services Architecture on EKS
Equinix replaced self-managed, team-owned Kubernetes clusters with a three-account shared services architecture on Amazon EKS: a workloads account (EKS + Cilium), a platform account (centralized CI/CD, managed data services), and a network account (Transit Gateway, Direct Connect). Results: 40% less operational overhead, 4× deployment frequency, 100% business unit adoption.
Kubernetes v1.37 Native Histograms Graduate to Beta — and They're Now On by Default
Kubernetes v1.37 enables Native Histograms by default, graduating from alpha in v1.36. The change replaces classic Prometheus histograms' static buckets with adaptive, lower-cardinality metrics that provide more accurate latency percentiles without manual configuration.
NetFlow Traffic Counts Are Lying to You. Here's How to Fix Them.
Most NetFlow configurations double-count traffic by design — two independent mechanisms create duplicate records, and they often run simultaneously. Datadog's guide covers both root causes and the two complementary fixes that eliminate the noise without losing visibility.
Kubernetes v1.37 Adds Five Standardized Node Conditions for Drain and Maintenance Workflows
Kubernetes v1.37 introduces five new well-known Node conditions — DrainInProgress, Drained, MaintenancePlanned, MaintenanceInProgress, and GracefulNodeShutdownInProgress — replacing the scattered taint/label signals that platform teams currently use to communicate node state during operational events.
Kubernetes v1.37 Gang Scheduling Hits Beta — and Brings a New API for AI/ML Workloads
Kubernetes v1.37 graduates gang scheduling to beta with a new CompositePodGroup API, Workload-Aware Preemption, and standardized building blocks for third-party controller integration. The AI/ML workload angle is the reason this cycle matters.
AWS Weekly: Claude Fable 5.1 on Bedrock, Lambda SnapStart for Containers
This week's AWS releases include Fable 5.1 as a Covered Model on Bedrock, Lambda SnapStart for containers, the Agent Registry for governance, and Graviton5 memory instances.
Kubernetes v1.37: Dynamic Resource Allocation Graduates to GA — What Changes for GPU Workloads
Kubernetes v1.37 promotes DRA Extended Resource Support to GA, enabling existing GPU workloads to migrate to Dynamic Resource Allocation without code changes. Device taints and NUMA standardization also reach GA.
Kubernetes v1.37: HPA Scale-to-Zero Is Now Beta and On by Default
The HorizontalPodAutoscaler can now scale workloads to zero replicas in Kubernetes v1.37 — what changed from alpha, how to configure it, and when not to use it.
The Datadog Loop: Five Stages for Turning Agent Traces Into Verified Improvements
Datadog's five-stage optimization loop — Observe, Hypothesize, Evaluate, Experiment, Ship — gives platform teams a repeatable method for improving AI agents without blind prompt guessing.
JFrog at swampUP 2026: Agents Are Now Supply Chain Actors, Not Just Tools
JFrog unveiled APM repositories, prompt-to-release traceability, and zero-touch remediation at swampUP 2026 — extending supply chain governance to autonomous AI agents.
Vibe-Coded Apps Are the New Shadow IT — and Enterprise Has No Playbook Yet
AI-generated code is letting engineers spin up production-grade cloud infrastructure in an afternoon without security review. Platform teams are watching and mostly unprepared.
How to Orchestrate On-Premises Infrastructure at Scale with EKS Anywhere and AWS Serverless
AWS Architecture Blog's three-layer reference architecture for hybrid cloud orchestration: EKS Anywhere clusters at the edge, Step Functions and EventBridge at center, and a DynamoDB-backed Order Management System tying them together.
From Traces to Experiments: The 5-Stage Loop for Improving AI Agents in Production
Datadog's framework for turning AI agent traces into actionable improvements — from pattern identification to production A/B testing — addresses the gap that offline evaluation alone can't close.
MCP Went Stateless: The AWS Well-Architected Audit Your MCP Server Needs Now
MCP's July 28 protocol update eliminated session state — and with it, the sticky load balancers, DynamoDB session stores, and Lambda workarounds most AWS MCP deployments were built around.
AWS Acquires DuckLabs and Launches Agentic Resource Discovery: What It Means for Cloud Engineers
AWS's DuckLabs acquisition brings DuckDB into the enterprise stack, while the new Agentic Resource Discovery spec solves the scattered-registry problem for agentic workloads. Both moves matter for platform teams.
AWS EC2 R9g and R9gd Are Now GA: Graviton5's Case for Memory-Optimized Workloads
The R9g and R9gd instance families bring Graviton5's 25% compute performance boost and DDR5 at 8800 MT/s to databases, in-memory caches, and real-time analytics. Here's who should care.
Datadog's Bitbucket Cloud Integration: Source Code Context in Every Trace
Datadog's new Bitbucket Cloud source code integration connects running services to their commit history, surfaces code snippets inline during troubleshooting, and posts automated PR feedback. Here's what changes for teams using Bitbucket.
How Datadog Bits Proves a Query Rewrite Is Actually Faster — Not Just Theoretically
Datadog's Bits Database Optimization generates synthetic production environments to validate query rewrites against three metrics before recommending them. Here's the methodology that makes it trustworthy.
Your AI Agent Is Only as Good as the Harness Around It
AI agents that look compelling in demos routinely fail in production. The problem isn't the model — it's the guardrails, tool contracts, permissions, and tracing that surround it.
Kubernetes v1.37: Pod Certificates and Cluster Trust Bundles Are Now GA
Kubernetes v1.37 graduates Pod Certificates and Cluster Trust Bundles to stable. They replace bearer token JWTs with proof-of-possession mTLS credentials — closing a workload identity gap that has existed since the beginning.
The Definitive Guide to Building an AI Factory on Kubernetes for Platform Teams
One GPU fleet, many teams, strict isolation: how to architect multi-tenant AI infrastructure on Kubernetes without hiding the data path behind a leaky abstraction.
How to Implement Predictive Autoscaling for GPU Workloads on Kubernetes
Reactive autoscaling can't keep up with GPU provisioning delays. This framework uses a Bi-LSTM predictor, burst detection, and a graduated scaler to close the gap.
Kubernetes v1.37 Pod Certificates: Why Bearer Tokens Were Never Enough
Pod Certificates and Cluster Trust Bundles hit GA in Kubernetes v1.37, replacing bearer token identity with proof-of-possession X.509 credentials.
Datadog Live Debugger: Fix Production Bugs Without Writing a Single Deploy
Datadog's Live Debugger attaches logpoints to running services and collects variable snapshots without code changes or restarts — with Bits AI converting a plain-language bug description into a production-backed code fix.
Kiro, AWS DevOps Agent, and Dynatrace: How Production Telemetry Gets Baked Into Code Generation
AWS's three-tool stack connects live Dynatrace production telemetry directly to Kiro's code generation — so AI-written changes reflect how systems actually behave, not how docs say they should.
How Datadog Saves $1 Million a Month on AI: The Optimization Playbook
Datadog cut over $1M/month in AI costs by migrating models, adjusting effort levels, and deploying context optimization. The specific numbers and methods behind each lever.
Golden Paths for AI Agents: What Platform Engineering Gets Wrong When the User Isn't Human
Datadog's framework for redesigning golden paths when AI agents replace human developers as platform users — deterministic enforcement, machine-readable contracts, and audit co-authorship.
Kiro + AWS DevOps Agent + Bluebox: The AI Software Delivery Loop AWS Is Betting On
AWS describes how Kiro, its DevOps Agent, and Dynatrace's Bluebox create a closed feedback loop from spec to production incident response. Human review gates required throughout.
Amazon EC2 at 20: From One Instance Type to 1,200 and What Comes Next
Amazon EC2 launched in 2006 with one instance type. At 20, it offers 1,200+ types and anchors an AI compute infrastructure its founders never anticipated.
Golden Paths for AI Agents: Redesigning Platform Workflows for Non-Human Users
Agents are now platform users. Datadog maps three required changes: execution patterns, deterministic controls, and dispatch authorization before agent runs.
JFrog Fly Graduates: What an Agentic Repository Actually Means for Enterprise CI/CD
JFrog Fly's agentic repository capabilities are now part of the main JFrog Platform. The experiment is over. The question now is what enterprise teams do with it.
Why Developers Should Own Their Own Observability (And How to Start)
CNCF's case for shift-left observability: instrument your code while writing it, use zero-code OpenTelemetry for baselines, and add manual spans where it matters most.
The 5-Step Framework for Automated Root Cause Analysis at Cloud-Native Scale
Atlassian's published approach to multi-signal correlation shows how to correlate metrics, traces, and logs to generate ranked RCA hypotheses automatically — narrowing a 200-service search to tens of services within minutes of an incident.
AWS Glue 6.0: Apache Iceberg v3 and a 30% Price Cut — What Changes for Data Teams
AWS Glue 6.0 lands on Spark 4.1, Python 3.13, and Iceberg v3 with spatial types and VARIANT shredding — plus a 30% hourly rate reduction that applies immediately with no API changes.
CloudFormation Drift Detection: The AWS Blueprint for Governing ClickOps Environments
AWS DevOps published a four-stage maturity framework for converting manually modified infrastructure into governed IaC — with EventBridge-driven drift detection at its core.
Kubernetes at the Edge Has Hit a Wall: Why Fleet Management Is the Answer
Edge Kubernetes deployments face a ceiling that more cluster optimization can't clear — disconnected operation, configuration drift, and scale management require a fleet-first architecture that most organizations haven't adopted yet.
MCP vs API: CircleCI's Practical Guide to When Each Makes Sense
CircleCI's engineering blog clarifies the actual distinction between APIs and MCP — and why the answer for most agentic systems is 'both, for different purposes.'
AWS Retired This EKS Auth Method — and 81% of Clusters Haven't Noticed
AWS deprecated ConfigMap-based EKS cluster authentication, but 81% of clusters still run the legacy method. Here's what the migration window looks like and what's at stake.
How Datadog Scaled Git Serving 20x Without Slowing CI Down
Datadog's GitRetriever sustains 20× CI traffic growth at 40ms median latency — a two-tier mirror/relay architecture for monorepo CI that any platform team can adapt.
How to Trace AWS Lambda Durable Functions with Datadog
Datadog's Node.js and Python tracers now instrument AWS Lambda Durable Functions automatically — connecting multi-invocation workflows into a single unified flame graph without code changes.
Consistency Is the New Latency: What AWS Aurora, DynamoDB, and Keyspaces Teach Us About AI Agent Data
For AI agents, a fast wrong answer costs more than a slow right one. AWS's architecture blog explains why the data layer's consistency model now determines agent trustworthiness — and how Aurora, DynamoDB, and Keyspaces each handle it.
Datadog Work Management: One Queue for Humans and AI Agents
Datadog's renamed Work Management platform centralizes human and AI agent task tracking with full observability context attached. Here's what it solves that Jira and Slack threads don't.
Consistency Is the New Latency: Matching AWS Data Services to AI Agent Workloads
Replication lag silently corrupts AI agent context — an agent that reads stale data makes wrong decisions that can write back to the database, creating cycles of compounding error. AWS architects now have three distinct patterns to match service choice to agent task type.
CNCF Publishes Governance Framework Guidance: Three Models, One Critical Mechanism
CNCF's analysis of 72 projects reveals that organizational-balanced voting — not contributor volume — is the strongest predictor of sustained contributor diversity. The guidance recommends three governance structures based on project size and complexity.
Scale Your Platform Without Becoming the Bottleneck: The JFrog Projects Framework
Growing engineering orgs hit a wall when centralized platform admins become the constraint. JFrog Projects introduces delegated administration, project-scoped RBAC, and isolation by default — with a model that scales to 120,000+ repos.
Eleven Minutes, Zero Humans: How This Kubernetes Upgrade Pipeline Works
A production Kubernetes control plane upgraded across three nodes in 11 minutes without manual intervention. Here's the six-tool pipeline behind it, the critical concurrency mistake to avoid, and what self-healing actually requires.
JFrog Artifactory and GCP Artifact Registry: Native Pull, No Sync Required
JFrog's Artifact Registry Connector routes Cloud Run and GKE pulls directly to Artifactory in real time — eliminating sync lag, parallel registries, and policy enforcement gaps.
AGENTS.md vs. Skills: How to Actually Steer a Coding Agent
CircleCI's breakdown of when to use AGENTS.md versus modular skills for coding agents — and why the real problem isn't the format, it's measuring whether steering works at all.
Databricks Acquires Electric: Every AI Agent Gets Its Own Postgres Database
Databricks bought Electric, the startup behind WASM-based PGlite, to give AI agents isolated Postgres instances in their sandboxes — synchronizing back to Lakebase.
Pulling Multi-Gigabyte Container Images in Seconds on Amazon EKS
SOCI lazy loading cuts a 1.3 GB container image pull from 20 seconds to 2.8 seconds on EKS — with no image format changes required. Here's the mechanism and how to enable it.
How to Pull Multi-Gigabyte Container Images in Seconds on Amazon EKS
SOCI (Seekable OCI) lazy loading lets EKS pods start before the full image is pulled — cutting a 10 GB image from minutes to seconds. Here's how the technique works and how to deploy it.
When Zero Plus Zero Equals Two: Fixing Trace Fragmentation in Istio and Kiali
Combining Istio sidecar tracing with OpenTelemetry instrumentation produces duplicate, disconnected trace records — not unified observability. The fix is two configuration changes, and it closes the gap permanently.
How to Bring Organizational Knowledge Into Kiro Using Amazon Bedrock and MCP
AWS shows how to connect Kiro to Amazon Bedrock Knowledge Bases via MCP so developers get instant, cited answers about ADRs, API specs, and coding standards without leaving their editor.
Platform Engineering ROI: The Real Cost of Building Your Own Internal Platform
A DIY internal developer platform runs $7.5M/year at enterprise scale. The ROI is real but requires 50+ engineers to capture. Here's how to read the math before committing.
AWS DevOps Agent + SageMaker HyperPod: Automated Incident Triage at ML Scale
HyperPod self-heals hardware faults automatically, but configuration issues and stuck pods still require 30-45 minutes of manual triage. AWS's DevOps Agent cuts that to minutes.
The npm Attack That Turned Provenance Attestations Into Camouflage
The August 2026 npm worm compromised packages with 150M+ weekly downloads by publishing from legitimate GitHub Actions runners — making valid provenance attestations a false safety signal.
Shadow AI in CI/CD: The Six-Stage Threat Model from Laptop to Kubernetes
CNCF maps six attack surfaces where unapproved AI agents gain privileged access in the software pipeline — every enterprise has at least one gap, and CI credentials are the target.
AWS Kiro's Agent Client Protocol: The LSP Moment for AI Coding Agents
AWS rebuilt Kiro around the Agent Client Protocol, separating coding agents from editors. Here's why this LSP-like shift matters for platform teams.
Anthropic Says: One Worktree Per Agent. Your Infrastructure Says: Not So Fast.
Anthropic recommends one git worktree per agent. That solves the file layer — but platform teams running multi-agent workflows still face runtime collisions.
AWS IaC MCP Server: What CloudFormation Development Looks Like with Unified AI Tooling
AWS's IaC MCP Server consolidates CloudFormation documentation search, syntax validation, compliance checking, and runtime troubleshooting into one conversational interface. Here's what that workflow change actually delivers.
swampUP 2026: JFrog's Conference Puts AI Supply Chain Trust at the Center
swampUP 2026 in New York (September 1–3) focuses on immunizing, healing, and governing the agentic software supply chain. Anthropic's Deputy CISO, NVIDIA, AWS, and Wiz are on the agenda. Here's what to expect.
Gateway API v1.6: TCP and UDP Routing Are Finally Production-Ready
Kubernetes Gateway API v1.6 graduates TCPRoute and UDPRoute from experimental to Standard, letting platform teams route databases, DNS, and gaming traffic without vendor lock-in.
Kubernetes v1.37: The Deprecations Platform Teams Need Now
cgroup v1 nodes now fail kubelet initialization by default, kube-proxy IPVS mode is deprecated, and Static Pods lose Secret/ConfigMap references in v1.37.
Why the controller-runtime Cache Keeps Kubernetes Stable
Every Kubernetes controller reads through a local cache, not the API server directly — the list-watch mechanism that makes that possible, and where it breaks.
The Practical Guide to AI Sandboxes for Developers
AI coding agents have deleted home directories and a production database. What an AI sandbox is, how isolation levels differ, and where it fits.
The Practical Guide to EC2 Image Builder and AWS CDK for Studio-Scale AMI Management
Company 3's post-production teams eliminated custom-resource workarounds for AMI versioning by adopting EC2 Image Builder auto-versioning and CDK L2 constructs.
Remote MCP Servers: Why 'Just Run It Locally' Stopped Working
Remote MCP servers move tool access from a developer's laptop to hosted infrastructure — here's the architecture shift and why CircleCI built one for CI/CD.
Terraform's New Undo Button Fixes Its Scariest Failure Mode
HCP Terraform's new Stacks restore feature undoes accidental workspace deletion with one click — part of a broader release addressing monorepo sprawl and migration friction.
Autonomous Infrastructure for Agentic Workflows
HashiCorp's seven-layer model for governing infrastructure as AI agents make changes at machine speed, from code to policy-bound self-service.
Datadog JFR: Why CPU-Time Profiling Beats Wall-Clock in JDK 25
JDK 25 adds unbiased CPU-time profiling to Java Flight Recorder, fixing wall-clock sampling bias that misleads Java performance work.
Kubernetes Didn't Fix Databases. It Just Hid the Problem
Kubernetes makes deploying Postgres trivial, but a failed failover can corrupt data in minutes. See why platform teams, not app teams, must own database ops.
Platform Engineering's Next Job: Managing AI Agents Like Any Other Workload
CNCF's case for the agentic enterprise: platforms must treat AI agents as first-class citizens alongside applications and resources, with shared context as the new primitive.
Datadog: What a Sixth Gartner Lead Means for AI-Driven Ops Teams
For the sixth straight year, Datadog tops Gartner's Observability MQ. Here's what the recognition reveals about observability in an AI-native world.
Atlassian's Jira Gets a Coding Agent: What the Teamwork Graph Actually Changes
Jira Coding Agent is now live on all paid plans. Atlassian's Teamwork Graph provides project context to connected AI coding tools — here's what that means for platform teams managing AI-assisted development at scale.
How 121 Million gRPC Connections Exposed a Fatal DNS Assumption
Bitdrift's T20 World Cup incident: a single DNS routing policy caused 80% errors when 121M devices connected at once. The fix required zero code changes.
AWS DevOps Agent + Kiro CLI: The Incident Remediation Loop That Fixes Itself
AWS has published a production blueprint where DevOps Agent investigates incidents and Kiro CLI applies the fix — reducing MTTR by 75% with a single human touchpoint: PR approval.
AI Agents Now Have a Package Manager — and JFrog Is the Enterprise Registry
APM (Agent Package Manager) treats agent primitives like versioned software packages. JFrog's Artifactory adds native support, bringing supply-chain governance to AI agent configuration.
Amazon SQS at 20: How a Simple Queue Became the Backbone of Cloud Infrastructure
Launched July 13, 2006 alongside EC2 and S3, Amazon SQS turns 20 with 70,000 TPS throughput and 1 MiB payloads. What two decades of iteration reveals about distributed systems design.
Is a Kubernetes Pod the Right Deployment Unit for an AI Agent?
CNCF's kagent team asks whether Pods — ideal for long-lived microservices — are the right abstraction for AI agents that wake briefly, execute, and go idle. Their answer: probably not.
MAPFRE's Fraud Detection Jumped 135% Accuracy — Using EMR Serverless and Graph Analytics
How MAPFRE USA replaced rules-based insurance fraud detection with a graph-enriched ML pipeline on AWS, producing $6.8M in 2025 savings and 50–135% accuracy improvements.
March Networks Moved 5,600 TB of Video to AWS — and Cut Storage Costs by 79%
How enterprise video surveillance found its cloud-native architecture: March Networks' S3 and Glacier stack delivers $1.35M in annual savings for a single retail deployment.
Specification-Driven Data Workflows on AWS: Why Regulated Industries Are Adopting This Pattern
AWS architects outline a three-layer pattern — intent, composition, processing — that separates what a data workflow should do from how it executes. Clinical trials report onboarding datasets in days, not weeks.
The Velocity Gap Is Getting Worse: What CircleCI's Q2 2026 Data Shows
Elite engineering teams now run 9x more main-branch workflows than median teams — up from 8x in Q1. CircleCI's Q2 Pulse report introduces a new metric, MER, that explains why the gap compounds.
CircleCI Rewrote Its CLI in Go Because Coding Agents Needed Predictability
CircleCI's CLI rewrite isn't a developer ergonomics play—it's infrastructure for agentic CI/CD. Consistent JSON, stable exit codes, and a first-class MCP server are now the requirements.
JFrog Boost: The Free CLI That Cuts AI Coding Token Bills Before You Hit the Limit
JFrog Boost enters public preview with 80% payload reduction in CI scenarios—addressing the token-cost problem quietly becoming every platform team's biggest AI line item.
How S&P Global Hit 15-Minute RTO on Capital IQ Using Amazon FSx and NetApp ONTAP
S&P Global's Capital IQ platform now achieves sub-15-minute read-only failover using Amazon FSx SnapMirror and FlexClone pre-provisioning. The design turns disaster recovery into a traffic redirect.
CircleCI Q2 2026: The 9x Velocity Gap Between Elite Teams and Everyone Else
CircleCI analyzed 20 million workflows and found the gap between top 5% engineering teams and median teams widened to 9x in Q2 2026. The differentiator isn't AI — it's what happens to code before it reaches the AI pipeline.
Sandboxing Your AI Agents Is Necessary. It's Not Enough.
CNCF's July 2026 analysis of production agent fleets identifies the gap that sandboxing alone leaves open: resource efficiency at scale. Isolation solves security. Serverless-style runtimes solve the fleet management problem. You need both.
AWS Brings Claude Sonnet 5 to Bedrock and Launches WorkSpaces for AI Agents
AWS's July 6 roundup covers two additions for production AI builders: Claude Sonnet 5 on Amazon Bedrock and WorkSpaces for AI Agents reaching general availability for desktop-app automation.
Platform Engineering 2.0: Five Pillars for AI-Native Workloads
Platform Engineering 1.0 solved developer delivery. Platform Engineering 2.0 must solve GPU allocation, model serving, agentic governance, and FinOps for AI consumption. Here's the framework.
The 4-Body Problem of SRE: Why Autonomous Operations Require Unified Context
Autonomous SRE operations don't fail because models aren't good enough. They fail because the four bodies of operational knowledge — code, infrastructure, signals, and tribal wisdom — stay fragmented.
Data Sovereignty Is No Longer a Geography Problem — It's an Architecture Problem
The EU's Cloud and AI Development Act reframes data sovereignty as jurisdictional control, not physical location. Here's how platform engineers are enforcing it through Kubernetes admission controllers, OpenStack, and policy-as-code.
kpt Joins CNCF: The Kubernetes Config Toolchain That Shows You What You're Deploying Before You Deploy It
kpt's CNCF sandbox debut reintroduces a Kubernetes configuration toolchain built around WYSIWYG deployment — you inspect the final manifest before it hits the cluster, not a template that generates it.
AWS EKS Kubernetes Version Rollbacks: Upgrading Is No Longer a One-Way Door
Amazon EKS now lets teams reverse a Kubernetes version upgrade within 7 days. Here's how rollback works, what the limits are, and what it changes for platform engineers.
Terraform and Azure in the AI Era: Governing Infrastructure That Won't Hold Still
AI experimentation is creating unmanaged Azure resources faster than ops teams can track them. Terraform Query and Sentinel policy-as-code are how teams are bringing order back.
Why Traditional CI/CD Fails for LLMs—and the Release Gates That Fix It
CI/CD was built for deterministic code. LLMs aren't deterministic. Here's the core mismatch and the threshold-based release gates teams are building to address it.
AWS Certificate Manager Adds ACME Support for Automated TLS
AWS Certificate Manager now runs a fully managed ACME server endpoint — automating TLS certificate issuance and renewal via Certbot, cert-manager, or any ACMEv2 client.
AWS CloudFormation Express Mode: 4x Faster, Zero Extra Cost
AWS CloudFormation's new Express mode cuts deployment times by up to 4x by skipping stabilization wait times — enabling sub-minute feedback loops for AI-assisted infrastructure at no added charge.
Datadog Acquires Adaptive ML: Production-Trained AI Agents for Observability
Datadog acquired Adaptive ML to embed specialized model training into its observability platform — shifting AI agents from generic APIs to systems trained on real production signals.
Lessons from Running 1 Million Lambda Functions: What Scale-to-Zero Actually Costs
Building true-serverless multi-tenant SaaS at one million Lambda functions exposes problems documentation doesn't mention — synchronized scheduling, observability cost explosions, and the SQS idle trap.
Three Layers to Stop ML Data Exfiltration in AWS SageMaker Environments
iBusiness built a three-layered security architecture using SageMaker AI, WorkSpaces Secure Browser, and VPC isolation — cutting per-user cost 80% while closing every major data movement path.
Okta Brings AI Agent Governance Inside FedRAMP Boundaries First
Okta is now the first identity platform to extend AI agent lifecycle management into FedRAMP and HIPAA environments — meaning federal agencies can finally deploy agents against regulated data.
Workday's Argument: AI Guardrails Must Live at the Inference Layer
Workday CTO Gabe Monroy argues that for HR and payroll data, agent gateways and external wrappers sit at the wrong layer — guardrails have to be wired into inference itself.
Coding Agents All Agree: Run the Code. The Debate Is What It Runs Against.
Runtime verification is now the baseline for AI coding agents. Greptile, Cursor, and Devin agree on execution — they disagree on what it runs against, and that choice matters at scale.
Datadog's CDN Log Fix: Archive Search Lets You Query 751 GB of Logs Without Paying to Index Them
High-volume CDN access logs are too expensive to keep in Datadog's indexing tier but too valuable to throw away. Archive Search solves the gap — query petabytes in cold storage with the same syntax as Log Explorer.
Codeplain's Argument: Code Should Be Regenerated, Not Maintained
Dušan Omerčević's Codeplain treats code as disposable output and specs as the durable artifact. In the age of AI-assisted development, the case for regenerative development is harder to dismiss than it sounds.
How to Cut AI Costs by 80%: What Port.io's 12,000-Query Study Found
Port.io ran 12,000 queries across three models and found that structured context management — a 'Context Lake' approach — cut costs by 80% compared to unstructured MCP-only setups. The tradeoffs are not what most teams expect.
Mutation Testing: What Platform Teams Are Missing With Code Coverage Alone
Code coverage tells you which lines ran. Mutation testing tells you whether your tests would actually catch a defect. For platform teams shipping infrastructure-affecting code, the difference is the gap between 'tests passed' and 'tests work'.
Your AI Pipeline Is Broken and Your Dashboards Don't Know It
Traditional monitoring shows binary pass/fail. LLM pipelines fail probabilistically — silently returning plausible but wrong outputs while every health metric shows green. Here's what to instrument instead.
AWS Agent Toolkit: Why Your Agent Is Ignoring 20+ Skills Without This One File
AWS launched an Agent Toolkit with 20+ packaged skills for coding agents, but most developers miss the rules file that tells agents to use them — causing silent fallback to training data instead of authoritative AWS guidance.
AWS DevOps Agent Adds Release Management: Pre-Production Assessment Before Code Merges
AWS DevOps Agent's new release management capabilities add release readiness review and autonomous release testing — two preview features that assess code changes in isolated environments before they reach production.
AWS Security Agent Adds STRIDE Threat Modeling, Kiro Power, and Claude Code Plugin
AWS Security Agent now generates STRIDE-based threat models from design docs or source code, surfaces findings in Kiro and Claude Code IDEs, and adds full-repo code scanning with remediation — moving security earlier in the development workflow.
Checkmarx's New SAST Engine Isn't About the LLM. It's About What Comes After.
Checkmarx unveiled a hybrid SAST engine with three components — a deterministic scanner, an LLM trained on security data, and a Finding Analysis Engine that filters false positives before results reach developers. The differentiator is the last one.
HCP Vault Dedicated Gets Cluster Disaster Recovery — and a DR Testing Path
HashiCorp's HCP Vault Dedicated now supports cluster-level disaster recovery in public preview, enabling failover for cluster-specific incidents and — critically — scheduled DR testing without waiting for a regional outage.
JFrog Artifactory Adds Xet Protocol Support: How Enterprise Model Distribution Finally Scales
JFrog Artifactory's native Xet protocol support brings chunk-level deduplication to Hugging Face model distribution — delivering up to 3.7x faster subsequent pulls and controlled storage growth for enterprises managing fine-tuned model variants.
Building a Cluster-Aware AI Agent with Kubernetes, Argo CD, and GitOps
A CNCF reference architecture shows how to run an AI agent inside a Kubernetes cluster that observes live state, diagnoses pods via RAG, and delivers updates through a full GitOps pipeline — without write access to the cluster.
Amazon Bedrock Managed Knowledge Base Turns Enterprise RAG Into a Managed Primitive
Bedrock Managed Knowledge Base abstracts the full RAG stack — six native connectors, auto-selected embeddings and reranker, Agentic Retriever for multi-hop queries, and MCP exposure via AgentCore Gateway — so teams build retrieval applications without managing the pipeline.
Amazon Launches Web Search API for AI Agents Inside AWS: $7/1K Queries, Zero Data Egress
AgentCore Web Search gives AI agents access to current web knowledge via Amazon's search infrastructure — $7 per 1,000 queries, queries never leave AWS, returns snippets and publication dates, MCP connector via AgentCore Gateway. GA in US East as of June 17, 2026.
How Datadog Used AI to Turn a 45-Minute Query Into a 1-Second One
Datadog migrated its Stream Router — the control plane handling 100+ trillion events daily — from FoundationDB to PostgreSQL using AI-assisted refactoring. The approach cut 45-minute operations to 1 second and reduced database costs by 90%.
JFrog Brings Artifact Governance to Coding Agent Plugins
JFrog Agent Plugins Repositories treats coding agent plugins as governed software artifacts in Artifactory — closing the supply chain gap where Claude Code, Cursor, and Codex plugins arrive from uncontrolled GitHub repos and Slack channels.
50% of Your Metrics Are Never Queried: The Case for Sustainable Observability
CNCF's telemetry panel found that half of collected metrics are never acted on. Here's the framework for designing observability pipelines that produce signal, not storage overhead.
AWS DevOps Agent + LaunchDarkly: Feature Flags as Incident Response
AWS DevOps Agent now connects to LaunchDarkly's MCP server, enabling agentic feature flag orchestration at deployment and during incidents — flag-based containment in minutes, not rollbacks.
AWS Kiro IDE Now Integrates DevOps Agent: Incident Response Without Leaving Your Editor
The AWS DevOps Agent integration in Kiro brings CloudWatch metrics, X-Ray traces, deployment history, and cost optimization directly into the IDE — collapsing the context switch between writing code and investigating production issues.
AWS Summit New York 2026: What Actually Matters for Platform Engineers
AWS Summit New York 2026 delivered 15+ announcements. Here's what platform engineers should pay attention to: autonomous agents going GA, ECS 4.2x faster scaling, and the agentic CI/CD stack taking shape.
JFrog Named a Leader in the First-Ever Gartner MQ for Software Supply Chain
JFrog placed highest for Ability to Execute in the inaugural Gartner Magic Quadrant for Software Supply Chain Platforms — the first analyst framework to evaluate this market as a unified category.
MCP's Missing Enterprise Authorization Layer Is Now Filled
The Enterprise-Managed Authorization extension for the Model Context Protocol eliminates per-server OAuth consent prompts, letting IT admins provision MCP server access centrally through existing identity providers.
AWS Summit New York 2026: Where Agentic AI Becomes Infrastructure
AWS's June 2026 Summit delivered seven announcements with one shared thesis: agentic AI is no longer a feature layer — it's a new runtime for how production systems operate.
How AWS Transform Turns Tech Debt Into a Daily Ops Problem
AWS Transform now scans continuously and auto-generates remediation PRs. That reframes tech debt from migration event to ongoing infrastructure concern.
HashiCorp Closes the Terraform-Ansible Gap With pyTFE and Collection 2.0
pyTFE 1.0 and Terraform Ansible Collection 2.0 make it practical to run Terraform workflows from Ansible without glue code — bridging Day 0 provisioning and Day 2 operations natively.
AWS S3 Annotations: 1 GB of Queryable Context Per Object for AI Agents
Amazon S3 now lets you attach up to 1 GB of rich, mutable, queryable context directly to your objects — no separate metadata system required. Here's what it means for agentic workflows.
HashiCorp Launches tfctl: A Dedicated CLI for HCP Terraform and Terraform Enterprise
HashiCorp's new tfctl gives platform engineers full API coverage of HCP Terraform and TFE from the command line — with dry-run mode, schema discovery, and built-in guardrails for destructive operations.
Samsung Cut Pricing Latency 90x With Lambda Response Streaming
Samsung.com had a 1-hour pricing lag that showed wrong prices during flash sales. Their Lambda Response Streaming architecture achieved P90 latency of 50ms and a 95% cache hit ratio — here's the pattern any high-traffic API team can replicate.
88% of Enterprises Had AI Agent Security Incidents — Because They Can't See Inside Their Agents
New data shows 88% of enterprises experienced AI agent security incidents in the past year, with only 21% having runtime visibility into agent behavior. The missing layer isn't logging — it's decision traceability.
Stack Traces Can't Debug AI Systems — Because AI Failures Don't Have a Line Number
Traditional debugging assumes deterministic code with reproducible failure states. AI systems violate both assumptions. The debugging paradigm that replaces stack traces requires a different mental model and a different observability stack.
Datadog MCP Apps Bring Rendered Dashboards Into Claude, Cursor, and ChatGPT
Datadog's MCP Apps extend the Model Context Protocol with rendered UI components — interactive monitor cards, timeseries graphs, and APM trace views — surfaced directly inside AI coding and chat interfaces.
JetBrains Is Building Course Infrastructure for IDEs — Because 76% Awareness Produces 18% Daily Use
JetBrains' Course Creators Program embeds exercises directly in developer IDEs via Udemy, Coursera, and LinkedIn Learning integrations. The gap it's trying to close: GitHub Copilot has 76% developer awareness and only 18% daily usage.
Why Vector Search Alone Isn't Enough for Production AI Retrieval — And What Tensors Add
Cosine similarity finds semantically similar content. It does not rank by authority, recency, or structural relevance. The gap between what vector search can do and what production RAG systems actually need is driving a shift toward multi-dimensional retrieval architectures.
Claude Fable Cost $9 in One Coding Test. GPT-5.5 Cost $1.50. Model Triage Is Now a Platform Engineering Skill.
When the same coding task costs 6x more on one frontier model than another, model selection stops being a preference and becomes infrastructure. How platform engineers are building routing policies before AI spend compounds into a budget crisis.
Why Verifying AI Agents Is a Runtime Problem, Not a Build-Time One
Static testing and pre-deployment checks were built for synchronous, deterministic software. Async AI agents in cloud-native environments require a fundamentally different verification model — one that operates at runtime.
Apache Cassandra 6.0 and Accord: What Changes When Your Distributed Database Handles Transactions Itself
Cassandra 6.0's Accord consensus protocol brings multi-partition ACID transactions with leaderless coordination and a single WAN round trip—eliminating the application-layer workarounds that Cassandra teams have built for years.
Datadog DASH 2026: When Your Monitoring Platform Became an Agentic Operating System
Bits AI agents now detect, remediate, validate, and write code inside Datadog. DASH 2026 marks the shift from observability tool to autonomous engineering platform.
Microsoft Made the Agent Runtime Free—and That's Exactly the Point
Microsoft's Agent Framework—built on open-source OpenClaw—is now free. Scout ships on top of it. The pattern matches how mobile platforms evolved: free runtime at the base, managed services and compliance tooling as the revenue layer.
Replit's Shopify Integration Reveals the Real Play: Owning the Vibe Coder's Full Financial Stack
Replit added Shopify storefront generation to its monetization suite—joining RevenueCat subscriptions and Visa agentic payments to assemble a turn-key financial layer for apps built without traditional engineering teams.
Claude Code Can Now Orchestrate 1,000 Agents at Once
Claude Code's dynamic workflows orchestrate up to 1,000 agents in parallel without manual pipeline setup. Here's what it changes for engineering teams.
When AI Teams Deploy 1,000 Times a Month, the Pipeline Breaks
AI coding agents have reversed the classic software constraint: code now takes hours, not weeks. The CI/CD pipeline, still designed for human-speed development, has not kept up.
From Jupyter Notebook to Production: How to Ship AI Systems That Actually Work
Over 85% of ML models never reach production. The gap isn't technical capability — it's the five infrastructure decisions that separate a working notebook from a reliable system.
JFrog's MCP Integration: Ask Your Platform to Provision Itself
JFrog's new MCP server lets AI coding agents like Cursor and Claude Code provision Artifactory repos, run Xray security scans, and trace release bundles — in plain language, without navigating dozens of UI screens.
Cloud Native Is Now AI-Native: Three Kubernetes Primitives That Don't Work for AI
A KubeCon roundtable with AWS, Google, and Microsoft engineers identified the specific Kubernetes gaps holding back production-ready AI — and the primitives being built to close them.
Kubernetes Dashboard Is Archived — Headlamp Is the Official Successor
The Kubernetes Dashboard project has been formally archived. Headlamp, its successor, adds multi-cluster support, application-centric views, and a plugin system while preserving the familiar single-cluster workflows.
Kubernetes Autoscaling at Scale: The Datadog Approach
From bulk UI activation to GitOps cluster profiles: how Datadog deploys Kubernetes autoscaling across an entire fleet without per-service configuration handoffs or manual YAML.
The Kubernetes Integration Tax: What Tutorials Never Show You
Platform teams spend 80% of their time wiring CNCF tools together, not installing them. Here's where Prometheus, Cilium, and cert-manager actually fail in production.
Platform Depth Unlocks AI Agents: The Unified Data Model Case
Fragmented tooling creates 20+ minute delays correlating data before rollout decisions. Unified data models eliminate that latency — and are the prerequisite for AI agents that can monitor and respond to production events autonomously.
Kubernetes v1.36: The Route Sync Metric That Quantifies CCM Waste
A new alpha counter in Kubernetes v1.36 makes the efficiency gap between default and watch-based route reconciliation observable — and reveals that a stable cluster generates 120 unnecessary syncs for every 1 actually needed.
AI Agent Observability: Why 79% of Teams Can't See What Their Agents Are Actually Doing
79% of organizations run AI agents but only 26% rate their observability as mature — and traditional APM can't trace multi-step agentic decision chains.
Migrating From ingress-nginx to Envoy Gateway Without Dropping a Single Request
How weighted Route 53 DNS records enable zero-downtime Kubernetes ingress migration from ingress-nginx to Envoy Gateway — and where the naive approach fails.
Kubernetes Policy Enforcement Is Happening at the Wrong Stage of Development
Review-time Kubernetes policy enforcement fills the gap between IDE linters and admission controllers. Here's how the four-layer model and GuardOn address it.
Datadog's 4th DevEx Dimension: Why AI Changes What You Have to Measure
Datadog added a 4th dimension to the DevEx framework for the AI era: AI adoption and impact. With 80% AI-assisted PRs, what you measure has to change.
AWS CDK Mixins: Composable Infrastructure Without Construct Rewrites
CDK Mixins, now GA in CDK v2.241.0, let platform teams apply logging, encryption, and compliance features to any construct with a single .with() call — without touching existing definitions.
Terraform 1.15: What Dynamic Module Sources Change for Platform Teams
Terraform 1.15 introduces dynamic module sources, variable deprecation, native Windows ARM64 support, and inline type conversion. Here's what each feature unlocks for IaC at scale.
Agentic Dev Tools: Why Audit Trails Can't Keep Up
As AI coding agents open merge requests and trigger pipelines, DevSecOps teams face a new compliance gap: the agents act, but the paper trail doesn't follow.
Red Hat AgentOps: Why 44% of AI Projects Stall Before Production
44% of enterprise AI leaders lack confidence in autonomous agents. Red Hat AI 3.4's AgentOps layer fills the governance gap blocking production deployment.
AWS Strands + Amazon Transform: How to Modernize 100 Repos Without a Migration Team
How AWS's three-service agentic stack — Strands, Transform Custom, and BedrockAgentCore — automates application modernization at scale.
Amp CLI: Multi-Agent Orchestration for Solo and Team Developers
Amp's Neo CLI rebuild brings sub-agent orchestration and persistent project memory to agentic developer workflows — how it compares to Claude Code and Cursor.
Azure Fleet Manager: How Microsoft Governs Thousands of K8s Clusters
Azure Kubernetes Fleet Manager governs thousands of K8s clusters via hub-spoke declarative policies — where GitOps' single-cluster model breaks down.
Temporal Serverless: Durable Execution Without Infrastructure
Temporal Serverless Workers scale to zero on Lambda — ending the long-lived polling model. What this means for agentic workflow teams.
Amazon WorkSpaces for AI Agents: Solving the Legacy Desktop Bottleneck
AWS's preview lets AI agents operate legacy desktop apps via WorkSpaces with IAM auth and computer vision — no API modernization needed. What it means for platform teams.
Kubernetes v1.36 Declarative Validation: Retiring 18,000 Lines of Code
Kubernetes API validation graduated to GA — a code generator now replaces 18K lines of handwritten Go. What platform teams gain from the shift to marker-based validation.
HCP Terraform + Infragraph: A Live Map of Your Entire Cloud Estate
HCP Terraform's Infragraph delivers a live knowledge graph of your multi-cloud estate — unmanaged resources, drift, and ownership visible in one place.
Incredibuild's Islo: A Persistent Sandbox Built for AI Agents, Not Human Developers
Existing cloud dev environments were designed for humans. Incredibuild's Islo gives each AI agent its own persistent, isolated environment with a policy layer — a different architecture for a different principal.
Amazon Q Developer Is Being Retired: What Kiro Means for AWS Developers
AWS will block new Amazon Q Developer signups May 15 and end IDE plugin support April 2027. The replacement is Kiro — an agentic IDE built for spec-driven development.
AWS What's Next 2026: Amazon Quick, Connect, and the OpenAI Bet
Amazon Quick brings AI to the desktop with 5 major integrations. What AWS's biggest 2026 announcements mean for cloud platform and enterprise AI teams.
Deloitte Cut Kubernetes Test Environment Provisioning From 45 Minutes to Under 5
Deloitte replaced dedicated EKS clusters per test environment with vCluster virtual clusters on a shared host — cutting provisioning from 45 minutes to under 5, and saving 500 QA hours annually.
Terraform Is Green. Your Cloud Is Broken. Here's Why.
Terraform state files are snapshots, not live records. When cloud infrastructure drifts from what Terraform believes exists, the plan looks clean until the outage happens.
AWS Transform Custom: Enterprise Code Modernization at 10-20× Less Effort
AWS Transform custom's Learn-Scale-Improve flywheel compresses code modernization from 12 weeks to 2.5. Here's how the agentic pipeline actually works.
k0s and k0rdent: Kubernetes Multi-Cluster Management Without the Control Plane Tax
k0rdent and k0s: how Hosted Control Planes remove the per-cluster overhead that makes Kubernetes fleet management expensive for platform teams.
OpenAI Workspace Agents: The Enterprise Infrastructure Story Behind GPT-5.5 Week
OpenAI launched Workspace Agents on April 22 — before GPT-5.5. Build once, share across teams, govern what it can touch. It's the first credible attempt to turn enterprise AI from scattered tools into shared infrastructure.
Roo Code's IDE Exit: What Happens When a Coding Agent Abandons the Editor
Roo Code is shutting down its VS Code extension on May 15 and launching Roomote — a cloud agent that runs coding tasks across Slack, GitHub, and Linear. The CEO's position: IDEs aren't the future of coding.
SmartBear Swagger Targets the Silent API Drift That AI Coding Tools Create
SmartBear's Swagger Catalog and Contract Testing with Drift Detection address a new failure mode: AI coding tools generate code that silently diverges from the OpenAPI spec it was supposed to implement.
AWS Interconnect: The Managed Layer Multicloud Has Been Missing
AWS Interconnect now offers managed private Layer 3 connectivity between AWS and Google Cloud VPCs — with Azure and OCI support coming later in 2026.
Platform Engineering Metrics: What to Measure, What to Ignore
Datadog maps the three-tier metrics hierarchy every platform team needs — outcomes, drivers, diagnostics — and explains why optimizing CI duration in isolation is a trap. Here's the framework.
Ingress NGINX Is EOL: What the K8s Gateway API Migration Actually Requires
Ingress NGINX reached end-of-life in March 2026 with unpatched critical CVEs. Kubernetes Gateway API is the designated successor — here's what the migration breaks and what Datadog maps out.
Amazon S3 Files: Object Storage Finally Gets File System Semantics
AWS launched S3 Files — file system access layered directly on S3 buckets. Sub-millisecond latency, 25K concurrent connections, 90% cost reduction vs hybrid architectures. Here's what changes.
The Hidden Tax on Every AI-Generated Merge Request
AI doubled merge request volume but review time rose 91% in parallel. Here's the hidden cost accumulating in your codebase.
Velero Joins CNCF Sandbox: What the Broadcom Donation Means
Broadcom donated Velero to the CNCF Sandbox at KubeCon Europe. For platform teams running Kubernetes, here's what the governance change means.
KubeCon 2026: Kelsey Hightower on AI and the Expertise Reset
Kelsey Hightower at KubeCon: when AI moves this fast, expertise resets. What 'everyone is junior on AI' means for platform engineering teams building on open source.
WebAssembly vs Containers: What WASI 0.3 Actually Changes
WASI 0.3 finalizes the WebAssembly component model, enabling 5–10x faster cold starts than containers. Here's what it means for platform engineering teams.
HashiCorp HCP Multi-Owner Governance: Scaling Terraform Without the Platform Bottleneck
HashiCorp's HCP governance update separates workspace ownership from policy enforcement — letting platform teams set global controls without owning every workspace.
The $43,800 Hidden Tax on Kubernetes: How Virtual Clusters Fix Platform Team Sprawl
Cluster sprawl consumes 25–30% of platform engineering time. Virtual clusters eliminate the hidden tax — without sacrificing the isolation teams actually need.
The Platform Under the Model: Why Cloud Native Infrastructure Determines AI Production Success
82% of container users run Kubernetes in production. Only 41% of AI developers identify as cloud native. That gap is where most AI production failures happen.