MicroFrontends at Scale with Florian Rappl | The Art of Modular Architecture

What if you could build web applications where teams could deploy independently without breaking each other's code? In this episode, we sit down with Florian Rappl—author of "The Art of Micro Frontends," creator of the Piral framework, and Microsoft MVP—to explore how micro frontends are transforming how we build scalable web applications.

Florian shares hard-won lessons from over a decade of building distributed systems, from smart home platforms to enterprise portals for some of Germany's largest companies. We dive deep into the philosophy behind Piral, why modular architecture isn't just about using multiple frameworks, and how micro frontends might be the key to unlocking AI-powered development workflows.

🔸 Key Topics Discussed:

- The evolution from monolithic frontends to true modular architecture

- Why loose coupling is more important than multi-framework support

- How Piral solves the orchestration problem that Module Federation doesn't

- The "inverse dependency" pattern that makes micro frontends resilient

- Building enterprise portals that scale across hundreds of teams

- Server-side rendering and SEO challenges in micro frontend architectures

- Why Cloudflare Workers and edge computing are game-changers for MFEs

- The future of AI-assisted development in modular codebases

- Lessons learned from smart home systems, customer portals, and production deployments

Whether you're an architect evaluating micro frontends for your organization or a developer curious about modular patterns that actually work in production, this conversation offers battle-tested insights you won't find in the documentation.

⏱️ Chapters:

00:00 - Introduction & Welcome

01:31 - The Origin Story of Piral

04:30 - The Micro Frontend Landscape in 2019

08:05 - Piral vs Module Federation: Understanding the Difference

12:15 - The Inverse Dependency Pattern

18:20 - Building Enterprise Portals at Scale

25:40 - Server-Side Rendering & SEO Challenges

35:10 - Cloudflare Workers & Edge Computing for Micro Frontends

45:25 - Cross-Framework Components & the Converter API

52:30 - Discovery Services & Dynamic Module Loading

58:15 - AI-Assisted Development & Modular Architecture

1:04:01 - Book Recommendations

📚 Resources Mentioned:

- Piral Framework: https://piral.io

- The Art of Micro Frontends (2nd Edition) by Florian Rappl

- Building Micro-Frontends (2nd Edition) by Luca Mezzalira

- Physics of the Future by Michio Kaku

- Release It! by Michael T. Nygard

- Continuous Delivery by Jez Humble & David Farley

🔗 Follow Florian:

- LinkedIn: [Add Florian's LinkedIn]

- Twitter/X: [Add Florian's Twitter]

- GitHub: [Add Florian's GitHub]

🎙️ Follow & Subscribe:

📸 Instagram: https://www.instagram.com/senorsatscale/

📸 Instagram: https://www.instagram.com/neciudev

🎙 Podcast: https://neciudan.dev/senors-at-scale

📬 Newsletter: https://neciudan.dev/subscribe

💼 LinkedIn: https://www.linkedin.com/in/neciudan

💼 LinkedIn: https://www.linkedin.com/company/señors-scale/

#MicroFrontends #WebDevelopment #SoftwareArchitecture #Piral #ModuleFederation #ScalingSoftware #EnterpriseArchitecture #JavaScript #React #DevOps

💬 What's your experience with micro frontends? Have you tried Piral or other frameworks? Let us know in the comments!

---

Señors @ Scale is a podcast exploring the technical decisions, architectural patterns, and scaling strategies that power modern software systems. Each episode features deep conversations with engineers, architects, and technical leaders building software that serves millions.

In this episode of Señors @ Scale, Dan sits down with Daniel Roe, leader of the Nuxt Core team at Vercel, for an in-depth conversation about building and scaling with Nuxt, Vue's most powerful meta-framework.

Daniel shares his journey from the Laravel world into Vue and Nuxt, revealing how he went from being a user to becoming the lead maintainer of one of the most important frameworks in the JavaScript ecosystem. We explore the evolution of Nuxt, the philosophy behind its developer experience, and how understanding user pain points shapes every feature decision.

The conversation dives deep into the technical aspects that matter when building at scale: rendering strategies and when to choose static over server-side rendering, the revolutionary Nitro server engine and how it transforms backend flexibility, data fetching patterns and best practices for performance, and the module ecosystem that empowers developers to extend Nuxt in powerful ways.

Daniel explains why "always go for static rendering if you can" isn't just advice — it's a performance philosophy. He breaks down how Nuxt makes it easier to be your own target audience as a framework developer, and why contributing to open source is ultimately about joy and giving back to the community.

Whether you're building with Nuxt, considering it for your next project, or just curious about how modern frameworks are designed with developer experience at their core, this episode offers invaluable insights from someone shaping the future of Vue development.

Chapters

00:00 Introduction and Daniel's Background

03:45 From Laravel to Vue and Nuxt

08:20 Becoming a Nuxt Core Team Member

12:30 The Evolution of Nuxt and Developer Experience

18:15 Understanding User Pain Points

24:00 Rendering Strategies: Static vs Server-Side

29:45 The Nitro Server Engine Revolution

35:20 Data Fetching Best Practices

41:10 The Power of Nuxt Modules

46:30 Contributing to Open Source

51:00 The Future of Nuxt

53:52 Outro

Follow & Subscribe:

📸 Instagram: https://www.instagram.com/senorsatscale/

📸 Instagram: https://www.instagram.com/neciudev

🎙 Podcast URL: https://neciudan.dev/senors-at-scale

📬 Newsletter: https://neciudan.dev/subscribe

💼 LinkedIn: https://www.linkedin.com/in/neciudan

💼 LinkedIn: https://www.linkedin.com/company/señors-scale/

Additional Resources

🌐 Nuxt: https://nuxt.com

💬 Daniel Roe on GitHub: https://github.com/danielroe

🚀 Vercel: https://vercel.com

#nuxt #vue #javascript #webdevelopment #frontend #serverless #nitro #vercel #opensource #developerexperience #señorsatscale

Don't forget to like, comment, and subscribe for more engineering stories from the front lines.

How is your team using Nuxt or Vue to scale? Share below 👇

In this episode of Señors @ Scale, Dan sits down with Vlad Kononov, software architect, keynote speaker, and author of Learning Domain-Driven Design and Balancing Coupling in Software Design.

Vlad has spent more than twenty years helping teams untangle legacy systems, rebuild failing architectures, and bring clarity to messy business domains. His work spans greenfield systems, enterprise refactors, and the ambiguous environments where most real software actually lives.

This conversation cuts through the hype around DDD and microservices, focusing on the mechanics of bounded contexts, coupling, business alignment, and architectural evolution. We talk about why ubiquitous language reduces project failure, how bounded contexts emerge from social structures rather than diagrams, why most teams misuse aggregates, and how to spot “pain signatures” inside a system and trace them back to unclear domain boundaries. Vlad explains how subdomains evolve over time, how good designs quietly become counterproductive, and how accidental complexity appears at every layer of a system.

We also dig into the real model behind coupling—strength, distance, and volatility—and how teams can use it to design systems that stay adaptable under pressure. Vlad breaks down why many microservice rewrites fail, when DDD actually makes sense, and why refactoring should start with understanding the business rather than carving out services at random.

The episode ends with a discussion about AI and architecture, and how LLMs make domain-driven design more important rather than less. Vlad explains why clear domain vocabulary and modular boundaries help both engineers and AI reason about a system without being overwhelmed by complexity.

If you’re building complex systems, leading platform or architecture teams, or struggling with a legacy codebase that keeps pushing back, this episode offers a practical, experience-driven guide to designing systems that scale with the business.

Chapters

00:00 Intro and Vlad’s Background
01:42 Why DDD Was Written and Who It Was For
04:02 When Aggregates Finally Made Sense
05:42 Ubiquitous Language as the Core of DDD
07:31 Why Software Projects Fail
08:52 The Biggest Misconception About DDD
10:13 Common Anti-Patterns in Domain Design
12:12 Greenfield vs Brownfield DDD
14:03 How to Begin Refactoring a Monolith
15:25 Mapping Subdomains: Core, Supporting, Generic
19:25 When Companies Do DDD Without Knowing
20:39 When DDD Fails and Lessons Learned
22:41 Why Defining Boundaries Is Hard
25:56 Accidental Complexity in Large Systems
27:32 Microservices, Myths, and Pain
30:29 What Coupling Really Means
33:17 Strength, Distance, and Volatility
39:07 How Vlad Documents Architecture
41:37 Event Storming as the Source of Truth
44:01 How AI Changes System Design
48:28 How to Enforce Ubiquitous Language
51:00 Book Recommendations
53:33 Closing Thoughts

Follow and Subscribe:
Instagram: https://www.instagram.com/senorsatscale/
Instagram: https://www.instagram.com/neciudev
Podcast: https://neciudan.dev/senors-at-scale
Newsletter: https://neciudan.dev/subscribe
LinkedIn: https://www.linkedin.com/in/neciudan
LinkedIn: https://www.linkedin.com/company/se%C3%B1ors-scale/

In this episode of Señors @ Scale, Dan sits down with Bramus Van Damme, Chrome Developer Relations Engineer at Google, and one of the driving forces behind View Transitions, Scroll-Driven Animations, Anchor Positioning, and CSS Custom Functions.Bramus brings a rare perspective from inside the browser engine itself. From helping shape CSS specs at the standards level to building the demos and tooling that developers rely on every day, he has a front-row seat to how modern UI engineering is evolving.We go deep into how the new CSS works in practice — beyond the marketing, straight into the mechanics of performance, rendering, and real-world API design.We break down how these capabilities actually work:How View Transitions calculate DOM deltas and morph shared elements across pages,How Scroll-Driven Animations run on the compositor instead of the main thread,How Anchor Positioning finally fixes popovers, tooltips, and dropdowns without JavaScript,and how CSS Custom Functions and Mixins push the language closer to a full programming environment.Bramus also explains the browser-internals most teams never see — interop, working with the CSS Working Group, and the engineering cost behind features that take 5 to 10 years to land across engines.The conversation goes beyond features into the realities of framework timing, React’s virtual DOM, when animations fall back to the main thread, and why modern CSS is becoming the foundation for UI systems at scale.If you’re building modern frontends, maintaining a design system, or leading platform engineering for UI, this episode is a masterclass in what the next generation of the web actually looks like.Chapters00:00 The Journey into Web Development01:02 Best Practices for View Transitions07:46 What Chrome DevRel Actually Does10:33 How Browser Features Get Prioritized13:38 Why Styling Forms Has Been Broken for Years17:18 Inside View Transitions and Cross-Document Animations22:11 Motion, Accessibility, and Reducing Overuse23:44 Integrating Browser Features with React, Vue, and Frameworks27:46 The Popover API and Pattern-Driven Standards30:48 How React and Chrome Collaborated on View Transitions31:46 The State of Scroll-Driven Animations34:25 Triggered Animations and What’s Coming Next35:50 Why JS Scroll Handlers Cause Jank37:17 GPU-Accelerated vs Main-Thread Animations40:10 The Coolest Demo: Scroll-Driven View Transitions44:24 Anchor Positioning and De-JSifying UI Patterns48:23 Developer Feedback, Interop, and Spec Evolution51:19 Custom Functions and the Future of CSS as a Language54:58 Mixins, Preprocessors, and Platform Evolution56:43 Books, Blogs, and Where Bramus Learns58:11 Closing Thoughts and Call for FeedbackFollow & Subscribe:📸 Instagram: https://www.instagram.com/senorsatscale/📸 Instagram: https://www.instagram.com/neciudev🎙 Podcast URL: https://neciudan.dev/senors-at-scale📬 Newsletter: https://neciudan.dev/subscribe💼 LinkedIn: https://www.linkedin.com/in/neciudan💼 LinkedIn: https://www.linkedin.com/company/se%C3%B1ors-scale/Additional Resources🌐 Bramus’ Blog: https://www.bram.us🌐 View Transitions Demos: https://view-transitions.chrome.dev🌐 Scroll-Driven Animations Course: https://scroll-driven-animations.style/🌐 Anchor-Tool by Una: https://anchor-tool.com#css #webdevelopment #frontend #javascript #chrome #softwareengineering #uiux #devtools #animations #react #performance #softwarearchitecture #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines.

In this episode of Señors @ Scale, Dan sits down with Liran Tal, Director of Developer Advocacy at Snyk, GitHub Star, and one of the most influential voices in modern application security. Liran has spent decades at the intersection of open-source ecosystems, Node.js, supply chain security, and now AI agent security, helping developers ship fast without exposing themselves to silent, catastrophic risks.

He breaks down the real stories behind today’s security landscape — from NPM malware and maintainer compromises to MCP attacks, toxic flows, and the hidden vulnerabilities emerging from AI-driven development.

We dig into what “security at scale” actually means: how attackers compromise maintainers and publish worm-style malware, how invisible Unicode payloads bypass human review, why AI-generated code is statistically insecure, and how developers can build guardrails directly into their workflows with tools like Snyk, NPQ, and MCP scanning.

Liran also reveals the problems teams consistently underestimate — developer ergonomics, dependency trust, package governance, CI risk, and why blindly upgrading dependencies is one of the most dangerous patterns in modern engineering.

The conversation goes far beyond theory — into secure coding, package hygiene, NPM ecosystem fragility, MCP prompt injection, SQL and command injection patterns, and what real-world breaches teach us about resilience.

If you build software, install dependencies, or use AI coding agents, this episode is a masterclass in defensive engineering, supply chain awareness, and the new security realities shaping our industry.

Chapters
00:00 Security at Scale – Why It Matters Now
02:14 How Liran Got Into Security
05:12 The Shift Toward Developer-Led Security
08:33 How Snyk Changed the Developer Security Workflow
11:07 The Story Behind NPQ and Safer Dependency Installation
14:02 The Rise of NPM Malware and Maintainer Compromise
16:48 Why Blind Upgrade Everything Pipelines Are Dangerous
19:15 Is Node the Problem or Is It NPM
21:10 The Hidden Risk of MCPs and AI Agent Vulnerabilities
24:18 Toxic Flows, Shadowed Tools, and Prompt Injection
27:22 AI Browsers, Extensions, and Real Prompt Injection Attacks
30:04 Why Prompt Injection Has No True Fix
33:01 AI-Generated Code Is Statistically Insecure
35:12 How Snyk Plus MCP Creates a Secure Coding Loop
37:40 The Most Common MCP Vulnerabilities
40:55 How AI Agents Turn Mild Bugs Into Critical RCE
43:11 The Glassworm Invisible Unicode Attack Vector
44:51 EventStream, XZ Utils, and Supply Chain Horror Stories
48:03 Liran’s Personal Security Incidents
51:10 UX vs Security and Real World Tension
53:04 Liran’s Book Recommendations
55:37 Final Thoughts and Protecting Yourself as AI Evolves

Sound Bites
"Security at scale is a complex challenge."
"AI-generated code is not always secure."
"Security and UX must work together."

Follow & Subscribe:
Instagram: https://www.instagram.com/senorsatscale/
Instagram: https://www.instagram.com/neciudev
Podcast URL: https://neciudan.dev/senors-at-scale
Newsletter: https://neciudan.dev/subscribe
LinkedIn: https://www.linkedin.com/in/neciudan
LinkedIn: https://www.linkedin.com/company/señors-scale/

Additional Resources
Snyk – developer-first security tools
Serverless Security (O’Reilly) – co-authored by Liran
Liran’s GitHub: https://github.com/lirantal
NPQ package checker: https://github.com/lirantal/npq
MCP Scan (Snyk) – securing MCP servers

#security #softwaresecurity #supplychainsecurity #npm

Don’t forget to like, comment, and subscribe for more engineering stories from the front lines.

How are you protecting your stack from supply chain attacks? Share below 👇

In this episode of Señors @ Scale, Dan sits down with Luca Mezzalira, Principal Serverless Specialist at AWS and author of Building Micro-Frontends, for a deep and highly practical look at scaling frontend architectures for hundreds of developers.

Luca shares the real story behind how micro-frontends were born — from his early experiments at DAZN trying to scale a live sports platform across 40 devices and 500+ engineers, to pioneering techniques that cut app startup times from 40 seconds to 12.

We break down how distributed frontends actually work:
How to design stable application shells with zero global state,
How to compose independently deployed views without iframes, and how guardrails like bundle-size budgets and canary deployments keep massive systems fast and safe.

Luca also explains the hidden challenges most teams miss — governance, team topology, and socio-technical design.
He shows how to evolve from a monolith to micro-frontends step by step, using edge routing, feature flags, and domain-driven design to scale safely without rewrites.

The conversation goes beyond theory — into the mechanics of migration, platform teams, CI/CD pipelines, and why friction in your system is actually a signal, not a failure.

If you’re leading a frontend platform, planning a migration, or just trying to make sense of where micro-frontends actually fit, this episode is a masterclass in autonomy, architecture, and evolution at scale.

Chapters
00:00 The Origin of Micro-Frontends at DAZN05:41 Building a Distributed Frontend Without iFrames08:50 Designing the Application Shell and Stateless Architecture12:23 Zero Global State and Memory Management15:53 Guardrails for Bundle Size and Developer Discipline17:39 Governance and Designing for Scale20:18 When (and When Not) to Adopt Micro-Frontends22:46 Canary Releases and Edge Routing for Safe Migration25:49 Vertical vs Horizontal Splits in Micro-Frontends31:30 Lessons from Building the First Edition of the Book35:38 Frameworks, Federation, and Modern Tools39:22 Core Principles of Successful Frontend Architecture42:06 Building Platform Teams and Core Governance44:19 When Micro-Frontends Don’t Make Sense47:50 Micro-Frontends for Small Teams and Startups49:32 Monorepo vs Polyrepo – What Actually Matters53:10 Preventing Duplication and Encouraging Communication57:39 Why a Design System Is Non-Negotiable59:17 Common Anti-Patterns in Micro-Frontend Architecture

1:03:33 Book Recommendations and Final Thoughts

Follow & Subscribe:
📸 Instagram: https://www.instagram.com/senorsatscale/
📸 Instagram: https://www.instagram.com/neciudev
🎙 Podcast: https://neciudan.dev/senors-at-scale
📬 Newsletter: https://neciudan.dev/subscribe
💼 LinkedIn: https://www.linkedin.com/in/neciudan
💼 LinkedIn: https://www.linkedin.com/company/se%C3%B1ors-scale/

Additional Resources

📘 Building Micro-Frontends – Luca Mezzalira (O’Reilly) buildingmicrofrontends.com

🌐 buildingmfe.com

💬 Luca’s Blog: https://lucamezzalira.com

#microfrontends #aws #frontendarchitecture #javascript #webdevelopment #softwareengineering #softwarearchitecture #react #scaling #teamtopologies #serverless #señorsatscale

Don’t forget to like, comment, and subscribe for more engineering stories from the front lines.

How is your team approaching frontend scaling and independence? Share below 👇

🎙 About the Podcast:

Join host Neciu Dan as he sits down with Stefano Magni, a senior front-end engineer and tech lead at Preply, to explore the intricacies of building a robust design system and the journey of working in public.

Stefano shares his insights on the importance of skills, reputation, and networking in shaping a successful career. Discover how his experiences from building Flash mini-games to architecting React-based systems have influenced his approach to engineering excellence.

In this episode, they discuss:

The pivotal moment that led Stefano to work in public

How Preply's design system impacts user experience

The balance between perfectionism and pragmatism in engineering

The role of data-driven decisions in Preply's culture

Best practices for managing large codebases without tests

Stefano also shares his journey from a Flash developer to a leader in the design system space, emphasizing the value of sharing knowledge and building a strong professional network.

Chapters:

00:00 Introduction to Stefano Magni and Preply

05:12 The Importance of Public Work

12:45 Building a Design System at Preply

18:30 Balancing Perfectionism and Pragmatism

25:00 Data-Driven Culture at Preply

32:15 Managing Large Codebases Without Tests

40:00 The Journey from Flash to React

47:30 Networking and Reputation in Tech

55:00 Closing Thoughts and Future Plans

📚Links & Resources:

📸 Instagram: https://www.instagram.com/senorsatscale/📸 Instagram: https://www.instagram.com/neciudev🎙 Podcast URL: https://neciudan.dev/senors-at-scale📬 Newsletter: https://neciudan.dev/subscribe💼 LinkedIn: https://www.linkedin.com/in/neciudan💼 LinkedIn: https://www.linkedin.com/company/se%C3%B1ors-scale/

#designsystem #frontend #engineeringexcellence #preply #networking #publicwork #softwaredevelopment #señorsatscale

Don’t forget to like, comment, and subscribe for more engineering stories from the front lines. How is your team approaching design systems and public work? Share below 👇