Señors at Scale - Software Engineering & Tech Leadership

What does engineering at Meta actually look like from the inside? Spoiler: almost nothing you know from outside applies.In this episode, Dan sits down with Evyatar Alush, Software Engineer at Meta in Tel Aviv and the creator of EmojiPicker React (600K+ weekly downloads) and Vest. Evyatar's journey is one of the most unusual on the show: no degree, no high school diploma, learned JavaScript on Code Academy during military night shifts in a server room, then talked his way into Fiverr, scaled to Front End Platform Lead, and got recruited into Facebook in 2019.We get into what it's actually like inside Meta's frontend infrastructure: Hack instead of PHP, Flow instead of TypeScript, Relay instead of Apollo, Sapling instead of Git, stacked diffs instead of pull requests, and a custom everything (testing frameworks, ORMs, dev servers, data centers). We also cover his open source philosophy, why he builds his own libraries instead of pulling dependencies, the supply chain risks of modern npm, and how AI-assisted code is reshaping open source maintainer work.Key Topics:- Learning to code on military night shifts with zero CS background- Joining Fiverr with one year of experience and bluffing through the interview- Building Fiverr's notification system, in-app inbox, and toast library- Creating EmojiPicker React from a Fiverr internal tool- The "Unmask" manifesto and starting Fiverr's frontend infrastructure team- Designing the Front Ants team by faking the trappings of a real team- Building micro-frontends that bridge a Ruby on Rails monolith and React- Saying no to Facebook on the first email- Interviewing at Meta in London (and the Dan Abramov interview)- The Calibra/Diem crypto wallet team during COVID- Hack vs PHP, Flow vs TypeScript, Relay vs Apollo, Sapling vs Git- Stacked diffs and why ex-Meta engineers miss them- Why "move fast and break things" is dead at Meta- Code review, dev mod servers, and end-to-end testing at scale- Open source maintenance in the AI era and Cursor-generated PRs- Why he owns the "context" package on npmGUEST: Evyatar Alush💼 LinkedIn: https://www.linkedin.com/in/evyataralush-5b760866🐙 GitHub: https://github.com/ealush🌐 EmojiPicker React: https://github.com/ealush/emoji-picker-react🌐 Vest: https://vestjs.devFOLLOW & 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/senors-scale/ADDITIONAL RESOURCES- EmojiPicker React: https://www.npmjs.com/package/emoji-picker-react- Vest (form validation): https://vestjs.dev- Sapling (Meta's source control): https://sapling-scm.com- The Hack language: https://hacklang.org- Flow: https://flow.org- Relay: https://relay.dev- The Design of Everyday Things by Don Norman- Never Split the Difference by Chris Voss#Meta #Facebook #Frontend #ReactJS #HackLang #Flow #Relay #Sapling #StackedDiffs #OpenSource #EmojiPickerReact #Vest #SoftwareEngineering #SenorsAtScale💬 What's your take on Meta's "everything in-house" engineering culture? Would you rather work with familiar tools or relearn engineering from scratch for better internal infrastructure?

What does it actually take to build production React Native apps in 2026, and where does Expo fit in?In this episode of Señors at Scale, Dan sits down with Kadi Kraman, software developer at Expo, who has spent over six years in the React Native ecosystem, wearing every hat from IC to director. Kadi shares the story of how she went from writing C++ in a maths degree to becoming one of the early React Native engineers at Formidable, and eventually joining Expo to work on the platform itself.We dig into what makes React Native genuinely competitive with native iOS and Android development today, why Expo Go is now just for prototyping, how EAS workflows and fingerprint-based repacks dramatically speed up CI, the real story on OTA updates (and where the legal gray area sits), and what's still missing from the ecosystem. Kadi also gives a rare look at the new Expo agent for vibe-coding mobile apps, the case for React Native brownfield, and her honest take on Lynx as competition.Key Topics:- Why React Native + Expo is faster than native Xcode/Android Studio workflows- The mental shift from web to native (display points, gestures, pixel density)- Expo Go vs development builds, and why the recommendation has changed- EAS workflows, repack jobs, and project fingerprints- React Native performance, list rendering, and the React Compiler- OTA updates: when to use them, when not to, and what the stores actually allow- Debugging strategies (expo-doctor, native logs, AI-assisted log analysis)- Brownfield React Native and embedding RN screens into existing native apps- Lynx, competition, and the future of cross-platform mobile- Career advice on imposter syndrome, applying anyway, and finding talk topicsGUEST: Kadi Kraman, Software Developer at Expo💼 LinkedIn: https://www.linkedin.com/in/kadikraman/🐦 Twitter/X: https://x.com/kadikraman🐙 GitHub: https://github.com/kadikraman🌐 Website: https://kadikraman.com/FOLLOW & SUBSCRIBE🎙️ Podcast: https://neciudan.dev/senors-at-scale📩 Newsletter: https://neciudan.dev/subscribe💼 LinkedIn (Show): https://www.linkedin.com/company/senors-scale/💼 LinkedIn (Dan): https://www.linkedin.com/in/neciudan📸 Instagram (Show): https://www.instagram.com/senorsatscale/📸 Instagram (Dan): https://www.instagram.com/neciudevADDITIONAL RESOURCES- Expo: https://expo.dev/- Kadi's "From Web to Native with React" blog post: https://expo.dev/blog- EAS Workflows: https://docs.expo.dev/eas-workflows/get-started/- Expo Doctor: https://docs.expo.dev/more/expo-cli/#expo-doctor- Expo Fetch (streaming support): https://docs.expo.dev/versions/latest/sdk/expo/#ReactNative #Expo #MobileDevelopment #JavaScript #iOS #Android #EAS #ExpoRouter #SoftwareEngineering #SeñorsAtScale💬 What's your biggest pain point building React Native apps today, and have EAS workflows changed your CI setup?

Can you really run state-of-the-art machine learning models directly in the browser, with no server, no API calls, and full privacy by default?In this episode, Nico Martin, Open Source Machine Learning Engineer at Hugging Face and Google Developer Expert in AI and Web Technologies, walks through how Transformers.js makes on-device AI a reality. Nico's journey is anything but conventional. He started as a ski and windsurf instructor, taught himself web development on the side, spent years as a freelancer (including five at a bank building e-banking front ends), and recently landed what he calls his dream job at Hugging Face.We unpack what Hugging Face actually is (the GitHub for machine learning), how Transformers.js brings the Python Transformers API to the browser, and the real engineering challenges of running models on whatever hardware your users happen to have. Nico explains quantization, ONNX as the standard for portable model architectures, the role of tokenizers, how text becomes tensors, and why WebGPU matters for running larger models client-side.We also dig into the bigger picture: privacy-preserving AI, the difference between open weights and truly open source models, agents and MCP, and what front-end developers should actually learn to stay relevant in an AI-first world.Key Topics:- What Hugging Face is and the role of the Hub, Transformers, and Diffusers- Transformers.js: bringing Python Transformers API to JavaScript and the browser- The biggest challenge of browser ML: running on unknown client hardware- Quantization explained (Q4, 4-bit vs 16/32-bit) and how it compresses models- ONNX and ONNX Runtime Web: the standard for portable model architectures- Open weights vs open source models and why the distinction matters- Tokenizers, token IDs, and why each model needs its own tokenizer- From text to tensors: pre-processing, inference, and post-processing- Text embeddings explained through a simple animal feature analogy- WebGPU and what it unlocks for in-browser inference- Agents, tool calling, MCP, and how context windows get consumed- Advice for developers who want to break into AI and ML engineering🔗 FOLLOW NICO💼 LinkedIn: https://www.linkedin.com/in/nicodotdev/🐦 X/Twitter: https://twitter.com/nic_o_martin🦋 Bluesky: https://bsky.app/profile/nico.dev🐙 GitHub: https://github.com/nico-martin🌐 Website: https://nico.dev🎙️ 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/senors-scale/📚 ADDITIONAL RESOURCES- Transformers.js: https://huggingface.co/docs/transformers.js- Hugging Face: https://huggingface.co- ONNX: https://onnx.ai- ONNX Runtime: https://onnxruntime.ai- WebGPU: https://www.w3.org/TR/webgpu/- Utopia for Realists by Rutger Bregman#MachineLearning #AI #HuggingFace #TransformersJS #WebML #OnDeviceAI #WebGPU #ONNX #JavaScript #Frontend #WebDev #SenorsAtScale #OpenSource💬 Would you trust on-device AI over cloud-based models for sensitive data? Share your thoughts in the comments!

What does it actually take to scale a frontend from 15 people in a converted flat to a 1,800-person unicorn, and then migrate the whole thing to microfrontends without breaking anyone's week?In this episode, Dan sits down with Giorgio Polvara, Staff Engineer at Perk (formerly TravelPerk) and the original creator of @testing-library/user-event (1M+ weekly npm downloads). Giorgio joined TravelPerk as employee #15, set up the frontend foundations that still power the product today, left to try engineering management at Toptal, realized he missed building, and came back as Staff.They get into the microfrontend migration that replaced a monolithic React app with vertically-split single-page apps served at the infrastructure layer, the rebrand that changed the name, domain, logo, and colors simultaneously, and the philosophy that ties it all together: you're not building features, you're improving a system that happens to produce features.Key Topics:- Scaling a frontend team from 7 engineers to a full platform tribe- Why 20% refactoring time is the wrong model- Monolith to microfrontends: SingleSPA vs the vertical-split architecture they built- Managing shared dependencies with pnpm, Syncpack, and Vite plugin packages- Contract testing with Pact vs runtime schema validation with Zod- Rebranding an entire product behind a feature flag, without leaking the design- Why Giorgio tried engineering management and went back to IC- Staff engineer advice: propose five solutions, expect one to land🔗 FOLLOW GIORGIO💼 LinkedIn: https://www.linkedin.com/in/polvara🐙 GitHub: https://github.com/Gpx🌐 npm: https://www.npmjs.com/package/@testing-library/user-event🎙️ 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/senors-scale/📚 ADDITIONAL RESOURCES- A Philosophy of Software Design by John Ousterhout- Out of the Tar Pit (Moseley & Marks)- No Silver Bullet (Fred Brooks)- @testing-library/user-event: https://www.npmjs.com/package/@testing-library/user-event- SingleSPA: https://single-spa.js.org- Vite: https://vitejs.dev- Pact (contract testing): https://pact.io- Zod: https://zod.dev#staffengineer #microfrontends #frontendarchitecture #perk #travelperk #reactjs #softwarearchitecture #engineeringleadership #devtools #softwaredesign #senorsatscale💬 How does your team handle the tension between shipping features and keeping the system healthy? Drop a comment 👇

How do you deploy federated front ends to the edge in 150 milliseconds? In this episode, Zack Chapple, CEO and Co-founder of Zephyr Cloud, and Nestor Lopez, Platform Engineer at Zephyr Cloud, break down everything developers need to know about micro frontends, module federation, and deploying at global scale without the infrastructure pain.Zack's journey started at a consulting company working with enterprises like SAP to add module federation support to Angular, which eventually revealed all the pain points of scaling federated architectures. That led to Medusa, then to Zephyr Cloud, the platform he describes as "Kubernetes for the front end." Nestor's path started eight years ago with Sencha.js and iframes, long before module federation existed, and brought him to Zephyr through open source contributions to TRPC and other projects.We cover why module federation is "Docker for the front end," how Zephyr deploys with one line of code and no CI/CD pipeline, their reverse tree shaking technique that recomposes federated bundles into a monolith at the edge, how Nestor deployed 5,200+ micro frontends as a single video, their federated MCP server for enterprise AI orchestration, and a TC39 proposal to fix ESM module unloading in V8. We also talk about pricing, open source contributions, and what it's really like to build a startup with four kids.Whether you're an enterprise team trying to ship frontend independently across dozens of teams, or a solo developer who just wants to deploy without setting up a CI/CD pipeline, this conversation covers the full spectrum.Key Topics:- Micro frontends explained through the microservices and Kubernetes analogy- Module federation as "Docker for the front end" and Zephyr as the orchestration layer- End-to-end walkthrough: from bundler to global edge deploy in ~150ms- No repo required, Zephyr hooks into any bundler and deploys on build- Reverse tree shaking: monolith performance with micro frontend dev experience- The Chrome extension for hot-swapping MFEs in any environment- Federated MCP servers built on module federation for enterprise AI- TC39 proposal to fix ESM module unloading and enable live HMR on Node.js- Bring your own cloud: Cloudflare, AWS, Fastly- Pricing: free for solo, $19/seat for teams, org-wide for enterprise- Mobile support through Metro and desktop through Tauri- Open source contributions and financially supporting projects like RSPack, SWC, and Tailwind🔗 FOLLOW ZACK💼 LinkedIn: https://www.linkedin.com/in/zackarychapple/🐦 X/Twitter: https://x.com/Zackary_Chapple🐙 GitHub: https://github.com/zackarychapple🔗 FOLLOW NESTOR💼 LinkedIn: https://www.linkedin.com/in/nstlopez/🐦 X/Twitter: https://x.com/nstlopez🌐 Blog: https://nstlopez.com🎙️ 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/senors-scale/📚 ADDITIONAL RESOURCES- Zephyr Cloud: https://zephyr-cloud.io- Module Federation: https://module-federation.io- RSPack: https://rspack.dev- Hono: https://hono.dev- shadcn/ui: https://ui.shadcn.com#MicroFrontends #ModuleFederation #ZephyrCloud #Frontend #WebDev #PlatformEngineering #DevEx #EdgeComputing #Kubernetes #SenorsAtScale #OpenSource #Startup💬 What's the most painful deployment workflow you've ever had to deal with? Share your stories in the comments!

William Morgan is the CEO of Buoyant and the creator of Linkerd, the world's first service mesh and a CNCF graduated project powering production Kubernetes infrastructure at thousands of companies. Before founding Buoyant, William spent nearly four years at Twitter as a software engineer and engineering manager, where he shipped core platform features like the Twitter photo service and embed timelines — and watched the legendary monolith-to-microservices transformation unfold firsthand.In this episode, we cover what it was like engineering at Twitter during the fail whale era, how decomposing a monolith introduces entirely new networking challenges, why William invented the term "service mesh," and how Linkerd gives platform teams reliability, security, and observability without developers having to think about it.Whether you're a platform engineer running Kubernetes in production, an SRE trying to make sense of service-to-service communication, or a developer curious about what infrastructure teams actually do — this conversation is packed with hard-won lessons from a decade of building critical open source infrastructure.🔸 Key Topics:- Engineering at Twitter in 2010: the Rails monolith, Scala rewrite, and microservices transformation- How replacing function calls with network calls changes everything- What a service mesh is and why the term had to be invented- Control plane vs data plane architecture- Why Linkerd rewrote its proxy from Scala/JVM to Rust- Latency-aware load balancing, mTLS, and protocol detection- Multi-cluster communication and mesh expansion to VMs- Common service mesh implementation mistakes- Linkerd vs Istio: William's honest take- Open source sustainability and enterprise monetization- The enterprise sales journey from engineer to CEO- Book recommendations: Hyperion, Gideon the Ninth, The Book of the New Sun🔗 FOLLOW WILLIAM💼 LinkedIn: https://www.linkedin.com/in/wmorgan/🐦 X/Twitter: https://x.com/wm🌐 Buoyant: https://buoyant.io🎙️ 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- Linkerd: https://linkerd.io- Buoyant: https://buoyant.io- Linkerd Getting Started: https://docs.buoyant.io- Linkerd GitHub (Proxy): https://github.com/linkerd/linkerd2-proxy- Hyperion by Dan Simmons- Gideon the Ninth by Tamsyn Muir- The Book of the New Sun by Gene Wolfe- Simon Willison's Blog (AI/LLMs): https://simonwillison.net#Linkerd #ServiceMesh #Kubernetes #Rust #CloudNative #Buoyant #CNCF #Microservices #Infrastructure #PlatformEngineering #SoftwareEngineering #SenorsAtScale💬 What's the most complex networking issue you've debugged in a microservices environment? Share your war stories in the comments!

You can never build anything faster than your slowest database query. In this episode, Tyler Benfield, Staff Software Engineer at Prisma, breaks down everything developers need to know about database performance, from why your queries are slow to how Prisma scales Postgres to handle billions of requests on bare metal infrastructure.Tyler's path into databases started at Penske Racing, writing trackside software for NASCAR pit stops, and eventually led him deep into query optimization, connection pooling, and building Prisma Postgres from the ground up. We cover the most common ORM anti-patterns, why indexes are the single biggest performance lever most developers ignore, how Prisma Accelerate turns database connections into HTTP calls, and why Tyler thinks the SQL query language itself is fundamentally broken for modern web apps.Whether you're a frontend developer afraid to touch the database or a backend engineer scaling past your first million users, this conversation is packed with practical, immediately actionable advice.🔸 Key Topics:- ORMs vs raw SQL vs query builders and when to use each- The most common Prisma anti-patterns that tank your app performance- How database indexes actually work (the address book analogy)- Connection pooling, serverless runtimes, and the problem Prisma Accelerate solves- Scaling Postgres on bare metal with memory snapshots and scale-to-zero- Per-query pricing and why Prisma charges differently than other providers- NoSQL vs SQL and when Postgres can handle both- Why SQL is a bad query language for nested relational data- The future of AI agents and databases, MCP servers, and ephemeral environments🔗 FOLLOW TYLER💼 LinkedIn: https://www.linkedin.com/in/tylerbenfield/🐦 X/Twitter: https://x.com/rtbenfield🦋 Bluesky: https://bsky.app/profile/rtbenfield.dev🌐 Website: https://tylerbenfield.me🎙️ 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- Prisma ORM: https://www.prisma.io- Prisma Postgres: https://www.prisma.io/postgres- The Design of Everyday Things by Don Norman- The Design of Future Things by Don Norman- Designing Data-Intensive Applications by Martin Kleppmann- Aaron Francis (database education): https://aaronfrancis.com#Prisma #Postgres #DatabasePerformance #ORM #TypeScript #ServerlessDatabase #ConnectionPooling #SQLOptimization #WebDevelopment #SoftwareEngineering #FullStack #DatabaseIndexes #SenorsAtScale💬 What's the worst database performance issue you've ever debugged? Share your war stories in the comments!

TanStack Form gets over a million downloads per week. Corbin Crutchley is the person behind it. But this conversation goes way beyond forms and frameworks.Corbin started coding professionally at 16, worked minimum wage at a charter school, taught himself Angular through sheer persistence, and eventually became a GitHub Star, Microsoft MVP, author of The Framework Field Guide, and VP of Engineering at Immersive Homes. Along the way, he built one of the most beloved open source form libraries in the JavaScript ecosystem and founded Playful Programming, a nonprofit that teaches people how to code for free.In this episode, we get into the real stuff: how he joined TanStack through a 30-minute conversation with Tanner Lindsley that turned into an invitation to lead a project, what it actually feels like to maintain a library that millions of projects depend on, why he almost quit open source after a wave of rude issues, and how he thinks about versioning as a social contract with your users. We also talk about framework agnostic architecture, why he wrote a free book that teaches React, Angular and Vue at the same time, the open source funding problem, and his transition from IC to VP of Engineering at Immersive Homes (which started with a game of Magic: The Gathering). He closes with something deeply personal about mental health in tech that I think everyone needs to hear.📚 RESOURCES MENTIONED- TanStack Form: https://tanstack.com/form- TanStack: https://tanstack.com- The Framework Field Guide: https://playfulprogramming.com/collections/framework-field-guide- Playful Programming: https://playfulprogramming.com- Diataxis Documentation Framework: https://diataxis.fr- Will Larson's Books (An Elegant Puzzle, Staff Engineer): https://lethain.com- Engineering Management for the Rest of Us by Sarah Drasner- Shoe Dog by Phil Knight🔗 FOLLOW CORBIN- GitHub: https://github.com/crutchcorn- LinkedIn: https://www.linkedin.com/in/corbincrutchley- Bluesky: https://bsky.app/profile/crutchcorn.dev- Twitch: https://twitch.tv/crutchcorn🎙️ FOLLOW & SUBSCRIBE📸 Podcast Instagram: https://www.instagram.com/senorsatscale📸 Dan's Instagram: https://www.instagram.com/nicudan📰 Newsletter: https://senorsatscale.substack.com💼 Dan's LinkedIn: https://www.linkedin.com/in/nicudan🌐 Website: https://neciudan.dev#SoftwareEngineering #OpenSource #TanStack #TanStackForm #JavaScript #TypeScript #ReactJS #Angular #Vue #FrameworkAgnostic #GitHubStar #VPofEngineering #EngineeringLeadership #TechLeadership #MentalHealthInTech #WebDevelopment #SenorsAtScale

What happens when one developer's tools account for 0.7% of all NPM downloads? In this episode, Andrey Sitnik, creator of PostCSS, Autoprefixer, and Browserlist, and lead engineer at Evil Martians, shares the full story behind the CSS tools that millions of developers depend on every day.From writing PostCSS in CoffeeScript to architecting its event-based plugin system in version 8, Andrey walks us through the technical decisions, ecosystem politics, and open source philosophy that shaped modern CSS tooling. We also dig into why he intentionally designed Browserlist's query language to fight browser discrimination, how Tailwind's donation accidentally forced the PostCSS 8 release, and why he believes the tech industry's biggest problems aren't technical at all.🔸 Key Topics:- The origin story of PostCSS and why Autoprefixer was the gateway- Plugin architecture from day one: designing for ecosystem growth- Managing painful major releases across a massive plugin ecosystem- Why rewriting tools in Rust isn't always the performance win you think- Browserlist's hidden philosophy: shaping developer behavior through language design- The Tailwind donation that triggered the PostCSS 8 release- Why the hardest problems in open source are political, not technical- CSS tooling in the age of LLMs: complexity control over automation- Social media, values, and what the tech industry lost in the 2010s- Dark transhumanism: sci-fi book recommendations from a systems thinker⏱ Chapters:00:00 - Intro00:53 - How Andrey started programming and his Wikipedia roots02:59 - The origin of PostCSS and Autoprefixer06:26 - Why PostCSS was built as a plugin system from day one08:20 - The relationship between PostCSS and Sass/Less communities11:04 - Managing the PostCSS 8 major release and migration strategy14:57 - From CoffeeScript to ES modules: PostCSS's language journey16:08 - Why rewriting in Rust isn't always the answer19:15 - The hardest problems aren't technical21:51 - Event-based plugin architecture deep dive23:20 - What Andrey would do differently today24:14 - Is PostCSS still needed? CSS tooling in the future27:51 - Browserlist: fighting browser discrimination through design31:41 - AI, open source, and the values crisis in tech38:51 - The Open Claw controversy and open source experiments40:18 - The social media reader Andrey wishes existed44:24 - Book recommendations: dark transhumanism and beyond🔗 Resources & Links:- Andrey Sitnik: https://evilmartians.com/martians/andrey-sitnik- The history of PostCSS (article): https://evilmartians.com/chronicles/what-we-learned-from-creating-postcss- PostCSS: https://postcss.org- Browserlist: https://browsersl.ist- CSSTree (faster JS-based PostCSS alternative): https://github.com/csstree/csstree- CSSTree author's talk on how he built it: https://www.youtube.com/watch?v=itxpfoo1daM- Lightning CSS (Rust-based PostCSS replacement): https://lightningcss.dev- Slow Reader (Andrey's social media reader project): https://github.com/hplush/slowreader- Evil Martians: https://evilmartians.com📚 Dark Transhumanism Reading List:1. "Permutation City" by Greg Egan2. "Lena" by qntm (short horror story in wiki format): https://qntm.org/mmacevedo3. "The Quantum Thief" by Arsène Lupin4. "Blindsight" by Peter Watts🔗 Follow & Subscribe:📸 Podcast Instagram: https://www.instagram.com/senorsatscale📸 Dan's Instagram: https://www.instagram.com/nicudan📰 Newsletter: https://senorsatscale.substack.com💼 Dan's LinkedIn: https://www.linkedin.com/in/nicudan🌐 Website: https://neciudan.dev#SeniorsAtScale #PostCSS #Browserlist #Autoprefixer #OpenSource #CSSTooling #EvilMartians #WebDevelopment #FrontendEngineering #SoftwareEngineering #TechLeadership #PluginArchitecture #DeveloperTools

What does a robotics graduate, a Microsoft MVP, and a Vercel DX Engineer have in common? They're all Aurora Scharff, and she's on a mission to change how developers think about React.In this episode, Aurora takes us through her unconventional path from studying Robotics and Intelligent Systems at the University of Oslo to becoming one of the most active voices in the React community. From her early days building Angular frontends at a fintech startup to leading a major public sector frontend rebuild with Next.js at Crayon Consulting, Aurora has seen it all. Now at Vercel, she's focused on developer experience, and as React Certification Lead at certificates.dev, she's shaping how the industry validates React skills.We go deep on React Server Components, what they actually change about how you build apps, why the mental model shift trips up even experienced developers, and how Next.js App Router fits into the picture. Aurora also shares real stories from rebuilding legacy systems for the Norwegian government, her honest take on Vercel vs Azure deployments, and why she thinks certifications matter more than ever in an AI-driven world.🔸 Topics Covered:- Transitioning from robotics and Angular to the React ecosystem- React Server Components: how they simplify data fetching and improve performance- The mental model shift developers need to make with async server components- Next.js App Router vs Page Router and why the migration is worth it- Deploying Next.js on Vercel vs Azure: trade-offs and gotchas- Handling vulnerabilities and upgrades in production Next.js apps- Rebuilding legacy public sector systems with modern web tech- Creating the React certification at certificates.dev- Common React mistakes: deriving state and other pitfalls- New React features: view transitions, suspense, and what's coming next- Public speaking tips and building a content creation workflow- Becoming a Microsoft MVP and contributing to the developer community📌 Chapters00:00 Introduction to Aurora Scharff01:56 Transition from Robotics to Web Development03:22 Journey from Angular to React06:40 Understanding React Server Components09:23 Mental Model Shifts with Server Components10:41 Exploring Next.js and Its Features11:33 Deployment Strategies: Vercel vs Azure14:43 Handling Vulnerabilities in Next.js15:47 Next.js App Router vs Page Router16:54 New Features in React Ecosystem18:46 Rebuilding Legacy Systems20:45 Testing Practices in Next.js22:23 Creating React Certifications29:07 The Importance of Certifications29:52 Common Mistakes in React Development31:36 Aurora's Speaking Journey36:14 Content Creation Process for Talks37:33 Balancing Work and Side Projects40:23 Advice for Aspiring Speakers42:24 Becoming a Microsoft MVP43:47 Excitement in the React Ecosystem44:59 Future Plans and Upcoming Projects45:33 Recommended Movies and Closing Thoughts🔗 Connect with Aurora:- LinkedIn: https://www.linkedin.com/in/aurorascharff-a86b88188- Website: https://aurorascharff.no🎙️ 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/#ReactJS #NextJS #ReactServerComponents #WebDevelopment #SoftwareEngineering #Vercel #DeveloperExperience #TechPodcast #SeniorsAtScale #JavaScript #FrontendDevelopment #Microsoft MVP #ReactCertification #AppRouter #TechLeadership

What does it actually take to be a developer advocate? And how do you measure the impact of developer relations when everyone seems to disagree on the metrics?In this episode, Daniel Afonso, Senior Developer Advocate at PagerDuty, walks us through his journey from writing prank bash scripts as a 10-year-old in Portugal to becoming one of the most active voices in the European DevRel community. Daniel breaks down how developer relations sits at the intersection of engineering, marketing, sales, and product, and shares hard-won lessons on what makes DevRel programs succeed or fail.We also go deep on developer experience, covering the three pillars every SDK and API team should optimize for: reducing cognitive load, fast feedback loops, and keeping developers in flow state. Plus, Daniel shares his take on on-call culture, why postmortems matter, and the books that shaped his career.🔸 Topics Covered:Growing up drawn to tech and competing in national programming competitions in PortugalTransitioning from backend (Java, C++, .NET) to frontend and falling in love with ReactHow blogging, learning in public, and meetups built the foundation for a DevRel careerDeveloper Relations explained: the Venn diagram of engineering, marketing, sales, and productMeasuring DevRel impact: from vanity metrics to Developer Relations Qualified LeadsWhy DevRel programs fail: unreasonable expectations, pitch-fest conference talks, and missing business alignmentThe three pillars of developer experience: cognitive load, fast feedback loops, and flow stateHow React's JSX and Solid's signals represent great DX initiatives in practiceStaying technical as a developer advocate through side projects, code reviews, and community workOn-call culture: reducing alert fatigue, owning your services, and changing the "I hate on-call" mindsetBook recommendations: Thriving on Overload, How to Win Friends and Influence People, The Phoenix ProjectChapters:00:00 Introduction to Developer Advocacy01:15 Daniel's Journey into Programming07:28 Transitioning to Front-End Development12:49 The Path to Developer Relations18:43 Understanding Developer Relations22:53 Measuring the Impact of DevRel26:45 Common Pitfalls in DevRel Programs30:39 Marketing and Developer Relations Missteps33:47 Avoiding Developer Pitfalls at Events35:53 Staying Technical in Non-Technical Roles40:06 Defining Great Developer Experience46:56 The Importance of Documentation52:41 On-Call Experiences and Incident Management01:02:12 Book Recommendations and Personal Favorites01:06:52 Wrap Up🔗 Follow & Subscribe:YouTube: https://www.youtube.com/@neciudanSpotify: https://open.spotify.com/show/senorsatscaleApple Podcasts: https://podcasts.apple.com/podcast/senors-at-scaleLinkedIn: https://www.linkedin.com/in/neciudanNewsletter: https://neciudan.dev🔗 Guest Links:Twitter: https://twitter.com/danielafonsoLinkedIn: https://linkedin.com/in/danielafonsoPagerDuty: https://pagerduty.com/📚 Resources Mentioned:Thriving on Overload - https://www.amazon.com/Thriving-Overload-Strategies-Manage-Information/dp/XXXXXXReact Documentation - https://reactjs.org/docs/getting-started.htmlCloudflare Use Effect Postmortem - https://blog.cloudflare.com/postmortem-incident-XXXXXXSolidJS - https://solidjs.com/Frictionless by Abhinoda & Nicole ForsgreenThe Phoenix ProjectHow to Win Friends and Influence People by Dale Carnegie#DevRel #DeveloperExperience #DeveloperAdvocacy #SoftwareEngineering #PagerDuty #OnCall #DX #TechPodcast #SeniorsAtScale #DeveloperRelations #OpenSource #TechLeadership

How do you build an engineering organization from zero to 700 professionals? What happens when your biggest leadership lesson comes from a broken leg and a Border Collie?In this episode of Senors @ Scale, I sit down with Lucian Popovici, a force multiplier in tech leadership with 20+ years of experience scaling engineering organizations at Ericsson, Deutsche Bank, and Deloitte Digital. Lucian is the founder of Bridging Innovation, an enterprise strategy advisory and AI consultancy, and Bridging Gaps, a pro bono mentoring community of 80+ senior tech leaders that has delivered over 3,000 hours of free mentoring to 400+ professionals in Romania.Lucian shares the raw, unfiltered story of his transition from Java developer to engineering director, including the panic attacks he didn't acknowledge, the "control freak" feedback that changed everything, and why he believes informal leadership matters more than titles. We go deep on how AI is reshaping team structures (from 10-person teams to 5), why junior developer roles are disappearing, why Romania's IT industry needs to shift from body leasing to product thinking, and his bold take that project managers should "die" as a role. Whether you're scaling your first team or building your hundredth, this conversation is packed with hard-won wisdom.🔸 KEY TOPICS DISCUSSED- Scaling engineering organizations from scratch at Deutsche Bank, Deloitte Digital, and beyond- The brutal transition from developer to leader and why most people aren't prepared- Manager vs. leader: why less ego and more empathy changes everything- Why flat organizations beat pyramid schemes of managers- How AI is cutting team sizes in half and eliminating junior roles- The Romanian IT industry's transformation from outsourcing to product and consultancy- Why 85% more time is now spent on code reviews than writing code- Fractional CIO/CTO roles and why SMBs desperately need them- Building a pro bono mentoring community of 80+ senior leaders- AI readiness: why most companies fail at AI implementation before they even start- The startup ecosystem in Romania and why this is the best time for non-technical founders- Why project managers should disappear (but product managers never will)- The engineering mindset vs. role segregation in modern teams- Adaptability and curiosity as the core leadership skills for 2030⏱️ CHAPTERS00:00 Introduction to Lucian Popovici02:22 From Developer to Leader: The Brutal Transition06:27 Manager vs. Leader: Ego, Empathy, and Flat Orgs09:28 Scaling Organizations (Without a Playbook)11:23 How AI Is Reshaping Team Structures16:02 Is Romania's IT Industry Scaling Down?24:40 The "Control Freak" Feedback That Changed Everything29:37 How Bridging Gaps Started (The Border Collie Story)36:30 From Corporate to Entrepreneur: Bridging Innovation45:59 The Future of Engineering Roles and Leadership🔗 FOLLOW LUCIAN💼 LinkedIn: https://www.linkedin.com/in/lucianpopovici/🌐 Bridging Innovation: https://bridging-innovation.com🤝 Bridging Gaps: https://bridging-gaps.ro/📝 Blog: https://lucianpopovici.com🎙️ 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- HowToWeb Conference: https://www.howtoweb.co- Ascendis Training: https://www.ascendis.ro#EngineeringLeadership #ScalingTeams #TechLeadership #AI #SoftwareEngineering #StartupRomania #EngineeringManagement #ProBonoMentoring #FractionalCTO #AgileLeadership #DevOps #TeamScaling #SenorsAtScale💬 Have you made the jump from developer to leader? What was your biggest challenge? Share in the comments!

What makes a great tech lead? It's not just technical chops—it's the soft skills that scale your impact beyond your own keyboard.In this episode, I sit down with Anemari Fiser, an engineering leader, O'Reilly author, and coach who's spent over a decade helping engineers make the leap from individual contributor to technical leader. Anemari has led teams at ThoughtWorks through massive transformations (think monolith-to-microservices, datacenter-to-AWS migrations), coached 500+ engineers, and trained 300+ tech leads worldwide.Her new book, "Leveling Up as a Tech Lead," distills years of hands-on experience into practical frameworks for the hardest role in tech. We explore why so many senior engineers struggle with the transition, how to measure success when you're no longer shipping code, and the collaboration techniques that actually work in real-world teams.This conversation goes deep on the unglamorous but essential work of technical leadership—from running effective 1-on-1s to delegation that empowers rather than bottlenecks, from defining what success means for you to navigating the brutal tech lead job market.🔸 KEY TOPICS DISCUSSED- The journey from software engineer to product director—and what she learned along the way- Why soft skills, not just technical expertise, determine your impact at scale- The critical difference between senior engineers and tech leads- How to transition from "doing the work" to "enabling the work"- Why your success as a tech lead depends entirely on your team's success- The accountability framework that drives consistent growth in others- How to get people out of their comfort zones without breaking trust- The power of intentional growth vs. accidental learning- Measuring impact when you're not writing code anymore- Why 1-on-1s are your secret weapon (and how to run them effectively)- The delegation playbook that removes pressure while empowering your team- Networking strategies that actually work in today's tech job market- How to interview for tech lead roles—and spot the red flags- The collaboration techniques that scale teams beyond individual heroics⏱️ CHAPTERS00:00 Introduction to Anemari Fiser00:58 Early Career: From University to First Tech Job04:09 Balancing Work and University in Romania09:00 First Job Experiences and Learning to Code12:02 The Importance of Accountability in Leadership16:07 Strategies for Encouraging Growth in Others20:03 Intentional Growth and Getting Out of Your Comfort Zone20:56 Scaling Soft Skills in Tech23:57 Senior Engineer vs. Tech Lead: What's the Difference?26:55 Making the Transition from Senior Engineer to Tech Lead29:40 Expanding Your Team's Impact Beyond Your Own Work31:01 The Tech Lead Role Across Different Companies32:32 Balancing Hands-On Technical Work with Leadership34:29 Defining Success as a Tech Lead38:10 Measuring Impact and Setting Personal OKRs42:07 Guiding Junior Engineers: Teaching vs. Enabling43:51 Job Hunting Strategies in the Current Tech Market46:10 Why Networking is Your Best Job Search Tool50:52 Interviewing for Tech Lead Roles: Green Flags and Red Flags53:28 Key Takeaways from "Leveling Up as a Tech Lead"📚 RESOURCES MENTIONED- Anemari's Book: "Leveling Up as a Tech Lead" (O'Reilly) - https://www.amazon.com/[BOOK-LINK]- Crucial Conversations by Kerry Patterson- The Culture Map by Erin Meyer- The Manager's Path by Camille Fournier- Continuous Deployment by Valentina Servile- The Silent Patient by Alex Michaelides🔗 FOLLOW ANEMARI- LinkedIn: https://www.linkedin.com/in/anemari-fiser- Website: https://anemarifiser.com🎙️ 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%C3%B1ors-scale/

MicroFrontends at Scale with Florian Rappl | The Art of Modular ArchitectureWhat 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 deploymentsWhether 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 & Welcome01:31 - The Origin Story of Piral04:30 - The Micro Frontend Landscape in 201908:05 - Piral vs Module Federation: Understanding the Difference12:15 - The Inverse Dependency Pattern18:20 - Building Enterprise Portals at Scale25:40 - Server-Side Rendering & SEO Challenges35:10 - Cloudflare Workers & Edge Computing for Micro Frontends45:25 - Cross-Framework Components & the Converter API52:30 - Discovery Services & Dynamic Module Loading58:15 - AI-Assisted Development & Modular Architecture1: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.Chapters00:00 Introduction and Daniel's Background03:45 From Laravel to Vue and Nuxt08:20 Becoming a Nuxt Core Team Member12:30 The Evolution of Nuxt and Developer Experience18:15 Understanding User Pain Points24:00 Rendering Strategies: Static vs Server-Side29:45 The Nitro Server Engine Revolution35:20 Data Fetching Best Practices41:10 The Power of Nuxt Modules46:30 Contributing to Open Source51:00 The Future of Nuxt53:52 OutroFollow & 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ñorsatscaleDon'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 Seniors at Scale, host Dan Neciu dives deep into the world of state management with Daishi Kato, the prolific open-source author and maintainer behind three of the most widely used libraries in modern React: Zustand, Jotai, and Valtio. Daishi also shares insights into his new project, Waku, a framework built around React Server Components.Daishi has spent nearly a decade building modern open-source tools that expertly balance simplicity with scalability. He shares how the announcement of React Hooks got him excited and led him to pick global state as his field to explore, as it was "more like logic" and "off look and feel".We break down the core philosophies and technical trade-offs between his state management trifecta:Zustand (Zastan): Described as a single global store or global variable. It is minimal, and its philosophical difference from Redux is that it doesn't use reducers.Jotai (Jyotai): Defined as a set of atom definitions, structured more like functions than a single global store. Daishi explains how the concept evolved from a need to avoid JavaScript proxies and selectors for better rendering optimization.Valtio (Valtio): This library is fundamentally based on just using JavaScript objects. It re-introduces proxy-based reactivity because Daishi realized that proxies were now "recognized" and acceptable in the community. We discuss its hook-based API, which differentiates it from MobX's observer pattern.The conversation then moves to the future of React development with Waku, which Daishi started as an experiment to learn how state management interacts with React Server Components. He explains Waku is suited for small-to-medium-sized web applications and static sites and discusses his vision for it to coexist with, rather than beat, Next.js.What makes Zustand, Jotai, and Valtio different: Global Store vs. Atom Definitions vs. JavaScript Objects.The philosophical difference between Zustand and Redux: Redux is reducers, Zustand is not.How Jotai's atom concept evolved and its goal of render optimization without selectors.Why Valtio embraced proxies and how its hook-based API differs from MobX.The origin story of Waku as an experiment with React Server Components.How React 18's useSyncExternalStore made Zustand even smaller.The challenge of maintaining four popular open-source libraries, with Waku being the current focus.Daishi’s strategy for rejecting feature requests for minimal libraries like Zustand: "We reject everything".Why Daishi prefers a competitive community over a built-in React state manager.Which of his libraries (Jotai) is best suited for use within Waku, as it is an abstraction of state that works on both client and server.If you're managing global state in React, interested in the internals of popular open-source tools, or curious about the future with React Server Components, this episode is a must-listen.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%C3%B1ors-scale/Additional Resources🌐 Daishi's Libraries: https://github.com/pmndrs🌐 Waku: https://github.com/dai-shi/waku🌐 SICP Book: Structure and Interpretation of Computer Programs#react #zustand #jotai #valtio #waku #statemanagement #javascript #opensource #softwareengineering #frontend #webdevelopment #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 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.Chapters00:00 Intro and Vlad’s Background01:42 Why DDD Was Written and Who It Was For04:02 When Aggregates Finally Made Sense05:42 Ubiquitous Language as the Core of DDD07:31 Why Software Projects Fail08:52 The Biggest Misconception About DDD10:13 Common Anti-Patterns in Domain Design12:12 Greenfield vs Brownfield DDD14:03 How to Begin Refactoring a Monolith15:25 Mapping Subdomains: Core, Supporting, Generic19:25 When Companies Do DDD Without Knowing20:39 When DDD Fails and Lessons Learned22:41 Why Defining Boundaries Is Hard25:56 Accidental Complexity in Large Systems27:32 Microservices, Myths, and Pain30:29 What Coupling Really Means33:17 Strength, Distance, and Volatility39:07 How Vlad Documents Architecture41:37 Event Storming as the Source of Truth44:01 How AI Changes System Design48:28 How to Enforce Ubiquitous Language51:00 Book Recommendations53:33 Closing ThoughtsFollow and Subscribe:Instagram: https://www.instagram.com/senorsatscale/Instagram: https://www.instagram.com/neciudevPodcast: https://neciudan.dev/senors-at-scaleNewsletter: https://neciudan.dev/subscribeLinkedIn: https://www.linkedin.com/in/neciudanLinkedIn: 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.Chapters00:00 Security at Scale – Why It Matters Now02:14 How Liran Got Into Security05:12 The Shift Toward Developer-Led Security08:33 How Snyk Changed the Developer Security Workflow11:07 The Story Behind NPQ and Safer Dependency Installation14:02 The Rise of NPM Malware and Maintainer Compromise16:48 Why Blind Upgrade Everything Pipelines Are Dangerous19:15 Is Node the Problem or Is It NPM21:10 The Hidden Risk of MCPs and AI Agent Vulnerabilities24:18 Toxic Flows, Shadowed Tools, and Prompt Injection27:22 AI Browsers, Extensions, and Real Prompt Injection Attacks30:04 Why Prompt Injection Has No True Fix33:01 AI-Generated Code Is Statistically Insecure35:12 How Snyk Plus MCP Creates a Secure Coding Loop37:40 The Most Common MCP Vulnerabilities40:55 How AI Agents Turn Mild Bugs Into Critical RCE43:11 The Glassworm Invisible Unicode Attack Vector44:51 EventStream, XZ Utils, and Supply Chain Horror Stories48:03 Liran’s Personal Security Incidents51:10 UX vs Security and Real World Tension53:04 Liran’s Book Recommendations55:37 Final Thoughts and Protecting Yourself as AI EvolvesSound 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/neciudevPodcast URL: https://neciudan.dev/senors-at-scaleNewsletter: https://neciudan.dev/subscribeLinkedIn: https://www.linkedin.com/in/neciudanLinkedIn: https://www.linkedin.com/company/señors-scale/Additional ResourcesSnyk – developer-first security toolsServerless Security (O’Reilly) – co-authored by LiranLiran’s GitHub: https://github.com/lirantalNPQ package checker: https://github.com/lirantal/npqMCP 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.Chapters00: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 Architecture1:03:33 Book Recommendations and Final ThoughtsFollow & 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ñorsatscaleDon’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 publicHow Preply's design system impacts user experienceThe balance between perfectionism and pragmatism in engineeringThe role of data-driven decisions in Preply's cultureBest practices for managing large codebases without testsStefano 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 Preply05:12 The Importance of Public Work12:45 Building a Design System at Preply18:30 Balancing Perfectionism and Pragmatism25:00 Data-Driven Culture at Preply32:15 Managing Large Codebases Without Tests40:00 The Journey from Flash to React47:30 Networking and Reputation in Tech55: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ñorsatscaleDon’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 👇

🎙 About the Podcast:Señors @ Scale is a no-fluff engineering podcast hosted by Neciu Dan — diving into the real-world chaos of scaling systems, teams, and yourself. From production bugs to platform bets, we sit down with senior engineers to discuss the scars, strategies, and lessons that truly matter.In this episode, host Neciu Dan sits down with Bruno Paulino, Tech Lead at N26, to unpack how reliability, experimentation, and platform culture shape one of Europe’s most trusted digital banks.Bruno’s path is anything but ordinary — from serving as a police officer in Brazil to leading FinTech engineering teams at scale. He shares how N26 builds server-driven UIs, runs AI-powered customer support, and balances speed vs reliability when every deploy touches millions of users.They break down:How server-driven UI lets N26 ship features in minutesWhy CI/CD pipelines are the backbone of reliabilityWhat it means to trade speed for resilience in FinTechHow Statsig changed experimentation culture company-wideLessons from production outages and post-mortemsWhy strong developer experience drives safer systemsIt’s a deep dive into the real architecture, trade-offs, and human decisions behind reliable banking systems at scale.🎧 Whether you’re scaling a FinTech product, managing CI/CD pipelines, or just trying to keep production sane, this one’s for you.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%C3%B1ors-scale/

In this episode of Señors @ Scale, Dan chats with Natalia Venditto, Principal Product Manager at Microsoft, and Igor Minar, Senior Director of Engineering at Cloudflare and co-creator of Angular, about WebFragments — a radical new approach to micro-frontends that rethinks how we build for the web.Natalia and Igor share how WebFragments was born from years of pain with module federation and brittle micro-frontend systems. They explain why shared dependencies and team coupling still plague large-scale applications, and how WebFragments breaks that pattern by isolating each fragment’s JavaScript and DOM context while still delivering a seamless user experience.We dive deep into the architecture:how iframes are being reinvented for performance and isolation,how Shadow DOM and a technique called Reframing encapsulate code like Docker does for containers,and how Fragment Piercing enables server-rendered fragments to appear instantly — even before the client shell has loaded.The conversation also covers the challenges of building vendor-agnostic, framework-independent systems, the middleware patterns that eliminate CORS issues, and Cloudflare’s real-world migration of its production dashboard to WebFragments.Plus, Natalia and Igor share what’s next — from nested fragments and out-of-order streaming to growing an open-source community around this new model of frontend architecture.Whether you’re building micro-frontends, leading platform teams, or just curious about what’s next for web architecture, this episode is a masterclass in isolation, performance, and pragmatic innovation at scale.Chapters00:00 Introduction to WebFragments and Guests06:48 Differentiating WebFragments from Module Federation13:46 The Promise of Independence in Micro-Frontends16:49 Reframing: A New Approach to Isolation19:54 The Concept of Piercing in WebFragments33:26 Fragment Communication and State Management36:09 Middleware and Request Routing39:22 WebFragments in Action at Cloudflare44:02 Getting Started and Migration Path50:13 Future Developments and Features54:37 Community and Contributions01:02:02 OutroFollow & 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 Resourceshttps://github.com/webfragmentshttps://blog.cloudflare.com/https://learn.microsoft.com/#microfrontends #webfragments #javascript #angular #cloudflare #microsoft #frontend #softwarearchitecture #performance #webdevelopment #softwareengineering #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines.How is your team approaching micro-frontends and architectural independence? Share below 👇

In this episode of Señors @ Scale, Erik Grijzen, Principal Software Engineer at New Relic, joins Dan to share his journey from web designer to principal architect and what it really takes to scale UI development across dozens of teams. Erik walks us through how New Relic built one of the first large-scale micro-frontend architectures before the term even existed, designing tooling that lets teams ship independently—from CLI bootstrapping to runtime composition. He explains how to manage hundreds of deploys a day without breaking the platform, and how observability keeps complex systems reliable when they inevitably fail.We dive deep into observability at scale—how metrics, logs, traces, and business data blend to show what’s happening inside distributed systems, and why visibility isn’t just for developers anymore but a business priority tied to uptime, revenue, and customer trust.Erik also shares what technical leadership looks like at New Relic: influencing without authority, scaling architecture through culture, and using processes like RFCs and change documents to make better decisions. He emphasizes writing before building, POCs before roadmaps, and the mindset shift from coding features to guiding direction.The episode closes with a thoughtful discussion on burnout, balance, and habits for longevity in engineering—from sports and shutdown rituals to books like A Philosophy of Software Design and 4,000 Weeks.Whether you’re an architect, staff engineer, or team lead scaling a complex frontend platform, this episode is packed with real lessons on architecture, observability, and leadership at scale.Chapters00:00 Introduction to Erik Grijzen and His Journey08:48 Building a Unified Platform at New Relic13:34 Challenges and Solutions in Micro-Frontend Development18:47 How Observability Works Behind the Scenes32:02 Organizing Teams Around Domains36:38 Testing in Micro Frontends43:38 Technical Leadership and Management49:38 Effective Processes for Teams54:05 Decompressing and Work-Life Balance---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%C3%B1ors-scale/---Additional Resources[https://newrelic.com/blog](https://newrelic.com/blog)[https://micro-frontends.org/](https://micro-frontends.org/)[https://web.stanford.edu/~ouster/cgi-bin/book.php](https://web.stanford.edu/~ouster/cgi-bin/book.php)[https://oliverburkeman.com/books/4000-weeks/](https://oliverburkeman.com/books/4000-weeks/)#microfrontends #observability #softwarearchitecture #newrelic #frontend #softwareengineering #leadership #teammanagement #engineeringculture #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. How is your team scaling architecture and observability? Share below 👇

In this episode of Señors @ Scale, Kateryna Porchienova, Senior Engineering Manager at Buffer, joins Dan to talk about her journey into programming, the craft of UI animation, and why accessibility should be a standard — not an afterthought.Kateryna shares how her very first app, built in high school, ended up helping children with disabilities learn from home — sparking a lifelong commitment to inclusion in tech. She walks us through best practices for accessibility, from learning to use a screen reader to understanding semantic HTML and ARIA roles.We also dive into the tooling side — from React Aria and Radix to Storybook and Lighthouse — and discuss how AI can both help and hurt accessibility efforts. Kateryna explains the most common mistakes developers make (like overusing ARIA labels), why animation and motion preferences matter for users’ health, and how to advocate for accessibility within engineering teams and company culture.The episode closes with her favorite book recommendations on product development and communication, underscoring how great engineering is as much about people as it is about code.🎯 Whether you’re a frontend developer, design system engineer, or tech lead, this episode is packed with real stories, practical takeaways, and thoughtful lessons from years of building inclusive products at scale.Chapters00:00 Introduction to Katarina Porchienova02:40 The Importance of Animation in UI Design05:23 Katarina's Journey into Programming09:02 Exploring Accessibility in Development11:43 Best Practices for Accessibility14:18 Tools and Libraries for Accessibility Testing17:09 The Role of AI in Accessibility20:44 Common Mistakes in Accessibility Implementation24:14 Advocating for Accessibility in Companies30:37 Recommended Books and Closing Thoughts---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%C3%B1ors-scale/---Here are some additional resources to dive deeper into the topic and learn more:- If you are just starting with accessibility, this free course on Udacity is awesome: 🔗 [Web Accessibility Course / Udacity](https://www.udacity.com/course/web-accessibility--ud891)- A11ycasts series on YouTube is great for bite-sized content on accessibility and screen-reader tutorials🔗 [A11ycasts with Rob Dodson](https://www.youtube.com/watch?v=HtTyRajRuyY&list=PLNYkxOF6rcICWx0C9LVWWVqvHlYJyqw7g)- [Adrian Roselli blog](https://adrianroselli.com/posts) is an awesome resource for deep dives on specific topics and details- [Web Content Accessibility Guidelines (WCAG) 2.1](https://www.w3.org/TR/WCAG/)- [ARIA Authoring Practices Guide (APG)](https://www.w3.org/WAI/ARIA/apg/) is super useful for developing different widgets- [HTML Accessibility API Mappings](https://www.w3.org/TR/html-aam/) to see how native HTML elements map to accessibility tree- [Aria Live Regions documentation](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions) to learn more about announcements and live regions- [A11Y support](https://a11ysupport.io/) shows support for various ARIA attributes across different screen readers#accessibility #webdevelopment #frontend #uiux #animation #buffer #reactaria #softwareengineering #a11y #engineeringculture #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines.How is your team building accessibility into your workflow? Share below 👇

In this episode of Señors @ Scale, Adrian Marin, founder of AVO and host of FriendlyRB, joins Dan to share his journey into programming and his deep commitment to the Ruby ecosystem.Adrian walks us through his transition from a non-technical background into software development and how he fell in love with Ruby on Rails for its elegance and productivity. He explains why everything in Ruby is an object, what makes Rails still the fastest way to build apps, and how Hotwire redefines frontend development with minimal JavaScript.We also dive into the tools and frameworks shaping today’s developer experience: the rise of Tailwind CSS, why Adrian built AVO to make internal tooling in Rails as smooth as Laravel Nova, and how the Ruby ecosystem continues to thrive with innovative libraries and first-party tools.Beyond code, Adrian shares how community and creativity intersect in tech — from organizing FriendlyRB in Romania to inventing a Ruby Passport that lets conference-goers collect stamps and connect with peers across events.🎯 Whether you’re a Rubyist, Rails engineer, or curious about how productivity frameworks scale, this episode is packed with insights, stories, and lessons from the trenches.---Chapters00:00 Introduction to Adrian Marin and His Journey04:33 The Early Days of Programming06:58 Nostalgia for the Old Web Development Days08:53 Evolution of Web Development Tools12:45 The Impact of AI on Development14:11 The Rise of Tailwind CSS15:16 Adrian's Love for Tailwind CSS20:46 Transitioning from PHP to Ruby on Rails29:35 Building AVO: A Toolkit for Internal Tools34:31 Understanding Hotwire in Rails36:29 Understanding Client-Server Interactions39:30 The Ruby Ecosystem and Community Engagement44:36 Creating Memorable Conferences46:10 Innovative Networking: The Ruby Passport54:46 Getting Started with Ruby on Rails01:06:24 Balancing Work and Family Life01:07:42 Recommended Reads for Developers---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%C3%B1ors-scale/---#rubyonrails #ruby #rails #hotwire #tailwindcss #avo #softwaredevelopment #developercommunity #webdevelopment #engineeringculture #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Are you building with Rails at scale? Share your experience below 👇

In this episode of Señors @ Scale, Andreas Panopoulos — Staff Software Engineer at Hack the Box and co-organizer of Vue.js Athens — joins Dan to share his journey from building jQuery landing pages to leading frontend teams powered by Vue.Andreas walks us through the evolution of Vue.js, from version 2 to 3, and how features like the Composition API and TypeScript support transformed developer experience. He shares what it was like to rewrite Hack the Box’s Academy platform on Nuxt 3, why Vue scales for millions of users, and what performance practices every frontend team should keep in mind.We also dive into the human side of engineering: why understanding the basics of JavaScript is essential even when using frameworks, how public speaking and community organizing can accelerate growth, and why keeping things simple often beats overengineering.Along the way, Andreas reflects on lessons learned from his early career, his transition to staff engineer, and the role of community in shaping modern engineering culture.🎯 Whether you’re a Vue enthusiast, frontend engineer, or developer community organizer, this episode is packed with practical insights and stories from the trenches.Chapters00:00 Introduction to Andreas Panopoulos02:56 Andreas's Journey into Programming09:52 Transitioning to Frontend Development17:52 Current Role at Hack the Box21:41 Vue 2 vs Vue 3: A Developer's Perspective26:13 Lessons Learned from Early Career30:21 Transition to Staff Engineer34:46 Project Updates and Future Plans35:54 Understanding Hack the Box38:25 Security Practices in Development39:47 Performance and User Experience42:03 Vue's Popularity in Athens46:12 Business Logic and Frameworks47:27 Challenges in Finding Speakers52:26 Public Speaking Experiences56:34 Relaxation and Personal Interests58:00 Book RecommendationsFollow & 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/#vuejs #vue3 #nuxt #frontenddevelopment #javascript #hackthebox #softwareengineering #webdevelopment #engineeringculture #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Are you using Vue at scale in your team? Share your experience below 👇

In this episode of Señors @ Scale, Faris Aziz — Staff Front-End Engineer at Small PDF, international speaker, and co-founder of ZurichJS — joins Dan to talk about scaling both frontend architecture and engineering culture.Faris shares his unconventional journey from CrossFit trainer to software engineer, and how personal projects became his gateway into tech. He opens up about the realities of working on applications serving 30 million+ users, why BFF architecture is such a powerful pattern for managing data between front-end and back-end, and the hidden pitfalls of performance when building with React and Next.js.We also dig into the human side of architecture: how observability, error management, and developer experience shape reliable systems; why ownership and accountability drive better outcomes than process checklists; and how stress can be reframed when you work in a culture of trust.And beyond code, Faris reflects on community: what it takes to co-found a thriving JavaScript meetup in Zurich, why meetups are “mini start-ups,” and how community building fuels personal and professional growth.🎯 Whether you’re a frontend engineer, engineering manager, or developer community organizer, this episode is packed with architectural insights and real-world lessons from the trenches.---Chapters00:00 Introduction to Faris Aziz and His Journey05:46 From Fitness to Coding: The Bootcamp Experience08:33 Building Personal Projects and Learning by Doing11:28 The Impact of Global Work Culture on Engineering14:24 Co-founding ZurichJS: Building Community in Tech19:57 Technical Insights: React vs. Next.js at Scale25:38 Scaling Challenges in Data Representation31:35 Understanding the BFF Architecture40:44 Authentication and Security in BFFs43:30 Comparing BFF with GraphQL and TRPC49:09 Innovative UI Approaches in Application Development51:27 A Day in the Life of a Staff Engineer52:13 Strategic Engineering at Scale55:46 Managing Stress and Engineering Culture01:01:06 Finding Balance in High-Stakes Environments01:05:37 Book Recommendations and Personal Insights---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%C3%B1ors-scale/#frontend #nextjs #bffarchitecture #javascript #react #softwaredevelopment #engineeringculture #techevents #zurichjs #webdevelopment #señorsatscaleDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Have you ever built — or struggled with — frontend architecture at scale? Share your experience below 👇

In this episode of Señors @ Scale, Aris — founder of CityJS and longtime community builder — joins Dan to talk about the journey from small local meetups to organizing one of the fastest-growing global JavaScript conferences.Aris shares his unlikely path into programming, starting as a basketball-loving student in Greece with no computer at home, to innovating on the job with early Java projects, and eventually embracing frontend frameworks like Angular, React, and Vue. Along the way, he reflects on the competitive yet collaborative nature of programming, the evolution of the frontend ecosystem, and why choosing the “best” framework often depends less on hype and more on context.We dig into the heart of community building: why meetups matter beyond the pizza, how to create opportunities for first-time speakers, and the hidden challenges of finding sponsors and keeping attendees engaged. Aris also opens up about the leap from organizing monthly gatherings to running large-scale international conferences, and why he believes conferences should be treated as professional training — not optional perks.🎯 Whether you’re a frontend developer, a meetup organizer, or simply curious about what it takes to build thriving developer communities, this conversation offers a rare inside look at the messy, human, and rewarding world of tech events.Chapters00:00 Introduction and Name Origins04:14 Aris's Journey into Programming06:56 First Job and Early Experiences09:32 Transition to Frontend Development12:23 Framework Preferences and Ecosystem14:56 Meetups and Community Building17:44 The Importance of Networking20:11 Organizing Meetups and Conferences22:54 Creating Opportunities for New Speakers25:41 Challenges in Meetup Attendance27:32 Sponsorship Strategies for Meetups34:28 Transitioning from Meetups to Conferences39:37 The Value of Conferences for ProfessionalsFollow & 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/#javascript #conferences #developercommunity #frontend #meetups #cityjs #softwareengineering #techevents #communitybuilding #señorsatscale #webdevelopmentDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Have you ever spoken — or wanted to speak — at a tech meetup or conference? Share your experience below 👇

In this episode of Señors @ Scale, Eric Rasmussen — creator of Redux Form and React Final Form, now Principal Product Engineer at Attio — joins Dan to talk about building open source at scale, developer experience, and the lessons learned from two decades of shipping frontend software.Eric shares his journey from early experiments with BASIC and FoxPro to designing Attio’s secure SDK ecosystem, which enables third-party developers to extend a next-generation CRM. Along the way, he opens up about the pitfalls of feature creep in open source, the evolution from Redux Form to React Final Form, and how AI is already reshaping documentation.We dive into why developer ergonomics matter more than ever, how strict design systems preserve product quality, and what it really takes to manage breaking changes when your code runs in thousands of apps. Eric also offers practical advice for juniors looking to break into open source, as well as insights on testing strategies, state machines, and the libraries he can’t live without.🎯 Whether you’re maintaining a popular open source library, building SDKs for other developers, or just curious about the hidden costs of “yes” in software design, this conversation is full of hard-won lessons from the trenches.Chapters00:00 Introduction to Eric Rasmussen and His Journey05:34 Early Programming Experiences and First Job08:01 Transition to Principal Engineer at Atio10:37 Understanding Atio's CRM and Its Market Position13:08 Developer Experience and Building for Other Developers15:29 The Role of Documentation in Developer Tools18:03 SDK Development and Framework Choices20:30 Building a Secure and Custom Runtime22:54 Managing Breaking Changes and Developer Feedback25:28 The Creation of Redux Form and Its Impact27:59 Testing Strategies for SDKs and Components33:48 Building a Design System35:27 React Final Form: Evolution and Insights41:11 The Journey from Redux to React Final Form46:08 Choosing State Management Solutions48:10 Overused Libraries and Tools54:25 Advice for Junior Developers59:32 Book Recommendations and Closing Thoughts01:04:25 OutroFollow & 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/#opensource #reduxform #reactfinalform #frontend #developerexperience #sdk #documentation #designsystems #softwareengineering #señorsatscale #techtalks #webdevelopmentDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. What’s your favorite open source library — and how has it shaped your work? Share below 👇Don’t forget to like, comment, and subscribe for more engineering stories from the front lines.

In this episode of Señors @ Scale, Front-End Engineer and ADPList Top 100 Mentor Eduardo Aparicio-Cardenas joins Dan to talk about mentorship, career growth, and leadership at scale — from debugging real-world performance issues to guiding engineers through promotions and burnout.Eduardo shares lessons from 15+ years building web products, why perception often matters more than output for promotions, and how curiosity and frustration can be powerful motivators for learning. He breaks down what makes a strong tech lead, how to run compelling mock interviews, and why knowledge sharing is the ultimate multiplier for both mentor and mentee.They also discuss system design interviews (and why front-end design is often overlooked), strategies for breaking down problems, and what it truly means to grow from senior to staff to principal engineer.🎯 Whether you're mentoring juniors, preparing for a promotion, or just trying to be a better communicator on your team, this episode is packed with practical advice for engineers navigating their careers.Get in touch with Eduardo here https://eduardo-aparicio-cardenes.website, https://medium.com/@byeduardoac and if you are looking for a mentor: https://adplist.org/mentors/eduardo-dev or https://eduardo-aparicio-cardenes.website/mentor-profileChapters00:00 Journey to Front-End Engineering11:11 Transitioning to Happening and Current Projects18:51 Becoming a Mentor and Sharing Knowledge19:14 The Journey of Mentorship23:37 Understanding Mentee Needs28:18 The Importance of Sharing Knowledge31:43 Personal Growth and Agency36:13 Navigating Promotions and Perception39:16 Navigating Project Expectations in Tech Companies41:56 The Role of a Tech Lead44:39 Effective Communication in Tech47:18 Interview Strategies for Success49:54 System Design Insights52:22 Handling Burnout and Career Growth54:48 Recommended Reads for ProfessionalsFollow & 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/#softwareengineering #mentorship #frontend #career #promotion #systemdesign #burnout #staffengineer #leadership #señorsatscale #techtalks #webdevelopmentDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Have you had a mentor who changed the course of your career? Share your story below 👇

In this episode of Señors @ Scale, Staff Frontend Engineer Matheus Albuquerque joins Dan to talk all things React, rendering, and real-world performance at scale.They dive into React scheduling and fibers, why rendering strategies always “depend,” and how to make performance decisions when millions of users are at stake. Mateusz shares war stories about dropdowns with 16,000 options, migrating a stable React app to SSR (and regretting it), and what happens when browsers you’ve never heard of load your app in production.They also unpack how feature flags and ring deployments help ship safely, why junior devs struggle when they learn frameworks before fundamentals, and how mentorship + RFC-driven development can keep teams moving in the right direction.🎯 Whether you’re debugging hydration issues, experimenting with performance APIs, or mentoring new frontend engineers, this one is full of sharp lessons from the trenches of large-scale React.*Chapters*00:00 Introduction to Mateusz Albuquerque04:19 The Journey to Programming06:57 Diving into Frontend Development09:33 Understanding React Scheduling12:21 Rendering Strategies in React15:01 Web Performance Challenges and Solutions17:30 Techniques for Optimizing Performance20:01 Common Challenges for New Developers32:13 The Importance of Foundational Knowledge33:56 The Value of RFC-Driven Development35:42 Proud Achievements in Software Development39:57 Challenges and Bugs in Large Scale Applications46:11 Best Practices for Frontend Development49:40 Recommended Reading for Developers54:22 Personal Interests and Relaxation TechniquesFollow & Subscribe:📸 Instagram: [  / senorsatscale  ](  / senorsatscale  )📸 Instagram: [  / neciudev  ](  / neciudev  )🎙 Podcast URL: [https://neciudan.dev/senors-at-scale](https://neciudan.dev/senors-at-scale)📬 Newsletter: [https://neciudan.dev/subscribe](https://neciudan.dev/subscribe)💼 LinkedIn: [  / neciudan  ](  / neciudan  )💼 LinkedIn: [  / se%c3%b1ors-scale  ](  / se%c3%b1ors-scale  )Keywords:Mateusz Albuquerque, React, frontend development, web performance, programming challenges, mentorship, feature flags, deployment strategies, tech conferences, performance optimizationDon’t forget to like, comment, and subscribe for more engineering stories from the front lines. Have you ever been burned by performance issues in production React apps? Share your story below 👇

In this engaging conversation, Jose Calderon, a lead software engineer at JP Morgan Chase, shares his journey into software engineering, his passion for Java and the Spring ecosystem, and the importance of documentation and decision-making in software architecture. He discusses the evolving role of AI in coding, offers tips for learning Java, and emphasizes the significance of mentoring future engineers. The conversation also touches on crafting engaging conference talks, testing strategies for enterprise software, and the balance between refactoring and rewriting code. Jose concludes with book recommendations and insights into the gaming world as a form of relaxation.TakeawaysJose's journey into software engineering began with a passion for fixing computers and playing games.Java's ecosystem is robust, with a strong community and rapid evolution.Documentation of architectural decisions is crucial for future reference and understanding.AI tools can enhance productivity but should not replace fundamental coding skills.Unit tests should serve as documentation for code behavior.The choice between refactoring and rewriting code depends on the stability and control of the existing system.Chaos engineering helps teams prepare for unexpected failures in production environments.Mentoring future engineers is essential for fostering a strong tech community.Crafting engaging conference talks involves storytelling and relatable analogies.Gaming can serve as a form of relaxation and mental recharge for developers.Sound Bites"You can build whatever you want and play around.""The world is your oyster with Java.""You can simplify and still be effective."Keywordssoftware engineering, Java, Spring, coding, technology, software architecture, mentoring, conference talks, decision making, testing strategies, chaos engineering, AI in coding, book recommendations, gaming

🎙️ In this episode of Señors @ Scale, Principal Engineer Tudor Barbu (ex-Personio, Skyscanner) shares two decades of software engineering lessons — from hacking on cassette-based machines to leading platform efforts in modern frontend teams.We talk debugging horror stories, the evolution of tech roles post-pandemic, and the shift from chasing technical perfection to delivering user value. Tudor breaks down what it means to be a pragmatic engineer, how he interviews for adaptability, and why ownership (not just code) drives results.Whether you're mentoring juniors, scaling architecture, or just tired of reading octal bugs — this one’s for you.