Developer Voices

Hosted by Kris Jenkins

Technology NewsInterviews guests

Website RSS feed LinkedIn YouTube

Episodes

104

Latest episode

Mar 2026

Language

About the show

Deep-dive discussions with the smartest developers we know, explaining what they're working on, how they're trying to move the industry forward, and what we can learn from them. You might find the solution to your next architectural headache, pick up a new programming language, or just hear some good war stories from the frontline of technology. Join your host Kris Jenkins as we try to figure out what tomorrow's computing will look like the best way we know how - by listening directly to the developers' voices.

Listen to episodes

60 recent

March 26, 20261 hr 40 min

What's Worth Knowing In AI Right Now? (with Henry Garner)

AI is changing the way we all build software — that much seems clear. But the landscape is moving so fast that even the people paid to keep up are struggling. MCP or skills? Fine-tune or just prompt? LangChain or let a thousand agents loose? With almost 70 competing technologies and a shelf life of maybe six months on any advice, how do you figure out what's actually worth your time?Henry Garner is CTO of JUXT, a consultancy with about 150 senior engineers working at the coalface of AI-assisted development, including building AI platforms for tier-one banks. JUXT publishes a quarterly AI Radar — 68 technologies rated and reviewed — and Henry's been watching his own team go through the full adoption arc, from "spicy autocomplete" skepticism through to building Byzantine-fault-tolerant distributed systems over a weekend with Claude. Along the way we cover MCP vs skills, Conway's Law for LLMs, neurosymbolic AI and the unexpected return of Prolog, the "Ralph Wiggum loop" for getting agents to converge on correct implementations, and Allium — a new behavioral specification language Henry's co-authored that sits between human prose and TLA+, aiming to give LLMs just enough structure to pin down what a system should do without falling into waterfall thinking.If you're trying to make sense of the AI tooling landscape, or you've hit that wall where your agents keep drifting away from what you actually wanted, Henry's thesis — velocity through clarity of intent — might well help out yours.--Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinJUXT: https://www.juxt.pro/JUXT AI Radar: https://www.juxt.pro/ai-radar/Allium on GitHub: https://github.com/juxt/alliumAllium Documentation: https://juxt.github.io/allium/Composition at a Distance (Henry's blog post): https://www.juxt.pro/blog/composition-at-a-distance/A New Vocabulary for an Old Problem (Henry's blog post): https://www.juxt.pro/blog/new-vocabulary-for-an-old-problem/Model Context Protocol (MCP): https://modelcontextprotocol.io/LangChain: https://www.langchain.com/LangGraph: https://www.langchain.com/langgraphGas Town (Steve Yegge): https://github.com/steveyegge/gastownKiro (spec-driven AI IDE): https://kiro.dev/Phoenix (LLM observability): https://github.com/Arize-ai/phoenixTemporal: https://temporal.io/Taalas (LLM-on-a-chip): https://taalas.com/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

February 19, 20261 hr 26 min

Asciinema: Terminal Recording Done Right (with Marcin Kulik)

I have a theory that only bad projects get finished — good ones keep finding new things to do. Asciinema is a case in point. What started as a way to share terminal sessions with friends has, over 14 years, grown into a full suite of tools covering recording, hosting, playback, and live streaming — and been rebuilt multiple times along the way. So what does it actually take to record and replay a terminal session faithfully in a browser?Joining us for this conversation is Marcin Kulik, Asciinema's creator. The project's architecture has passed through almost every interesting corner of software engineering: a Python recorder built around pseudo-terminals (PTY), a ClojureScript terminal emulator for the browser that hit performance limits with immutable data structures and garbage collection pressure, a move to Rust compiled to WebAssembly, a Go experiment that didn't last, and a new Rust CLI for concurrent live streaming backed by an Elixir/Phoenix server that calls Rust code via NIFs. The same Rust terminal emulator library now powers all three components — the browser player, the server, and the CLI.If you've ever looked at those terminal animations embedded in a README and wondered what's underneath them, or if you're interested in how a passionate open-source developer navigates 14 years of language changes and rewrites, this conversation has plenty to offer.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinAsciinema: https://asciinema.orgAsciinema Docs: https://docs.asciinema.orgAsciinema CLI (GitHub): https://github.com/asciinema/asciinemaAsciinema Player (GitHub): https://github.com/asciinema/asciinema-playerAsciinema Server (GitHub): https://github.com/asciinema/asciinema-serverAVT - Rust terminal emulator library: https://github.com/asciinema/avtvt-clj - the original ClojureScript terminal emulator: https://github.com/asciinema/vt-cljPaul Williams' ANSI/VT100 State Machine Parser: https://vt100.net/emu/dec_ansi_parserRust: https://www.rust-lang.orgWebAssembly: https://webassembly.orgSolidJS: https://www.solidjs.comElixir: https://elixir-lang.orgPhoenix Framework: https://www.phoenixframework.orgRustler (Rust NIFs for Elixir/Erlang): https://github.com/rusterlium/rustlerClojure: https://clojure.orgClojureScript: https://clojurescript.orgcmatrix: https://github.com/abishekvashok/cmatrixMarcin Kulik on GitHub: https://github.com/ku1ikMarcin Kulik on Mastodon: https://hachyderm.io/@ku1ikMarcin Kulik on asciinema.org: https://asciinema.org/~ku1ik"They're Made Out of Meat" demo: https://asciinema.org/a/746358Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/---0:00 Intro2:28 What Is Asciinema?4:48 How Asciinema Started9:51 The Problem of Parsing Terminal Output14:07 Building a Cross-Platform Recorder17:01 Rewriting the Parser in ClojureScript22:19 The Hidden Complexity of Terminals29:28 Rendering Terminals in the Browser39:47 When ClojureScript Can't Keep Up45:28 Moving to Rust and WebAssembly52:01 The Go Experiment57:43 Adding Live Terminal Streaming1:07:12 Can You Scrub Back in a Live Stream?1:14:40 Editing Recordings1:25:27 Outro

February 4, 20261 hr 41 min

Building the SpacetimeDB Database, Game-First (with Tyler Cloutier)

Eighteen months ago, Tyler Cloutier appeared on the show with what sounded like an ambitious (some might say crazy) plan: build a new distributed database from scratch, then use it to power a massively multiplayer online game. That's two of the hardest problems in software, tackled simultaneously. But sometimes the best infrastructure comes from solving your own impossible problems.The game, Bitcraft, has now launched on Steam. SpacetimeDB has hit version 1.0. And Tyler returns to share what actually happened when theory met production reality. We cover the launch day performance disasters (including a cascading failure caused by logging while holding a lock), why single-threaded execution running entirely from L1 cache can outperform sophisticated multi-threaded approaches by two orders of magnitude, and how the database's reducer model - borrowed from functional programming - enables zero-downtime code deployments. We also get into how SpacetimeDB is expanding beyond games with TypeScript support and React hooks that make building real-time multiplayer web apps surprisingly simple.If you're building anything where multiple users need to see the same data update in real time - which, as Tyler points out, describes most successful applications from Figma to Facebook - SpacetimeDB's approach of treating every app as a multiplayer game might be worth understanding.--Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinSpacetimeDB: https://spacetimedb.com/SpacetimeDB on GitHub: https://github.com/clockworklabs/SpacetimeDBOur previous episode with Tyler: https://youtu.be/roEsJcQYjd8Clockwork Labs: https://clockworklabs.io/Bitcraft Online: https://bitcraftonline.com/Bitcraft on Steam: https://store.steampowered.com/app/3454650/BitCraft_OnlineWebAssembly: https://webassembly.org/Flecs (ECS for C/C++): https://www.flecs.dev/flecs/TigerBeetle: https://tigerbeetle.com/CockroachDB: https://www.cockroachlabs.com/Google Cloud Spanner: https://cloud.google.com/spannerErlang: https://www.erlang.org/Apache Kafka: https://kafka.apache.org/Tyler Cloutier on X: https://x.com/TylerFCloutierTyler Cloutier on LinkedIn: https://www.linkedin.com/in/tylercloutier/--Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/0:00 Intro2:01 The Architecture of SpacetimeDB5:01 Client-Side Prediction in Multiplayer Games11:00 Reducers and Event Streaming15:00 Launching Bitcraft on Steam19:00 Debugging Launch Performance Problems26:56 Hot-Swapping Server Code Without Downtime30:01 In-Memory Tables and Query Optimization42:00 Is SpacetimeDB Only For Games?51:00 Performance Benchmarking For Web Workloads55:00 Why Single-Threaded Beats Multi-Threaded1:00:01 Multi-Version Concurrency Control Trade-offs1:05:01 Sharding Data Across Multiple Nodes1:10:56 Inter-Module Communication and Actor Models1:17:00 Replication and the Write-Ahead Log1:24:00 Supported Client Languages1:29:00 Getting Started With SpacetimeDB1:39:02 Outro

December 11, 20251 hr 51 min

Will Turso Be The Better SQLite? (with Glauber Costa)

SQLite is embedded everywhere - phones, browsers, IoT devices. It's reliable, battle-tested, and feature-rich. But what if you want concurrent writes? Or CDC for streaming changes? Or vector indexes for AI workloads? The SQLite codebase isn't accepting new contributors, and the test suite that makes it so reliable is proprietary. So how do you evolve an embedded database that's effectively frozen?Glauber Costa spent a decade contributing to the Linux kernel at Red Hat, then helped build Scylla, a high-performance rewrite of Cassandra. Now he's applying those lessons to SQLite. After initially forking SQLite (which produced a working business but failed to attract contributors), his team is taking the bolder path: a complete rewrite in Rust called Turso. The project already has features SQLite lacks - vector search, CDC, browser-native async operation - and is using deterministic simulation testing (inspired by TigerBeetle) to match SQLite's legendary reliability without access to its test suite.The conversation covers why rewrites attract contributors where forks don't, how the Linux kernel maintains quality with thousands of contributors, why Pekka's "pet project" jumped from 32 to 64 contributors in a month, and what it takes to build concurrent writes into an embedded database from scratch.--Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinTurso: https://turso.tech/Turso GitHub: https://github.com/tursodatabase/tursolibSQL (SQLite fork): https://github.com/tursodatabase/libsqlSQLite: https://www.sqlite.org/Rust: https://rust-lang.org/ScyllaDB (Cassandra rewrite): https://www.scylladb.com/Apache Cassandra: https://cassandra.apache.org/DuckDB (analytical embedded database): https://duckdb.org/MotherDuck (DuckDB cloud): https://motherduck.com/dqlite (Canonical distributed SQLite): https://canonical.com/dqliteTigerBeetle (deterministic simulation testing): https://tigerbeetle.com/Redpanda (Kafka alternative): https://www.redpanda.com/Linux Kernel: https://kernel.org/Datadog: https://www.datadoghq.com/Glauber Costa on X: https://x.com/glcstGlauber Costa on GitHub: https://github.com/glommerKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/--0:00 Intro3:16 Ten Years Contributing to the Linux Kernel15:17 From Linux to Startups: OSv and Scylla26:23 Lessons from Scylla: The Power of Ecosystem Compatibility33:00 Why SQLite Needs More37:41 Open Source But Not Open Contribution48:04 Why a Rewrite Attracted Contributors When a Fork Didn't57:22 How Deterministic Simulation Testing Works1:06:17 70% of SQLite in Six Months1:12:12 Features Beyond SQLite: Vector Search, CDC, and Browser Support1:19:15 The Challenge of Adding Concurrent Writes1:25:05 Building a Self-Sustaining Open Source Community1:30:09 Where Does Turso Fit Against DuckDB?1:41:00 Could Turso Compete with Postgres?1:46:21 How Do You Avoid a Toxic Community Culture?1:50:32 Outro

November 20, 20251 hr 5 min

Can Google's ADK Replace LangChain and MCP? (with Christina Lin)

How do you build systems with AI? Not code-generating assistants, but production systems that use LLMs as part of their processing pipeline. When should you chain multiple agent calls together versus just making one LLM request? And how do you debug, test, and deploy these things? The industry is clearly in exploration mode—we're seeing good ideas implemented badly and expensive mistakes made at scale. But Google needs to get this right more than most companies, because AI is both their biggest opportunity and an existential threat to their search-based business model.Christina Lin from Google joins us to discuss Agent Development Kit (ADK), Google's open-source Python framework for building agentic pipelines. We dig into the fundamental question of when agent pipelines make sense versus traditional code, exploring concepts like separation of concerns for agents, tool calling versus MCP servers, Google's grounding feature for citation-backed responses, and agent memory management. Christina explains A2A (Agent-to-Agent), Google's protocol for distributed agent communication that could replace both LangChain and MCP. We also cover practical concerns like debugging agent workflows, evaluation strategies, and how to think about deploying agents to production.If you're trying to figure out when AI belongs in your processing pipeline, how to structure agent systems, or whether frameworks like ADK solve real problems versus creating new complexity, this episode breaks down Google's approach to making agentic systems practical for production use.--Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinGoogle Agent Development Kit Announcement: https://developers.googleblog.com/en/agent-development-kit-easy-to-build-multi-agent-applications/ADK on GitHub: https://google.github.io/adk-docs/Google Gemini: https://ai.google.dev/gemini-apiGoogle Vertex AI: https://cloud.google.com/vertex-aiGoogle AI Studio: https://aistudio.google.com/Google Grounding with Google Search: https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/overviewModel Context Protocol (MCP): https://modelcontextprotocol.io/Anthropic MCP Servers: https://github.com/modelcontextprotocol/serversLangChain: https://www.langchain.com/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

October 31, 20251 hr 11 min

Building Observable Systems with eBPF and Linux (with Mohammed Aboullaite)

How do you monitor distributed systems that span dozens of microservices, multiple languages, and different databases? The old approach of gathering logs from different machines and recompiling apps with profiling flags doesn't scale when you're running thousands of servers. You need a unified strategy that works everywhere, on every component, in every language—and that means tackling the problem from the kernel level up.Mohammed Aboullaite is a backend engineer at Spotify, and he joins us to explore the latest in continuous profiling and observability using eBPF. We dive into how eBPF lets you programmatically peek into the Linux kernel without recompiling it, why companies like Google and Meta run profiling across their entire infrastructure, and how to manage the massive data volumes that continuous profiling generates. Mohammed walks through specific tools like Pyroscope, Pixie, and Parca, explains the security model of loading code into the kernel, and shares practical advice on overhead thresholds, storage strategies, and getting organizational buy-in for continuous profiling.Whether you're debugging performance issues, optimizing for scale, or just want to see what your code is really doing in production, this episode covers everything from packet filters to cultural changes in service of getting a clear view of your software when it hits production.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joineBPF: https://ebpf.io/Google-Wide Profiling Paper (2010): https://research.google.com/pubs/archive/36575.pdfGoogle pprof: https://github.com/google/pprofContinuous Profiling Tools:Pyroscope (Grafana): https://grafana.com/oss/pyroscope/Pixie (CNCF): https://px.dev/Parca: https://www.parca.dev/Datadog Continuous Profiler: https://www.datadoghq.com/product/code-profiling/Supporting Technologies:OpenTelemetry: https://opentelemetry.io/Grafana: https://grafana.com/New Relic: https://newrelic.com/Envoy Proxy: https://www.envoyproxy.io/Spring Cloud Sleuth: https://spring.io/projects/spring-cloud-sleuthMohammed Aboullaite:LinkedIn: https://www.linkedin.com/in/aboullaite/GitHub: https://github.com/aboullaiteWebsite: http://aboullaite.meTwitter/X: https://twitter.com/laytounKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

October 9, 20251 hr 11 min

Solving Git's Pain Points with Jujutsu (with Martin von Zweigbergk)

Git might be the most ubiquitous tool in software development, but that doesn't mean it's perfect. What if we could keep Git compatibility while fixing its most frustrating aspects—painful merges, scary rebases, being stuck in conflict states, and the confusing staging area?This week we're joined by Martin von Zweigbergk, creator of Jujutsu (JJ), a Git-compatible version control system that takes a fundamentally different approach. Starting from a simple idea—automatically snapshotting your working copy—Martin has built a tool that reimagines how we interact with version control. We explore the clever algebra behind Jujutsu's conflict handling that lets you store conflicts as commits and move freely through your repository even when things are broken. We discuss why there's no staging area, how the operation log gives you powerful undo/redo capabilities, and why rebasing becomes trivially easy when you can edit any commit in your history and have changes automatically propagate forward.Whether you're a Git power user frustrated by interactive rebases, someone who's lost work to a botched merge, or just curious about how version control could work differently, this conversation offers fresh perspectives on a tool we all take for granted. And if you're working with large monorepos or game development assets, Martin's vision for the future of Jujutsu might be exactly what you've been waiting for.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinJujutsu (JJ): https://github.com/martinvonz/jjJujutsu Documentation: https://martinvonz.github.io/jj/Git: https://git-scm.com/Mercurial: https://www.mercurial-scm.org/Rust: https://www.rust-lang.org/Watchman: https://facebook.github.io/watchman/Google Piper: https://research.google/pubs/why-google-stores-billions-of-lines-of-code-in-a-single-repository/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

September 24, 20251 hr 5 min

Getting New Technology Adopted (with Dov Katz)

Getting new technology adopted in a large organization can feel like pushing water uphill. The best tools in the world are useless if we're not allowed to use them, and as companies grow, their habits turn into inertia, then into "the way we've always done things." So how do you break through that resistance and get meaningful change to happen?This week's guest is Dov Katz from Morgan Stanley, who specializes in exactly this challenge - driving developer productivity and getting new practices adopted across thousands of developers. We explore the art of organizational change from every angle: How do you get management buy-in? How do you build grassroots developer enthusiasm? When should you use deterministic tools like OpenRewrite versus AI-powered solutions? And what role does open source play in breaking down the walls between competing financial institutions?Whether you're trying to modernize a legacy codebase, reduce technical debt, or just get your team to try that promising new tool you've discovered, this conversation offers practical strategies for navigating the complex dynamics of enterprise software development. Because sometimes the hardest part of our job isn't writing code - it's getting permission to write better code.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinMorgan Stanley: https://www.morganstanley.com/OpenRewrite: https://docs.openrewrite.org/Spring Framework: https://spring.io/Spring Integration: https://spring.io/projects/spring-integrationApache Camel: https://camel.apache.org/FINOS (FinTech Open Source Foundation): https://www.finos.org/Linux Foundation: https://www.linuxfoundation.org/Moderne (Code Remix conference organizers): https://www.moderne.io/Code Remix Conference: https://www.moderne.io/eventsKris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

September 10, 20251 hr 12 min

From Unit Tests to Whole Universe Tests (with Will Wilson)

How confident are you when your test suite goes green? If you're honest, probably not 100% confident - because most bugs come from scenarios we never thought to test. Traditional testing only catches the problems we anticipate, but the 3am pager alerts? Those come from the unexpected interactions, timing issues, and edge cases we never imagined.In this episode, Will Wilson from Antithesis takes us deep into the world of autonomous testing. They've built a deterministic hypervisor that can simulate entire distributed systems - complete with fake AWS services - and intelligently explore millions of possible states to find bugs before production. Think property-based testing, but for your entire infrastructure stack. The approach is so thorough they've even used it to find glitches in Super Mario Brothers (seriously).We explore how deterministic simulation works at the hypervisor level, why traditional integration tests are fundamentally limited, and how you can write maintainable tests that actually find the bugs that matter. If you've ever wished you could test "what happens when everything that can go wrong does go wrong," this conversation shows you how that's finally becoming possible.---Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinAntithesis: https://antithesis.com/Antithesis testing with Super Mario: https://antithesis.com/blog/sdtalk/...and with Metroid: https://antithesis.com/blog/2025/metroid/MongoDB: https://www.mongodb.com/etcd (Linux Foundation): https://etcd.io/Facebook Hermit: https://github.com/facebookexperimental/hermitRR (Record-Replay Debugger): https://rr-project.org/T-SAN (Thread Sanitizer): https://clang.llvm.org/docs/ThreadSanitizer.htmlToby Bell's Strange Loop Talk on JPL Testing: https://www.youtube.com/results?search_query=toby+bell+strange+loop+jplAndy Weir - Project Hail Mary: https://www.goodreads.com/book/show/54493401-project-hail-maryAndy Weir - The Martian: https://www.goodreads.com/book/show/18007564-the-martianAntithesis Blog (Nintendo Games Testing): https://antithesis.com/blog/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

August 22, 20251 hr 24 min

Building Render: Inside a Modern Cloud Platform (with Anurag Goel)

How would you build a Heroku-like platform from scratch? This week we're diving deep into the world of cloud platforms and infrastructure with Anurag Goel, founder and CEO of Render.Starting from the seemingly simple task of hosting a web service, we quickly discover why building a production-ready platform is far more complex than it appears. Why is hosting a Postgres database so challenging? How do you handle millions of users asking for thousands of different features? And what's the secret to building infrastructure that developers actually want to use?We explore the technical challenges of building enterprise-grade services—from implementing reliable backups and high availability to managing private networking and service discovery. Anurag shares insights on choosing between infrastructure-as-code versus configuration, why they built on Go, and how they handle 100 billion requests per month.Plus, we discuss the impact of AI on platform adoption: Are LLMs already influencing which platforms developers choose? Will hosting platforms need to actively support agentic workflows? And what does the future hold for automated debugging?Whether you're curious about building your own platform, want to understand what really happens behind your cloud provider's dashboard, or just enjoy hearing war stories from the infrastructure trenches, this episode has something for you.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/joinRender: https://render.com/Render’s MCP Server (Early Access): https://render.com/docs/mcp-serverPulumi: https://www.pulumi.com/Victoria Metrics: https://victoriametrics.comLoki: https://vector.dev/docs/reference/configuration/sinks/loki/Vector: https://vector.dev/Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.socialKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/