In today's episode, we’re diving deep into web performance — and not just looking at numbers, but learning how to understand them and act on them.

I’m joined by Maxi, and together we break down:

• What Core Web Vitals are (LCP, FID, CLS) and why they matter beyond just SEO
• How to measure your site’s performance using tools like Lighthouse, PageSpeed Insights, and field data from real users
• What the baseline thresholds mean — and how slow performance actually feels to users
• How to investigate and fix underperforming metrics — including practical tips for debugging Largest Contentful Paint (LCP) problems
• Why JavaScript is often the hidden villain behind slow pages — and what you can do to manage bundle size and third-party scripts

Monorepos are gaining popularity, but what do they really offer—and how do you make them work at scale?

In this episode of Commit to growth I sit down with Nicolas to explore how monorepos help simplify collaboration, streamline CI/CD pipelines, and improve the developer experience.

We discuss when monorepos make sense, how to avoid common pitfalls, and which tools (like Nx, PNPM, and Bazel) can make adoption smoother. You’ll also hear a real-world migration story that reduced build and release times.

If you're working on a large frontend and want to future-proof your architecture, this episode is packed with actionable insights.

Looking for a job as a junior or senior developer? The job market is shifting, AI is changing how companies hire, and competition is tougher than ever. So, how can you stand out?

In this episode of Commit to Growth, I sit down with Briab, a developer and mentor who has helped many engineers land jobs through his mentorship program Parsity. We cover:

✅ The current job market & why hiring has become more competitive
 ✅ How AI tools like ChatGPT & GitHub Copilot are changing developer skills
 ✅ Why junior developers struggle to land their first job—and what actually works
 ✅ The biggest mistakes senior developers make when switching jobs
 ✅ The power of mentorship and how it accelerates career growth

Web development has come a long way—from the static pages of the early internet to the powerful, scalable applications we build today. But how did we get here, and what are the challenges developers face when scaling modern applications?

In this episode, I sit down with Matteo to dive deep into:
✅ The early days of JavaScript and the rise of scalability challenges
✅ How frameworks like React, Angular, and Vue revolutionized development (but also introduced new problems)
✅ The real-world complexities of scaling modern web applications
✅ How design systems improve scalability

Episode Summary:
In this episode, we dive into the challenges and strategies of scaling frontend development. From platform teams to microfrontends and automated testing, we explore how engineering teams can stay productive while ensuring high performance and quality.

Key Topics Discussed:
✅ The role of platform teams in scaling frontend development
✅ How microfrontends can help large teams work independently
✅ The importance of automated testing in maintaining code quality
✅ Best practices for keeping engineering teams productive
✅ Strategies for balancing performance and maintainability

Resources & Links:
📌 Omri’s talk at React Day Berlin – https://gitnation.com/contents/the-superpower-of-asts-how-we-saved-16percent-on-our-bundle-size
📌 In-depth article on AST tools – https://engineering.monday.com/the-superpower-of-babel-how-we-saved-16-on-our-bundle-size/
📌 Omri’s personal website – http://omrilavi.com/

Connect with Us:
🎙 Follow the podcast for more episodes on software development, engineering strategies, and tech leadership.
📩 Have questions or suggestions? Reach out to us at [email protected]

Thank you for listening! Don't forget to subscribe and share this episode with your fellow developers.

Many developers see testing as a time-consuming task that slows down progress. But in reality, good testing practices accelerate development by catching issues early, reducing debugging time, and ensuring smoother deployments.

In this episode, we’ll explore:
✅ How testing actually speeds up development rather than slowing it down.
✅ Why a strong team culture leads to faster and more efficient development.
✅ Real-world examples of teams that have nailed this approach.

In this episode, I sit down with Stefano to talk about what it really takes to scale and maintain frontend applications. We cover:

• Design Systems & Visual Coverage – Why design systems matter and how they improve UI consistency.
• Lessons from Big Frontend Codebases – What we’ve learned from working with massive codebases and how to manage complexity.
• Writing Code for the Next Developer – Best practices to ensure your code is readable, maintainable, and easy to onboard new engineers.

If you’ve ever wondered how to build scalable, maintainable frontend systems while keeping things developer-friendly, this episode is for you!