The Marco Show

Daniel Gräfe, founder of Timing and Cotypist, joins Marco to talk about the realities of indie software development after leaving Big Tech. They discuss turning side projects into a real business, risky rewrites, subscription pricing, and how AI fits into day-to-day coding and support.
Daniel shares lessons from more than a decade of building and maintaining Mac apps, including what worked, what didn’t, and why sustainability matters more than quick wins. A grounded conversation for developers thinking about indie SaaS, side projects, or life beyond a full-time engineering role.
💡 Topics in this episode:
Leaving Google to go indie

Side projects vs running a business

Rewriting a product from scratch

Subscription pricing decisions

B2B vs B2C tradeoffs

Using AI in everyday development

Long-term maintenance and sustainability

🕑 Timestamps:
(00:00) Intro
(04:08) Timing, CoTypist, and Daniel’s background
(05:30) Early side projects and first Mac apps
(13:16) Getting into Google
(20:02) Promotion, performance, Big Tech reality
(27:33) Quitting Google and going indie
(28:27) Rewriting Timing from scratch
(37:52) Launch day, sales, and burnout
(46:37) Subscriptions and pricing decisions
(54:13) Using AI for coding and support
(01:03:34) Advice for aspiring indie developers
(01:12:10) Agency vs intelligence
(01:13:22) Giveaway + outro

New episodes every other Wednesday. Subscribe for more developer-focused conversations.
🎥 Watch the full episode on YouTube: https://youtu.be/t4DkaadHLnI

J. B. Rainsberger, TDD coach and software consultant, joins Marco to challenge common assumptions about software testing. They discuss why JB argues that “integrated tests are a scam,” how testing choices affect design and refactoring, and what teams get wrong when they rely too heavily on end-to-end tests. The conversation draws on decades of real-world experience working with development teams of all sizes.
💡 Topics in this episode:
What “integrated tests” really are and why they cause problems

Micro tests, fast feedback, and confidence-driven testing

When deleting tests is the right decision

How tests create pressure on system design

Collaboration and contract tests explained

Why there is no single testing best practice

Practical advice for junior and senior developers

New episodes every other Wednesday. Subscribe for more developer-focused conversations.

⏰ Timestamps:
(00:00) Teaser
(01:24) Intro
(02:44) How J. B. got into testing
(06:12) What “integrated tests” actually mean
(10:42) Stop asking “what’s the right test size?”
(13:22) Removing irrelevant details from tests
(15:30) Refactoring, coupling, and deleting tests
(18:08) “There’s no best practice.”
(23:52) Old TDD books and timeless ideas
(26:01) Collaboration and contract tests explained
(33:53) “99.5% of your tests can be micro tests”
(46:21) Do you want to be right or solve the problem?
(01:00:48) Advice for junior developers
(01:19:32) Testing strategy distilled
(01:23:58) Manual QA testing
(01:29:44) Giveaway
(01:33:15) Rapid fire and outro

🎥 Watch the full episode on YouTube: https://youtu.be/j0NjFsb-at8

The first season of The Marco Show has officially come to an end! In this Christmas special episode, we’re announcing all of our giveaway winners and wrapping up the season with a fun Q&A with Marco.
🎁 Giveaway winners:
If you’re one of the winners featured in this episode, please reach out to us at [email protected] and let us know what you’d prefer: a 1-year license to one of our JetBrains products, or a coupon for the JetBrains merch store.
Timestamps:
(00:00) Season Finale Intro & What to Expect
(00:34) LLMs with Jodie Burchell: giveaway winner
(01:08) Software performance with Casey: giveaway winner
(01:39) Hibernate with Gavin King: giveaway winner
(02:15) Flyway with Axel Fontaine: giveaway winner
(02:45) SQL with Torben: giveaway winner
(03:16) Quarkus with Kevin Dubois: giveaway winner
(03:46) Jetty with Ludovic: giveaway winner
(04:18) ByteBuddy with Rafael: giveaway winner
(04:52) How to claim your prize
(05:08) Q&A with Marco
(09:35) Outro and meet the team

Thank you to everyone who watched, listened, and supported the show this season. We truly appreciate it. See you next year!
New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/hZemYWNKa6I

Rafael Winterhalter, creator of ByteBuddy and long-time Java consultant, joins Marco to break down the hidden world of JVM bytecode instrumentation. They discuss how ByteBuddy powers tools like Mockito and Hibernate, why legacy Java still dominates enterprise systems, and what it’s really like maintaining a massive open-source project as a single developer.
💡 Topics in this episode:
How ByteBuddy works and why frameworks rely on it

JVM bugs, JIT issues, and surprises from instrumentation

Supporting legacy Java (5, 6, 8…) in modern environments

Open-source sustainability and avoiding burnout

Java modules, unsafe, and evolving with new JDK releases

Rethinking Java build tools and software engineering complexity

🕑 Timestamps:
(00:00) Intro
(01:10) Rafael’s background & the origin of ByteBuddy
(03:00) What ByteBuddy does and why it matters
(04:32) Replacing CGLIB and early challenges
(07:05) ByteBuddy’s design philosophy
(09:15) Mockito, Hibernate and real-world adoption
(13:14) Open source reality
(15:48) Performance myths and JVM behavior
(18:47) JVM bugs, JIT issues and instrumentation pitfalls
(21:11) Supporting legacy Java in enterprise
(23:56) Testing ByteBuddy across many JDKs
(25:53) Why companies still run Java 5/6
(28:25) Engineering vs economics
(30:39) Modules, unsafe and evolving with Java
(36:12) Maintaining a one-person project
(39:31) Conferences and developer evangelism
(42:02) Consulting vs product engineering
(49:51) Burnout and sustainability
(52:02) Thoughts on AI in software development
(57:13) Rethinking Java build tools
(01:05:07) Build security and dependency risks
(01:10:16) Giveaway
(01:10:48) Rapid fire and outro

New episodes every other Wednesday. Subscribe for more developer-focused conversations.
🎥 Watch the full episode on YouTube: https://youtu.be/AzfhxgkBL9s

Episode description:
Ludovic Orban (Jetty Maintainer and Performance Engineer at WebTide) joins Marco to break down what “web scale” really means, why most systems don’t need Google-level architecture, and how modern Java servers achieve massive throughput. From Jetty’s design philosophy to multi-core CPU realities, distributed transactions, Terracotta’s wild JVM clustering experiments, and the limits of AI-generated code, this episode dives deep into how high-performance Java is built today.
💡 In this episode:
What “web scale” actually means for real-world systems

Jetty vs Tomcat and how Jetty became a fast, modern web server

CPU evolution, memory bottlenecks, and multi-core performance

Distributed transactions, XA pitfalls, and compensating patterns

Terracotta’s clustered JVM: engineering lessons and war stories

Why developers struggle with performance (and how to learn it)

AI, coding assistance, and why Ludovic doesn’t trust generated code

⏱️ Timestamps:
(00:00) Teaser
(01:10) Who is Ludovic Orban?
(02:04) What “web scale” really means, and who actually needs it
(03:54) How hardware changes reshaped software performance
(06:28) Cloud, containers, and why performance still matters
(07:28) Jetty vs Tomcat: history, adoption & performance
(10:47) What makes Jetty “fast” in practice
(13:21) How the Jetty team prioritizes performance
(15:10) Recent work: fixing complex HTTP/2 bugs
(16:38) How WebTide supports customers beyond Jetty issues
(17:52) Bitronix: Why Ludovic built his own transaction manager
(20:45) Open-source challenges. The rise and fall of Bitronix
(24:19) Distributed transactions vs compensating transactions
(27:07) Where to learn more: Atomikos and modern approaches
(28:25) Terracotta: clustering JVMs and wild engineering stories
(31:20) What Terracotta taught him about the JVM
(33:48) Real-world Java performance mistakes developers make
(40:22) Why learning performance is so hard
(45:40) Kubernetes, abstraction, and performance visibility
(48:50) Hardware that excites Ludovic: Oxide Computer
(50:42) His take on AI and why he doesn’t trust generated code
(53:30) Lessons from Jetty, Terracotta, Bitronix, and Quartz
(56:10) Rapid-fire questions
(01:01:15) Giveaway and outro

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.
🎥 Watch the full episode on YouTube: https://youtu.be/fJvg5zTKHeE