Inside the Stack

The Developer Advocate's Perspective: Code, Community & AI with Gbadebo Bello

Send us Fan Mail In this episode of Inside the Stack, we sit down with Gbadebo Bello, a Senior Developer Advocate at Postman and co-lead of API Conference Lagos. Gbadebo shares his ongoing journey from writing code to educating developers and managing tech communities on a global scale. We explore the distinct cultural differences between tech communities in Africa versus the rest of the world, the operational challenges of organizing large-scale developer conferences, and the strategic overlap between developer education and advocacy. We also discuss why foundational software engineering principles remain essential in the era of AI-assisted "vibe coding" and lay out a practical roadmap for engineers looking to transition into DevRel. Timeline 00:00 - Guest introduction and Gbadebo's background in developer communities. 03:45 - Transitioning from a full-time software engineer to a developer advocate. 10:21 - The strategic differences and overlaps between developer education and developer advocacy. 16:28 - Analyzing the cultural and economic differences between tech communities in Africa and worldwide. 22:24 - Why local tech communities struggle with continuity and retention. 28:40 - The hidden challenges of running API Conf Lagos and managing community volunteers. 36:47 - The critical role APIs continue to play within the AI and MCP ecosystem. 40:10 - Vibe coding vs. AI-assisted engineering: Why human code review and architectural knowledge still matter. 51:50 - How AI is shaping the future of the developer advocacy profession. 01:00:58 - A practical roadmap for software engineers wanting to get into developer advocacy. Find our guest's profile here: https://www.debo.codes/ Support the show

• Transcript

Breaking Down Developer Relations & Education with David Chuka | Inside the Stack

Send us Fan Mail In this episode of Inside the Stack, host Oluwole Majiyagbe sits down with developer educator David Chuka to explore the evolving landscape of developer relations and technical teaching. Chuka breaks down the fundamental differences between developer education and advocacy, emphasizing why a strong engineering background remains crucial for anyone looking to teach tech. The conversation tackles how AI tools and coding agents are drastically changing the way developers learn, reducing the immediate need to visit traditional documentation. However, they highlight that AI models still fundamentally rely on human-created tutorials, articles, and documentation to function properly. Chuka also shares his insights on structuring courses for mixed skill levels, the importance of curiosity and pattern recognition over just finishing capstone projects, and why modern coding platforms need to aggressively cut out unnecessary fluff. *Where to meet David Chuka* Twitter: @cnwadiogbu Instagram: @davidchuka.me TikTok: David Chuka Personal Website: davidchuka.me Like, Share and Subscribe if you're yet to Support the show

• Transcript

Building 75+ Startups: Why Most Software Fails (w/ Kevin Riedl)

Send us Fan Mail In this episode of Inside the Stack, Oluwole sits down with Kevin Riedl, founder of the AI-native software agency Wavect, who claims to have shipped over 75 products. They dive deep into the intersection of software engineering, product thinking, and building a tech company. Kevin shares critical lessons on why knowing "what not to build" is often more important than knowing how to build it. They also explore the realities of client work, managing scope creep, and how AI is fundamentally changing the discovery and development processes. Whether you are a solo developer prone to over-engineering or an entrepreneur trying to scale a fintech product, this session is packed with real-world engineering wisdom. Video Timestamps 00:00 - Intro & Kevin Riedl’s journey to founding Wavect 04:04 - Operating an AI-native software agency 06:45 - The #1 lesson from 75+ products: What not to build 09:54 - Translating client ideas into code and managing feature requests 16:50 - Handling scope creep and changing client requirements 21:24 - Designing scalable systems and real-world fintech challenges 26:25 - Dealing with wrong technical assumptions and heavy server load Support the show

• Transcript
• Chapters

UI/UX vs Frontend: The Developer Strikes Back | Pixel Vs Code Ep 3

Send us Fan Mail The UI/UX vs Frontend debate continues! In this episode, host Oluwole Majiyagbe flips the perspective and sits down with frontend expert Mr Gbadamosi Moshood to uncover what really happens when the design handoff is complete and the coding begins. We strip away the aesthetics and dive into the reality of building functional, performant interfaces. We discuss the most impossible designs developers are asked to build, why component libraries are sometimes necessary, and what frontend engineers genuinely wish UI/UX designers understood about the DOM. Whether you are a developer looking for validation or a designer wanting to make your team's life easier, this episode is packed with truth bombs! 👇 What we cover in this episode: 00:00 - Introduction 03:00 - When people hear "frontend," they think buttons and colors. What is it really? 03:53 - Why should a person go into Frontend? 05:20 - Is Frontend easy? 08:05 - Your app has to work on every phone, every browser, every screen size. What's the strangest bug you've had to fix because of that? 10:48 - is CSS hard or are we learning it the wrong way and what's the difference between CSS libraries? 14:40 - When you get a design to build, what do designers usually not realize about the work involved? 16:55 - Sometimes a design looks great but is really hard to build. When does that happen, and what do you do? 19:35 - Do you have to build the design exactly as given? When do you speak up and ask to change something? 22:42 - When there's a conflict in packages and design, do you communicate it back to the UI/UX? 24:47 - Design systems are meant to make life easier. Do they actually help you, or get in the way? 26:48 - When the design and what's easy to build don't match, who gets the final say? 29:28 - There's a new frontend tool every few months — React, Vue, Svelte, and on and on. Is that tiring, or a good thing? 33:06 - How do you know when a screen is actually finished/completed? 34:57 - Do you think UI/UX don't understand the amount of work you're to do to implement their designs? 35:48 - How do you tell if a frontend and/or design is complicated? 41:27 - AI can write frontend code now. What does that mean for frontend developers? 45:40 - Outro 🎙️ Guest: Moshood Gbadamosi Follow them on X/Twitter: [@morshudlhgmo] Github: https://github.com/morshud LinkedIn: https://www.linkedin.com/in/morshudlhgmo 🎙️ Host: Oluwole Majiyagbe Follow Inside the Stack on Instagram/Tiktok/Youtube: @insidethestack 💡 Don't forget to like, comment, and subscribe for more deep dives into the tech industry! Let us know in the comments: Frontend Devs, what is the most frustrating design element you constantly have to code? #Frontend #UIUX #WebDevelopment #SoftwareEngineering #TechPodcast #InsideTheStack #UIUXvsFrontend #ReactJS #TechCareer Support the show

• Transcript
• Chapters

Inside the Mind of a UI/UX Designer: Pixels vs Code Ep. 2

Send us Fan Mail Welcome back to Episode 2 of the UI/UX vs Frontend series! This time, host Oluwole Majiyagbe sits down with UI/UX expert Kehinde Faaruq Azeez to flip the script and dive deep into the creative process from the designer's perspective. What does it really take to craft a user experience that developers can actually build? We discuss the realities of the design handoff, the dreaded "pixel-perfect" myth, and how designers really feel when developers push back on their creative vision. Whether you are a designer trying to get your team on board, or a frontend dev trying to understand what your designer is thinking, this episode bridges the gap! 👇 What we cover in this episode: Intro: Welcome back to UI/UX vs Frontend! Meet Kehinde Faaruq Azeez & his journey in UI/UX The biggest mistakes developers make when looking at a Figma file Is "Pixel-Perfect" actually a myth? The most frustrating parts of the design handoff How designers and devs can finally speak the same language The ultimate UI/UX pet peeves (Note: Be sure to update these timestamps to match your final video edit!) 🎙️ Guest: Kehinde Faaruq Azeez Follow him on LinkedIn 🎙️ Host: Oluwole Majiyagbe Follow Inside the Stack on Tiktok/Instagram/Thread: @insidethestackpodcast 💡 Don't forget to like, comment, and subscribe for more tech deep dives! Let us know in the comments: Designers, what is the one thing you wish frontend developers understood about your job? #UIUX #Frontend #WebDevelopment #UXDesign #TechPodcast #InsideTheStack #UIUXvsFrontend #SoftwareEngineering #TechCareer Support the show

• Transcript

UI/UX vs. Frontend: Do We Actually Need Each Other? | Pixels vs Code

Send us Fan Mail In this episode of the Pixels vs Code series, host Oluwole Majiyagbe sits down with UI/UX expert Afuwape Abiodun to answer the provocative question: Do Designers and Frontend Developers actually need each other? We dive deep into the classic clash between "Designing Intent" and "Building Reality." We discuss the friction points, why handoffs can be so frustrating, and how having different skills but the same goal can either make or break a project. If you are a frontend dev tired of impossible designs, or a UI/UX designer tired of devs ruining your pixels, this episode is for you! 🎙️ Guest: Afuwape Abiodun Follow him on Instagram: @jega_jnr and on Behance/LinkedIn: Afuwape Abiodun 🎙️ Host: Oluwole Majiyagbe Follow Inside the Stack on Instagram/Thread: @insidethestackpodcast 💡 Don't forget to like, comment, and subscribe for more deep dives into the tech industry! Let us know in the comments: Are you Team Pixel or Team Code? #UIUX #Frontend #WebDevelopment #DesignVsCode #TechPodcast #InsideTheStack #SoftwareEngineering #TechCareer Support the show

• Transcript

AI Is Making Developers Lazy… Here’s How to Stay Dangerous

Send us Fan Mail AI is everywhere. From writing code… to debugging… to building full applications in minutes. But here’s the uncomfortable truth: A lot of developers are getting worse — not better. In this episode of Inside the Stack, we break down how to use AI as a superpower without losing your engineering foundations. Because the real danger isn’t AI replacing developers…It’s developers replacing their thinking with AI. 🚀 In this episode, you’ll learn: Why relying too much on AI can quietly destroy your growth The difference between AI-assisted developers and AI-dependent developers How to actually understand the code AI generates Practical ways to use AI without losing depth The mindset shift that separates real engineers from prompt merchants 💡 If you’re learning to code, building projects, or trying to become job-ready… This episode might change how you use AI forever. Support the show

• Transcript

The Developer Roadmap Nobody Explains Clearly (Avoid Wasting Years)

Send us Fan Mail Everyone says “learn to code”… but no one shows you the roadmap clearly. In this episode of Inside the Stack, we break down the real path from beginner to job-ready developer — without the confusion, without the fluff, and without wasting years jumping between random tutorials. If you’ve ever felt stuck, overwhelmed, or unsure what to learn next… this episode is for you. 🚀 What You’ll Learn: The 4-stage developer roadmap: Learn → Build → Share → Apply Why tutorials alone won’t get you hired How to build a portfolio that actually stands out The biggest mistake beginners make (and how to avoid it) How to use AI tools without losing your engineering foundation Whether you're just starting out or trying to level up, this episode gives you a clear, practical direction to grow as a developer. 🔔 Subscribe for more: Deep dives into systems, software engineering, and real-world tech journeys. 💬 Let’s connect: What stage are you currently in? Drop a comment 👇 Support the show

From Code to Customers: Building Quizboot

Send us Fan Mail What does it really take to turn an idea into a working product? In this episode of Inside the Stack, we sit down to unpack the journey behind Quizboot — from the very first spark of an idea to a live product used by real people. This isn’t just a success story… it’s an engineering story. We dive into: How the idea for Quizboot came about The early decisions that shaped the product Challenges faced during development and deployment What it takes to move from “it works on my laptop” to production Lessons learned from building and scaling a real-world application Whether you’re building your first side project or trying to ship your next big idea, this episode gives you a behind-the-scenes look at what the journey actually looks like — beyond tutorials and theory. 🎧 If you’ve ever wondered “Can I really build something people will use?” This episode is for you. Support the show

What Scaling Really Is: The Architecture Truth No One Talks About

Send us Fan Mail Scaling is one of the most misunderstood ideas in software engineering. It’s not about traffic. It’s not about going viral. And it’s definitely not about adding more servers. In this episode of Inside the Stack, Oluwole Majiyagbe breaks down what scaling really means — and why architecture, predictability, and system design matter more than traffic spikes. You don’t scale into good architecture. You scale from it. We talk about: Why traffic exposes problems instead of creating them The difference between scaling users and scaling complexity What breaks first in growing systems Why premature optimization is often a distraction If you're building software that needs to grow without collapsing under its own complexity, this episode is for you. Subscribe to Inside the Stack for system-level conversations without hype or buzzwords. #Scaling #SoftwareArchitecture #SystemDesign #BackendEngineering #InsideTheStack Support the show

What happens between Request and Response?

Send us Fan Mail You click a button… and something happens. Or at least, you hope something happens. That single click travels across networks, hits servers, wakes up databases, checks permissions, runs logic — and then makes a long journey back to your screen. But when nothing happens…you start wondering. Was it the internet? The backend? Or did the server just decide to rest? In this episode of Inside the Stack, we slow everything down and answer one simple question: What actually happens between a request and a response? We start from the very beginning — not with frameworks or buzzwords — but with the core idea that powers the entire web: computers talking to other computers. You’ll learn: What a request really is, and why nothing happens without one How clients and servers actually interact What’s inside a request: methods, paths, headers, and body Why GET and POST exist, and how to choose the right one What HTTP really is (without memorizing definitions) Why HTTP is stateless, and why headers matter so much What error codes like 404, 403, 400, and 500 are actually trying to tell you Where things usually break — and how to debug without guessing We use simple mental models, real-life analogies, and real system behavior to make sense of concepts that often feel confusing or “magical.” By the end of this episode: Requests and responses will stop feeling mysterious. Error codes will start pointing you in the right direction The web will feel predictable instead of fragile And you’ll have a solid foundation for building apps, APIs, and systems with confidence This is the first episode in the Web Fundamentals mini-series, and whether you’re a beginner, a designer, or a developer, this episode will help you finally understand what’s going on behind the scenes — from click to code. Subscribe to Inside the Stack for more episodes where we break systems down, layer by layer, until they actually make sense. Support the show

Introducing Inside the Stack

Send us Fan Mail Welcome to Inside the Stack — a podcast about how real software systems are built, scaled, and sustained. In this short introductory episode, your host Oluwole Majiyagbe shares the why behind the podcast, what “the stack” really means, and what you can expect from future episodes. This show isn’t about trends, buzzwords, or chasing the next shiny tool. It’s about: Understanding what actually happens inside software systems Breaking down architecture, APIs, and backend decisions Exploring scaling beyond traffic — people, processes, and complexity Learning from real-world engineering experiences, not theory alone If you’re a developer, engineer, or founder who wants to build better systems — and understand the trade-offs behind technical decisions — Inside the Stack is for you. New episodes drop regularly. 🎧 Subscribe and step inside the stack. Support the show