The Good Thing

What makes an API truly AI-ready?

Cody Holden is the Senior Product Manager for MCP and the Integrations Platform at HubSpot, where he’s been leading a major overhaul of HubSpot’s API architecture and building their MCP client for agentic use from the ground up. Before HubSpot, Cody worked across journalism, technical writing, and product leadership, giving him a rare, multidisciplinary perspective on communication, developer experience, and platform design.

Cody joins Stefan Avram for a deep dive into the next generation of APIs, integrations, and AI protocols, and how companies can prepare for an agentic future.

Here’s what you’ll learn:

From Writing to Product Leadership
Cody shares how starting his career in journalism and technical writing shaped his approach to product management, communication, and developer empathy.

Inside HubSpot’s API Evolution
We break down how HubSpot modernized its APIs, what it means to build “AI-ready” systems, and the governance challenges that come with operating at HubSpot’s scale.

MCP: Hype vs. Reality
Some claim MCP will replace APIs. Others say it’s just another tool. Cody explains where MCP actually fits in the integration landscape and what unique problems it solves.

Becoming a Better Product Manager
Cody explains what separates great technical PMs from the rest, how the role is changing in the AI era, and the key habits he’s developed across his career.

Looking Ahead
From agentic workflows to new API paradigms, we discuss where the ecosystem is headed over the next decade and what platforms will need to embrace to stay relevant.

If you’re building APIs, managing integrations, or navigating the intersection of AI and developer platforms, this episode is for you.

Jump into the comments:
- What does “AI-ready” mean in your organization?
- Will MCP become part of every integration strategy?

No, we’re NOT abandoning Federation. We’re taking it to the next level.

This week on The Good Thing podcast, Stefan Avram (CCO) and Jens Neuse (CEO) break down how Federation reshapes collaboration, scales developer velocity, and sets the stage for the next era of intelligent systems.

From GraphQL to REST, gRPC, and beyond, they explain why a “Federation Layer” is now essential infrastructure for modern engineering teams.

We’ll start with the basics: what Federation actually is, what problems it solves, and why it’s central to WunderGraph’s vision, before diving deep into how we’re evolving the model with the Entity Layer and Cosmo Connect.

Here’s what you’ll learn:

Federation 101: The Big Picture
We set the record straight: Federation isn’t dead, it’s just misunderstood. We’ll deep-dive into why Federation remains core to WunderGraph’s roadmap. Expect a brutally honest look at how the shift from monoliths to supergraphs changes how teams build, deploy, and ship software, and why Federation should be about connecting people, not just services.

The Entity Layer: The Real Magic
Jens explains why this layer is the biggest leap forward since the birth of GraphQL Federation. We unpack how the Entity Layer gives LLMs real business context, why it’s the missing link between human collaboration and machine intelligence, and how it redefines what “federated” even means.

Cosmo Connect and the Future of Federation
Forget GraphQL-only Federation: the future speaks gRPC. Stefan and Jens dive into why they’re betting big on multi-protocol Federation, and why clinging to GraphQL as the only solution limits innovation. We’ll explore how Cosmo Connect unifies REST, SOAP, and gRPC into one Federated model, and why that’s essential for modern, AI-ready architectures.

AI Meets Federation: From Toy Projects to Real Systems
Everyone’s talking about LLMs, but few know how to make them production-ready. We’ll break down how Federation gives AI systems context, consistency, and governance, stopping them from becoming just another demo project.

Rebuilding Federation from Scratch
If we could burn down Federation and rebuild it tomorrow, what would stay, and what would go? The hosts share candid lessons from years in the trenches, what the community gets wrong, and how Federation 2.0 (and beyond) will look when built with people, not protocols, in mind.

If you’re building APIs, running microservices, or exploring AI-ready architecture, this isn’t a tutorial. It’s a manifesto for what’s next.

Join us in the live chat or in the comments! We’d love to hear:
How is your team approaching Federation today?
Is GraphQL still central, or are you going multi-protocol?
If you’re averse to adopting Federation, why?

--
Chapter Markers
00:00:00 What this episode is about
00:02:52 Why WunderGraph is all-in on Federation
00:05:02 The Working Group
00:07:47 eBay partnership and real-world Federation problems
00:09:58 Subgraph authorization
00:11:27 Semantic Non-Null and upcoming products
00:14:24 MCP, AI, and Federation as the backbone
00:21:22 What the Entity Layer is and why it matters
00:32:14 Why next-gen Federation speaks gRPC (Cosmo Connect)
00:43:14 Summit reactions: APM templates, operators, connectors
00:49:06 We’re hiring; retreats, meetups, and community plans
00:52:55 AI hype vs API fundamentals: founder perspective
00:57:22 Vertical AI + API design/governance strategy
01:03:11 Closing + what’s next

Is great customer support as important as a great product?

Viola Marku is the Customer Success Manager at WunderGraph, where she partners closely with engineering-led teams to drive successful adoption of federated architecture across complex organisations. With nearly a decade of experience in technical startups, she brings both empathy and precision to every customer engagement, translating abstract challenges into clear, actionable paths forward.

Viola's cross-functional work with engineering and sales has helped reduce time to value while elevating the role of customer success as a strategic growth function. She's focused on creating the conditions for customer ownership, embedding success into how modern platform teams actually work.

Hosted by WunderGraph CEO Jens Neuse and COO Stefan Avram, they'll talk support excellence, feedback loops, and share advice they’ve learned along the way.

Here’s what you’ll learn:

Support is a Product
* Great support isn't an afterthought. Viola and Stefan make the case that support is part of the product, and why investing early pays off.

From Chaos to EOC and beyond
* We trace the evolution of WunderGraph’s support process, from Stefan juggling sales and support alone, to the launch of the Engineer-On-Call (EOC) system in 2025, to how Viola reshaped workflows when she joined the team earlier this year.

Turning Feedback into Features
* How WunderGraph collects, prioritizes, and acts on customer feedback, and why this feedback loop is one of their biggest product advantages.

Failures, Fixes, and Lessons
* We talk about real mistakes: the support tickets that went sideways, the growing pains, and how even the worst moments became learning opportunities.

Scaling a Support Culture
* With a growing user base, how will WunderGraph maintain its customer-first values?

From AI tooling to culture building, we explore how the team is preparing for what’s next.

Whether you’re scaling a devtool, leading a support team, or just curious how real customer obsession shapes product growth, this episode is for you.

Jump into the comments or live chat! We want to hear:
* Is great customer support as important than the product itself?
* What’s the biggest support fail you’ve learned from?
* Can great support be your moat?

APIs run the modern digital world, but what separates the good from the great?

Daniel has been part of the codecentric team since October 2016. Since the beginning of 2022 he works as Principal API Consultant at the Dortmund branch. Starting as a consultant with a focus on application lifecycle management, his focus shifted more and more towards APIs. In addition to numerous customer projects and his involvement in the open source world around APIs. He is also a frequent speaker at conferences.

In this episode of The Good Thing with Stefan & Jens, Daniel joins us for a deep dive into how modern teams should think about APIs: as products, as capabilities, and as core business enablers. From governance models to open source adoption to the future of API standards, this conversation explores what it really takes to make APIs work at scale.

Here’s what you’ll learn:

From APIs to Capabilities
Daniel explains why thinking in terms of capabilities (“Ship Order”, “Process Payment”, “Approve Loan”) instead of technical endpoints can reshape API design. We discuss how this mindset shift ensures APIs align with business value and how product thinking drives long-term success.

Governance vs. Gateways
APIs don’t succeed without governance. Daniel shares why tools like API gateways are helpers, not leaders. Together, we explore strategies for balancing autonomy with control, defining ownership, and preventing API sprawl without killing innovation.

Open Source as the API Backbone
codecentric deliberately builds on open-source technologies. Daniel, Jens, and Stefan discuss how communities like OpenAPI, AsyncAPI, and GraphQL accelerate progress, the trade-offs of open source in enterprise settings, and why standards are crucial for event-driven APIs.

The Future of APIs
What role will GraphQL, gRPC, and AsyncAPI play in shaping tomorrow’s API strategies? How might AI influence API design and usage? Daniel shares his perspective on when to use different approaches, where they converge, and why reliability still matters most.

If you care about API strategy, developer experience, or building infrastructure that lasts, this conversation is for you.

Join the live chat or comments and share:
* Should APIs be designed as capabilities, not endpoints?
* How much governance is too much?
* What’s the role of open source in API strategy today?

What defines a truly great developer experience?

Sam Lambert is the CEO at PlanetScale, building the next-generation cloud database. Previously Sam was Vice President of Engineering at GitHub, where he was responsible for scaling the company and culture to the world's largest platform for developers with over 100 million users. He was also responsible for creating GitHub Actions, the popular workflow automation tool. Prior to GitHub, Sam led the traffic and video infrastructure teams at Facebook. He is passionate about developer experience and delivering high quality software at scale.

Sam joins us this week for an unfiltered conversation on what it takes to build tools developers trust. From scaling GitHub to reinventing how teams manage database workflows, Sam has been behind the scenes of some of the most developer-loved platforms of the last decade.

Hosted by Stefan Avram and Jens Neuse, we talk DevEx, open source, monetization, collaboration, and where databases are headed next.

Here’s what you’ll learn:

Trust over Table Stakes
Dark mode, a CLI, a working UI: these are baseline features, not innovation. Sam unpacks why trust is the foundation of any great developer experience, and how long-term thinking beats short-term applause.

From Vitess to DevOps for Databases
When Sam joined PlanetScale, the company was transitioning from simply offering the Vitess technology to delivering a MySQL database with a “compelling developer workflow”. We’ll explore how Sam helped articulate that product vision and build trust with users.

Data Federation Meets API Federation
PlanetScale unifies data across shards, regions, and database types. WunderGraph unifies APIs. Together, they offer a complementary model for modern teams. We explore how customers are using both types of tools, and what makes collaboration at scale actually work.

AI, Agents, and the Next Database Paradigm
We couldn’t end without asking Sam how AI is shifting the way PlanetScale works, and how he sees the future. What does the rise of agents and new protocols (cough, MCP) mean for databases? And what trends is Sam betting on for the next five years?

Why PlanetScale Metal is so fast
Sam breaks down the architectural decisions behind their high-performance Postgres and MySQL offerings. He explains how they run petabytes of state on bare metal inside Kubernetes and why most cloud databases leave performance on the table.

Lessons from 55 people with 100% uptime
With just 55 employees, PlanetScale runs one of the most trusted database platforms. Sam explains how a tiny infra team, a “no passengers” culture, and zero sysadmins help them outperform hyperscalers with 10 times the headcount.

The Open Source Advantage
Sam, Stefan & Jens explore how OSS enabled PlanetScale’s early growth, how they think about building on top of OSS today, and what Sam really thinks about the CNCF situation.

Building for Scale
Sam opens up about his obsession with scale. He talks about spinning up 500-node clusters at the press of a button and living vicariously through the success of their customers.

If you're building developer tools, designing distributed systems, or just want a fresh perspective on where infrastructure is headed, this one’s for you.

Jump into the comments or live chat! We want to hear:

What does “developer experience” mean to you?
Are databases finally part of DevOps?
Is open source still the best way to start something big?

What’s the future of API’s in an AI-powered world?

Kevin Swiber is an API strategy advisor with 15+ years of experience in standards and startups. They have a history of working in leading roles through software engineering, infrastructure operations, and enterprise architecture. In addition to their experience working at API companies like Apigee and Postman, Kevin is a member of the OpenAPI Initiative. Kevin is the CEO of Layered System, where they consult on the intersection of AI and APIs.

Kevin joins Stefan Avram and Jens Neuse to talk APIs, MCP, Federation, collaboration, and what’s coming next.

Spoiler: it’s APIs all the way down.

Here’s what you’ll learn:

It’s APIs All The Way Down:
APIs quietly power everything. Kevin, Stefan, and Jens unpack how APIs became the connective tissue of modern software, why this era feels different, and what it means for the future of digital products.

MCP: API Consumer, Not API Killer:
There have been claims that MCP (model context protocol) will replace APIs. But, as Kevin puts it, “MCP is built to consume APIs, not replace them. The host (an AI assistant like Claude) communicates with clients, which in turn communicate with servers that access various resources.” We discuss what this new layer means, how OpenAI and Anthropic are building around it, and why Sam Altman calls this "the protocol era."

Open Standards and Planning Your Escape Routes:
Kevin, Stefan & Jens talk big-bad vendor lock-in. They reflect on the history of API description formats and what led to the “OpenAPI advantage,” while sharing perspectives on the current API ecosystem and why they encourage companies to “plan their escape routes.”

API Design, Conway’s Law, and the Federation Fix:
Bad APIs often reflect bad org charts. Kevin, Stefan & Jens share lessons on designing APIs that scale with your team. We explore (GraphQL) Federation as a strategy to break down silos and avoid the pitfalls of Conway’s Law on system architecture.

What’s Next: Protocol Era, AI Agents, and the Future of APIs:
Are companies heading toward a new existential race to build internal API + AI layers?

Our hosts and Kevin share what to watch for, how to prepare, and what may be the real moat of the future.

If you care about APIs, AI, or building systems that scale, this episode is for you. Join us in the chat or the comments below!

HUGE thank you to Kevin Swiber for joining us today. Check out their blog here: https://www.layered.dev/

AI tools were supposed to 10x developer productivity. But what if they’re actually slowing us down?

A new study from METR found that AI coding tools like Cursor and Copilot slowed experienced developers down by 19 percent on average. A vindicating followup to a key insight from last episode: “every line of code is a liability”. However, this study has some SERIOUS red flags, and it seems more clickbait than substance.

Meanwhile, Swedish darling Lovable just raised a $200M Series A only 8 months after launch. They’re already pushing $20M+ ARR with just 45 employees, putting them near a $2B valuation. This phenomena of small AI startups bagging HUGE influxes of cash from VCs is not surprising nowadays, but still begs the question: bubble or not?

And then there’s Meta. In 2023, they doubled down on their stance that the future of AI is open-source. Now? They’re reportedly considering pulling the plug on Behemoth, their most powerful open-source model. After Chinese researchers at DeepSeek forked it and created a stronger, more efficient model, Meta might be regretting their open strategy (even if that was the point all along).

Plus, we talk (of course) about Federation, and why we’re bullish on gRPC as the next generation. Jens also shares key insights from his latest two blog posts on the topic.

This, and more, in this week’s episode of The Good Thing with Stefan & Jens.
An overview of what we’ll cover:

AI PRODUCTIVITY CRISIS?
- The METR study that says AI tools are slowing developers down
- A follow-up to our “every line of code is a liability” discussion
- Why “code generation” isn’t the same as productivity
- Can it be trusted? (probably not)

LOVABLE RAISES $200M SERIES A
- $20M+ ARR in just 8 months
- Is this sustainable or just another startup bubble moment?

META BACKS AWAY FROM OPEN SOURCE
- Behemoth might get shelved
- Did DeepSeek’s success spook them?
- Was Meta ever truly committed to open AI?

THE NEXT GENERATION OF GRAPHQL FEDERATION SPEAKS gRPC
- Why we’re bullish on gRPC as the next generation
- Insights from Jens’ latest blog posts
- What gRPC brings to Federation that GraphQL alone can’t

If you’re a dev who relies on these tools, this episode is for you. We’d love to hear:
- Have AI tools actually slowed you down?
- Should open-source AI stay open if it can be cloned and outpaced?
- Do you agree with our take on gRPC?

Happy Friday, and Welcome Back!

Cursor's recent pricing change sparked a developer exodus. But it really wasn’t about the price.

2025’s darling AI-code-editor Cursor shook its community this week with surprise pricing and usage changes that blindsided many. But It wasn’t just about the money, it was about the lack of transparency.

They apologized, but only for how they announced it, not for the changes themselves. The fallout? Heated debates across Cursor's social channels and numerous articles (including one from TechCrunch) dissecting their “non-apology” apology.

On the topic of Cursor… Claude Code just dropped its own VSCode extension. Many think this could eat substantially into Cursor’s userbase. Could this, coupled with the harsh reaction from the developer community to Cursor’s business model changes, signal the beginning of the end for Cursor already?

Plus, the other big story of the week: Planetscale now supports Postgres, which could have HUGE impacts on the infrastructure of digital products going forward.

This, and more, in this week’s episode of The Good Thing with Stefan & Jens. An overview of what we’ll cover:

CURSOR CONTROVERSY:
- Will its unicorn reign come to a screeching halt?

PLANETSCALE FINALLY EMBRACES POSTGRES:
- Postgres is the number two database tech after MySQL, which used to be Planetscale’s only focus. By adding Postgres, they just unlocked another 20 percent of the market.

LEE ROB MOVES ON FROM VERCEL
- The legendary Lee Robinson (@leerob) has officially moved on from Vercel. We thank him for his service to Next.JS and beyond.

DIGGING A MOAT WITH AN AI PRODUCT
- ..is pretty much impossible, unless you have hardware. Or is it? (yes it is, but let's talk about it).

If you’re a dev who relies on these tools, this episode is for you. We’d love to hear:
- Did Cursor handle this as badly as everyone says?
- Will you switch to Claude Code?
- Do you agree with our take on where gRPC fits in the GraphQL Federation picture?
- How do you think Planetscale x PostgresQL will change system design?

Drop your thoughts in the live chat or the comments below.

In this episode of The Good Thing with Stefan & Jens, our CEO Jens takes us through his latest LinkedIn post calling out a growing anti-pattern: generating GraphQL schemas from OpenAPI specs: deep dive into how we should (and shouldn’t) be building APIs.

Topics this episode:

Apollo GraphQL’s new “Connectors” feature… which somehow breaks their own Principled GraphQL guidelines. We unpack where things went sideways and what demand-driven schema design is really about.

"The first problem I see is that a GraphQL Schema should always be demand driven. A demand driven schema should abstract away the implementation details and solely focuses on the requirements of the app developers that use the API. These are by the way not my words but Apollo write this themselves in principled GraphQL." - Jens

The tech industry’s promise of “learn to code” is hitting a harsh reality: Comp Sci grads are facing the highest unemployment rate among all majors. We discuss what this means for hiring, the state of tech education, and how companies should respond.

And finally, we talk LLMs: Are they supercharging creativity, or dulling it? A post from Ahmet Soormally got us thinking: are engineers outsourcing too much of their thinking to AI tools?

Here’s a breakdown of the episode:

OpenAPI → GraphQL?

Apollo’s “do as I say, not as I do” moment

The job market crunch for Comp Sci graduates

Keeping your creative edge in an AI-assisted world

DISCLAIMER: This episode is much more fun in video-form. Check the link below for the link to the video version on YouTube.

Everyone's building an AI startup in 2025. But how many will make it to 2026?

VC funding is flowing, landing pages are sleek, and the term “AI-native” is slapped on everything from search tools to to-do apps. It’s a great time to start an AI company — but a brutal one to survive in.

In this episode of The Good Thing with Stefan & Jens, we decided to cut through the noise. Inspired by the energy of tech Twitter and the glut of product launches on Hacker News & Product Hunt, we created a 2025 AI Startup Tier List.

We picked 10 real AI startups and ranked them from S to F:

S Tier – Unicorn potential

A Tier – Will probably survive and find a market

B Tier – Decent shot, some good signs

C Tier – 50/50 territory, hard to call

D Tier – We’re worried, but not fully out

F Tier – RIP. Defunct imminent

What makes a startup S-tier vs. F-tier? We used 3 guiding criteria:

1. Impact – Are they solving a real, meaningful problem?

2. Differentiation – Are they unique or already being outplayed?

3. Gut feeling – Does it "feel" like it’s going to work out?

Disclaimer: these rankings are OUR OPINIONS. We never wish ill-will on any company. Stefan & Jens have considerable industry experience & have seen a thing or two, so these stamps of approval (or lack thereof) are backed up with years of trial & error scar tissue. If your organization doesn’t meet the mark on our list, we'd love to see you prove us wrong.

If you’re building, investing in, or just lurking in the AI space — this episode is a must-watch reality check.

Which startups would you put in F Tier right now? Or better yet — who’s your dark horse S Tier? Let us know in the comments.

When you're building in public, you don’t just ship code—you ship opinions. And sometimes, those opinions light the internet on fire.

In this week’s episode of The Good Thing, Jens and Stefan unpack three of the most talked-about stories in tech—from language wars to AI ethics to the future of foundational infrastructure.

We cover:

Go vs. Rust – why Jens’s viral post stirred up so much emotion, and what’s actually at stake for dev teams choosing between them

Claude and the blackmail buzz – TechCrunch’s report on Anthropic’s AI refusing shutdown… science fiction or a signal we shouldn’t ignore?

The Stargate Project – OpenAI's new collaboration with Oracle and SoftBank, with support of the United States Government, to invest $500 billion into AI infrastructure in the U.S.

OpenAI’s IPO potential – how going public could shift incentives, influence pricing, and impact every startup building on their APIs

If you care about developer experience, responsible AI, or the systems your tools depend on, this episode hits the sweet spot between spicy takes and serious insight.

We’d love to hear your thoughts:
Is Rust hype or hard truth? Should we be worried about agent autonomy? And how would a public OpenAI reshape the industry?

When you’re scaling systems, moving fast is only half the battle. You also need clarity around architecture, real-world feedback, and a deep understanding of how tools like GraphQL and AI actually fit into your pipeline. That’s where experience counts—and this week, we brought in one of the best.

On this episode of The Good Thing, Jens and Stefan are joined by Robert Farr, Principal Software Architect at Procore. With 22+ years in engineering and a track record across distributed systems, big data, and cloud architecture, Robert brings hard-earned perspective to the kinds of problems you don’t read about in tutorials.

We cover:

Where delivery pipelines break down at scale—and how to fix them

The realities of GraphQL Federation—what holds up, and what doesn’t

How AI is actually being used in engineering orgs today

Lessons from building resilient systems under real-world pressure

If you're navigating GraphQL, scaling platforms, or figuring out how AI fits into your workflows—this one’s packed with hard-won insight.

We’d love to hear your thoughts:
What’s the biggest challenge in your delivery pipeline right now?

TECHNICAL ADVISORY BOARDS: When you're building a platform for developers, shipping fast is not enough. You need feedback loops that grow with your product. You need insights from the people who hit the edge cases first. That is what a strong TAB enables.

In this week’s episode of The Good Thing, Jens and Stefan take you inside WunderGraph’s own Technical Advisory Board — what it is, how it works, and why it has become a critical part of how we build.

We cover:

Who belongs in a great TAB and why perspective diversity improves product outcomes

How structured feedback helped us improve delivery speed and reliability

Using a TAB to validate assumptions and make smarter roadmap decisions

What happens when you build based on real needs instead of internal guesses

If you are building developer platforms, scaling APIs, or just tired of guessing what your users want, this episode offers a clear path to more informed decisions.

We’d love to hear your thoughts:
Do you have a TAB or similar sounding board?

How has it shaped your roadmap?

APIs are shaped by teams. But what happens when teams are shaped by AI?

Conway’s Law famously says that software mirrors the communication structures of the teams that build it. But in a world of generative AI, autonomous agents, and increasingly API-first systems—how does that law hold up?

What we cover:

AI-Augmented Architectures – how generative tools influence team structures and API design

System Boundaries – when Conway’s Law helps… and when it hurts

Org Design for AI Era – how to align communication, ownership, and automation

APIs as Interfaces for AI – what happens when your consumers are not humans

Emergent Behavior & Complexity – the risks and rewards of AI-driven development patterns

We’re not just talking theory—we’re asking how engineering culture must evolve when your code isn’t only written by developers anymore.

If you’re building APIs, platform infrastructure, or just rethinking how your teams work in the age of AI, don’t miss this conversation.

We’d love to hear your thoughts:

How has AI changed the way your team communicates and builds?

Reuse is at the heart of open source, but what happens when reuse turns into rebranding?

When a third party matches your project feature-for-feature, slaps on a new logo, and sells it without contributing a cent or a single PR… what do you do?

What we cover:

License Levers – weighing Apache 2.0, SSPL, and Fair Code tradeoffs

Dual-Licensing & Open Core – can “pay-for-extras” models protect innovation?

Trademark & Branding – using reputation as your defensive moat

Community vs. Commercial – how do you balance contributor trust with sustainable growth?

Each strategy solves a different piece of the open-source sustainability puzzle. Together, they form the backbone of a resilient, value-aligned OSS model.

If you're building or relying on OSS, the real question isn't "How do we stop the copycats?".
It’s “What value are we trying to protect, and for whom?”

We'd love to hear your perspective: How would you react if your flagship OSS got resold without attribution?

DISCLAIMER: This episode is much more fun in video-form. Check out the link below for the link to the video episode on YouTube.

What makes a landing page actually work for developers? And why do so many fall short?

In this week’s episode of The Good Thing Podcast, Stefan and Jens dive into the design, messaging, and overall strategy behind the landing pages of some of today’s top developer platforms. From standout CTAs to common pitfalls, they break down what works, what doesn’t—and how we’re applying those insights at WunderGraph.

In the episode, they cover:

First impressions: what developer-focused brands are getting right

Common issues: where landing pages fail to convert or communicate

Practical takeaways: tips you can apply to improve your own product pages

A candid review of what makes a technical landing page both clear and compelling

Whether you’re a founder, marketer, or devtool builder, this episode is packed with value on how to position your product for the people who matter most: developers.

The Future of API Development: Building Internal Apps Faster Than Ever

Creating internal tools used to be a tedious process—connecting data sources, configuring UI, and deploying systems manually. But what if you could generate fully functional internal apps with a single prompt?

In this episode, we showcase a powerful new feature built on WunderGraph’s Supergraph and MCP Gateway that lets teams create employee dashboards and internal apps in minutes—not days.

From changing availability statuses in real time to auto-generating complete admin panels, we’re witnessing a shift in how internal software is being built.

And it’s not just fast—it’s intelligent.

Join us as we discuss:

How To Build An Entire Internal App from a Prompt

⟶ A walkthrough of how WunderGraph’s latest tool auto-generates internal tools based on your Supergraph—no manual configuration needed.

The End of Manual Data Source Connections

⟶ Why older tools like Retool required complex setups—and how this new approach removes that barrier with native integration and automation.

The New Mental Model for Internal Tooling

⟶ What happens when your API is not just a backend, but an engine for building software experiences? We unpack the philosophy behind this next-gen tooling shift.

The Good Thing?

Internal app development just got 100x easier—and smarter. No more spreadsheets, no more glue code. Just describe what you want, and let the system do the rest.

We're not just simplifying dev work—we're reimagining it.

The Tobi AI Memo: Shopify's Bezos Moment? | TGT #13

In this episode, we're gonna discuss the leaked internal memo from Shopify CEO Tobi Lütke that outlines a bold new direction for AI integration within the organization.

Let's unpack the 10 key insights from the internal message—an emerging "AI mandate" that echoes the impact of Jeff Bezos’ famous 2002 API directive at Amazon. As the tech world moves toward AI-native workflows, Shopify’s internal alignment around AI could signal a broader shift in how modern product and engineering teams operate.

We'll also discuss:

AI-Native Workflows at Scale

A closer look at how AI is being adopted as core infrastructure across large organizations, accelerating prototyping, decision-making, and cross-functional collaboration.

Security in the Stack: “The S in MCP Stands for Security”

A closer look to the trending Hacker News thread that challenges assumptions about secure systems, with a focus of the foundational importance of security in modern infrastructure.

AI is no longer optional—it’s becoming infrastructure. From how we code to how we collaborate, this shift is redefining team dynamics, tooling choices, and developer productivity across the board.

Join us as we break down these game-changing trends and discuss what it all means for the future of software engineering.

Want to join us on the podcast? Reach out to jacob@wundergraph.com!

Beyond GraphQL: How Federation is Redefining Scalable API Architecture

As organization scale, API management becomes increasingly complex, GraphQL Federation offers a transformative approach, enabling teams to build modular, scalable, and efficient API architectures.

In this episode, we delve into the evolution of GraphQL Federation—how it addresses the limitations of monolithic GraphQL APIs, enhances team collaboration, and streamlines API development at scale.

What to Expect in This Episode

The Evolution of GraphQL Federation

⟶ A look at how GraphQL Federation emerged as a response to the challenges of scaling GraphQL, and why it is shaping the future of API architecture.

Understanding Federation—How It Works

⟶ A deep dive into the core principles of federation, including subgraphs, schema composition, and distributed API management.

Overcoming Challenges in Federated Architectures

⟶ Insights into the common pitfalls teams face when implementing GraphQL Federation and best practices for success.

Real-World Applications and Industry Adoption

⟶ Case studies of engineering teams leveraging federation to improve API performance, optimize data access, and accelerate development.

The Future of GraphQL Federation

⟶ Emerging trends, innovations, and what’s next in the evolution of federated GraphQL APIs.

The advancements in GraphQL Federation would not be possible without the contributions of the developer community, whose insights and real-world implementations continue to drive innovation in API architecture.

The Good Thing Is…

The future of API development is being redefined, and GraphQL Federation is leading the way. As teams seek more scalable and efficient solutions, we are committed to exploring the next generation of API collaboration.

Join us as we break down the latest developments, share actionable insights, and discuss how engineering teams can leverage GraphQL Federation to build the future of API management.

Big announcement: We’ve secured $7.5M to revolutionize API collaboration!

In this special episode, we break down our Series A funding —what it means for WunderGraph, how it shapes our future, and the journey that got us here. Led by Karma Ventures, with participation from eBay Ventures and Aspenwood Ventures, this investment is a huge step forward in making WunderGraph Cosmo the go-to solution for API management at scale.

What's inside this episode?

The Story Behind Our $7.5M Series A Funding

⟶ A behind-the-scenes look at how we secured funding, the challenges we faced, and what this milestone means for the future of WunderGraph.

How Customer Feedback Helped Shape WunderGraph Cosmo

⟶ The crucial role our community and early adopters played in refining WunderGraph Cosmo—how your insights directly influenced its development.

Our Vision for the Future—Performance, Reliability & Scalability

⟶ How we're using this funding to push the boundaries of API collaboration, ensuring a faster, more reliable, and scalable experience.

New Features That Will Power Seamless API Collaboration

⟶ A sneak peek at upcoming innovations designed to enhance cross-team workflows, streamline development, and improve enterprise-scale collaboration.

What's Next—And How You Can Be Part of It

⟶ Our roadmap for the future and the opportunities to get involved—whether as a user, contributor, or team member.

None of this would be possible without you—our customers, community, and early supporters. Your trust, insights, and real-world use cases have been the driving force behind WunderGraph, shaping it into the game-changing platform it is today.

The Good Thing is...

We are just getting started!

With this new chapter, we're not just celebrating a funding milestone— we're doubling down on innovation, pushing limits of what's possible in API collaboration. We're committed to making API management more intuitive, scalable, and developer-friendly than ever before.

Join us as we shape the future of API development, turning ambitious ideas into powerful, real-world solutions for developers, teams and enterprises.

The Good Thing Podcast Episode 10 | Building WunderGraph: The Highs, Lows & Lessons Learned

For our 10th episode, we're making it extra special—an in-person conversation featuring all four WunderGraph founders: Björn, Jens, Dustin, and Stefan.

This offers an inside look at the journey of building WunderGraph—from the early decisions that shaped its success to the challenges and missteps along the way. We’ll discuss what we love about the platform, what we would have done differently, and the realities of running a remote-first company in today’s tech era.

Join us as we discuss:

The Strategic Decisions That Shaped WunderGraph

⟶ a reflection on the best choices we've made and how they've contributed to the company's growth.

Lessons Learned from Challenges and Missteps

⟶ the mistakes, trade-offs, and unexpected obstacles we encountered while scaling WunderGraph

The Reality of Running a Remote Company

⟶ insights into the opportunities and difficulties of managing a distributed team.

What We Love (and Hate) About WunderGraph

⟶ a candid discussion on the technical and business aspects of the platform. What excites us and what frustrates us.

The Future of WunderGraph

⟶ our evolving vision and what's next for the company.

The Good Thing?

Building a company is a journey of constant learning, iteration, and adaptation. Join us as we share our experiences, providing valuable insights for developers, startup founders, and anyone navigating the complexities of building a tech company.

With so many programming languages—JavaScript, Python, Go, Rust, TypeScript—how do you choose the one that matches your vibe?

Choosing the right programming language is one of the most important decisions developers make. But beyond personal preference, what factors truly define the best language for a given project?

In this episode, we break down the pros and cons of programming languages and explore how different factors—performance, scalability, ecosystem, and developer experience—shape the decision-making process.

But that's not all. We also explore an intriguing shift: Why did the creators of TypeScript opt for Go instead of C#? More importantly, what does this decision reveal about Microsoft’s long-term commitment to C# and .NET?

Along with a comprehensive review of several key topics.

Unfortunately, Stefan won't be joining this episode as he's traveling to meet the team, but the discussion continues with AI expert Cameron Sechrist!

Join us as we discuss:

What language should we vibe code in?

⟶ comprehensive analysis of the key factors influencing language selection and how different programming languages impact software development and long-term maintainability.

Why TypeScript chose Go instead of C#?

⟶ an in-depth look at why the creators of TypeScript opted for Go instead of C#. We explore the technical considerations, trade-offs, and strategic advantages that led to this decision.

What Decision Implies About Microsoft's commitment to C# and .NET?

⟶ the decision suggest about Microsoft's long-term vision for C# and .NET. The potential impact on the developer ecosystem, enterprise adoption, and the future of Microsoft's technology stack.

The Good Thing?

Technology choices shape the future of development, and we’re here to break them down.

Join us as we decode these crucial engineering decisions, turning technical complexity into actionable insights for developers, tech leaders, and decision-makers.

The State of Federation | What We've Learned Through Rapid Scale with Top Enterprise

In this episode, we take an in-depth look at our evolving approach to API integration and scalability. Drawing from our experiences with Top Enterprise clients, we share our insights on Federation—its challenges, breakthroughs, and the best practices/strategies we’ve developed along the way.

Along with a comprehensive review of several key topics.

Our discussion includes:

* The State of Federation ⟶ Learn how rapid scale with leading enterprises has refined our Federation strategy. We discuss the real-world challenges we’ve encountered, the trade-offs made, and the key lessons that have enabled us to build resilient, high-performing API infrastructures.

* REST Connectors ⟶ Get our unfiltered take.

* SoundCloud's Migration to WunderGraph ⟶ Explore a comprehensive case study detailing SoundCloud's journey, as we break down what we built, the technical hurdles we overcame and how their successful migration has enhanced their scalability and performance.

* Behind the Scenes of Renewals ⟶ Go behind the scenes with us and understand our customer retention process.

* The State of GraphQL Adoption ⟶ Examine the current market trends and industry shifts impacting GraphQL, as we provide insights into what the future holds for organizations adopting or optimizing GraphQL in their technology stacks.

Join us as we decode these complexities of engineering decisions, turning challenges into strategic opportunities that drives innovation for tech leaders and decision makers.

Ever wondered how Composition and Query Planning in GraphQL Federation works?

In this episode, Founding Engineers Sergey and Chief Composition Officer David share their insights and experiences at WunderGraph while discussing the intricacies of Federation.

What You'll Learn:

* Insights into the unique challenges of being founder engineers at an early stage startup
* Deep dive into the relationship between Federation, Composition & Query Planning
* Why it's still exciting to work on GraphQL tooling after more than 5 years
* What our experts think of Audits and the Federation Ecosystem

The Good Thing is...

Every engineering and business decision involves trade-offs. This episode provides a detailed exploration of these challenges and offers strategies for navigating them effectively.

Copying your competitors might seem like a shortcut to success—but is it really?

Could it actually be holding you back from real innovation?

In this episode, Stefan & Jens break down the pros and cons of following your competition’s playbook.

💡 What You’ll Learn

When copying competitors make sense (and when it doesn't)

The risk of following trends vs. building something original

How to analyze competitors without losing your unique edge

The Good Thing is...

Every engineering and business decision has trade-offs, and we're here to break them down.

Founder Mode vs. Founding Team & Is REST vs. GraphQL an Outdated Debate?

In this episode of The Good Thing, Stefan and Jens dive into two hot topics: Is “Founder Mode” scalable compared to a strong founding team? and Is the REST vs. GraphQL debate outdated?

We unpack the realities of scaling a startup beyond the “do-it-all” founder phase, the trade-offs of solo vision vs. a well-balanced team, and why many developers are still debating REST vs. GraphQL in 2025. Has the conversation moved past this comparison, and what’s next in API evolution?

Tune in for a raw, insightful, and slightly contrarian take on startups, tech, and what actually works.

👉 Subscribe and follow The Good Thing for more unfiltered discussions on APIs, GraphQL, and the startup grind.

In this episode of The Good Thing, Stefan and Jens dive deep into the inevitable journey of devtool companies transitioning into enterprise-focused giants. We discuss why almost every successful devtool company eventually targets enterprise customers, the unique challenges and opportunities that come with scaling to that level, and how funding strategies evolve as you grow.

Along the way, we share personal stories from building WunderGraph, reflecting on key lessons learned, trade-offs made, and unexpected discoveries. Whether you’re building a company or just curious about what it takes to scale a devtool to enterprise success, this episode offers practical advice, honest reflections, and, of course, a few laughs.

Join Stefan as he sits down with Dustin Deus, CTO and co-founder of WunderGraph, for a fun and insightful conversation about all things tech.

From scaling WunderGraph’s architecture to the challenges of building a next-generation platform for GraphQL Federation, Dustin shares his thoughts on technical decision-making, team collaboration, and innovation.

We’ll dive into trade-offs in software engineering, Dustin’s journey to becoming CTO, and how technical leadership evolves as a company scales. Expect plenty of “good things” and maybe a few behind-the-scenes stories from the WunderGraph team!

In this special episode, join Stefan & Jens as they walk through what it takes to survive a Super Bowl-level traffic spike.

“The Good Thing” is a podcast by Stefan and Jens, focusing on APIs, software development, GraphQL, and the trade-offs in engineering. Inspired by our startup journey at WunderGraph, The Good Thing comes from a phrase often used to find the positives in any situation, no matter the challenges. We also apply this phrase when building because any choice in engineering requires trade-offs.

With a casual chat format, the podcast dives into real-world challenges, lessons, and insights, blending humor and expertise. Special guests occasionally join the conversation to explore the ever-evolving world of software engineering.

“The Good Thing” is a podcast by Stefan and Jens, focusing on APIs, software development, GraphQL, and the trade-offs in engineering.

Inspired by our startup journey at WunderGraph, The Good Thing comes from a phrase we often use to find the positives in any situation, no matter the challenges. We also apply this phrase when building, because any choice in engineering requires trade-offs.

With a casual chat format, the podcast dives into real-world challenges, lessons, and insights, blending humor and expertise. Special guests occasionally join the conversation to explore the ever-evolving world of software engineering.