Naveh Sadeh
Full Stack Team Lead at Harmonya
Jerusalem, Israel
Actions
I'm a Full Stack Team Lead at Harmonya, where I lead the development of scalable, high-performance applications with a strong focus on JavaScript. I joined Harmonya after playing a key role at CyberSixgill, contributing to its successful exit, and after serving in 8200 in both mandatory and professional service. Along the way, I also worked as a freelancer, delivering end-to-end projects for a variety of clients and companies. Beyond tech, I'm a musician and guitarist, and in my free time, I’m passionate about education, working with teenagers to guide and inspire them. I also speak at meetups and write articles on JavaScript, sharing insights on development best practices, architecture, and performance improvements.
Area of Expertise
Topics
Why Is My Node.js Server Slow? Understanding the Event Loop and Fixing Bottlenecks
Node.js is known for its speed and efficiency, but sometimes, an application that starts off fast gradually slows down under load. Requests take longer to process, the server becomes sluggish, and debugging the issue isn’t always straightforward.
At the heart of this is the event loop - the engine that drives all asynchronous operations in Node.js. But how does it really work? And more importantly, how do we make sure we’re using it correctly?
What you’ll take away:
✅ What the event loop actually does, in simple terms
✅ Common mistakes that block the event loop and slow down performance
✅ How to write non-blocking code that keeps your server responsive
✅ Simple tools to detect and fix performance issues
No prior deep knowledge of Node.js internals is needed - this session is designed to help you understand and apply event loop best practices in your own projects. If you’ve ever wondered why your server isn’t handling requests as fast as expected, this talk will give you the answers.
Why Is My Node.js App Slow? A Practical Guide to Performance Debugging
Every Node.js developer has faced this moment - your API was working fine yesterday, but today, it's suddenly slow. Requests take longer, CPU usage spikes, and the backend struggles under load. But where do you even start looking?
In this talk, we’ll break down a practical, step-by-step approach to finding and fixing performance bottlenecks in Node.js. Using built-in tools and profiling techniques, we’ll see how to measure execution time, identify slow functions, and optimize the event loop for faster and more efficient code.
✅ How to use perf_hooks to measure execution time in your code
✅ How CPU profiling helps find slow functions and blocking operations
✅ How to spot and fix memory leaks and event loop delays
✅ Simple optimizations that immediately improve performance
If you've ever struggled with a Node.js app that felt sluggish for no clear reason, this session will give you the tools and techniques to diagnose and fix it like a pro.
Tiny Code, Huge Impact: How Small Changes Unlock Big Data Performance
Working with big data doesn't always mean big infrastructure. Sometimes, it just takes a few lines of smart code.
In this talk, I'll demonstrate how seemingly minor JavaScript tweaks can lead to dramatic performance improvements - even at massive scale. Through real-world examples, we'll see how choosing the right loop, restructuring a simple object, or avoiding a hidden sync trap can cut execution time by 90% or more.
The talk isn't just for JS developers: whether you're a data engineer, analyst, or someone who reads code but doesn't write it daily - this session will show you how understanding the platform you're working with can eliminate bottlenecks without scaling up hardware.
Expect quick wins, “aha” moments, and a new appreciation for the power of the small stuff.
Making Node.js Multi-Threaded - A Practical Guide to Worker Threads
Node.js is famously single-threaded, but that doesn’t mean it can’t handle CPU-intensive tasks. Worker threads allow us to run JavaScript in parallel, offloading heavy computations without blocking the event loop. However, using them incorrectly can lead to crashes, memory leaks, and performance regressions instead of improvements.
In this talk, we’ll demystify worker threads and explore when and how to use them properly. We’ll cover the common pitfalls developers encounter, how to manage communication between threads efficiently, and best practices to keep your app stable and performant.
✅ When to use worker threads - and when they’re not the right tool
✅ How to efficiently send and receive data between threads
✅ The trade-offs between worker threads and child processes
✅ Common mistakes that cause performance issues - and how to avoid them
If you’ve ever wondered whether worker threads could help speed up your app but weren’t sure where to start, this session will give you a clear and practical roadmap to using them safely.
JavaScript Performance Myths vs. Reality: What Really Speeds Up Your Code?
We all know that optimizing JavaScript can be tricky. But what if I told you that some of the biggest performance wins don’t come from complex refactors or major architecture changes - but from tiny tweaks in the right places?
In this talk, we’ll go behind the scenes of JavaScript and the browser to uncover the hidden costs of everyday code. We’ll explore how the JavaScript engine actually executes our code, why certain patterns slow things down, and how to write code that works with the engine instead of against it.
Through real-world examples and surprising case studies, we’ll see how subtle changes - like reordering conditions, adjusting loops, and avoiding hidden pitfalls - can dramatically improve execution time and memory usage.
What you’ll take away:
✅ Practical optimizations that make a real difference in performance
✅ Common JavaScript patterns that secretly slow down your code - and how to fix them
✅ How JavaScript engines and browsers optimize execution under the hood
✅ Simple, effective techniques to make your code faster without overcomplicating it
If you've ever wondered why a seemingly innocent function is slowing down your app, this talk will help you understand what’s happening behind the scenes - and how to make your JavaScript fly.
Forget REST - How gRPC Can Make Your API 10x Faster
For years, RESTful APIs have been the default choice for backend development. But as applications scale, REST starts showing its limits - over-fetching, under-fetching, and inefficient network usage become real bottlenecks. Enter gRPC and GraphQL - two powerful alternatives that tackle API performance from completely different angles.
gRPC is designed for speed and efficiency, leveraging binary serialization, HTTP/2, and built-in streaming to enable blazing-fast communication between services. Meanwhile, GraphQL offers flexibility and control over data fetching, solving many of REST’s inefficiencies. But which one is right for your application? And when does REST still make sense?
What you’ll take away:
✅ Why REST struggles at scale - and how gRPC & GraphQL solve its biggest issues
✅ How gRPC’s binary protocol and multiplexed streams make APIs significantly faster
✅ When to use GraphQL for flexibility vs. gRPC for raw performance
✅ The trade-offs: simplicity vs. efficiency, tooling vs. control, JSON vs. Protobuf
✅ How to integrate gRPC into an existing Node.js backend with minimal friction
If you've ever felt that REST is holding your API back, this talk will give you the insights and tools to choose the best architecture for your next backend project - one that delivers both speed and scalability.
Effortless Performance: Harnessing the GPU to Supercharge Your React App
As JavaScript developers, we spend a lot of time optimizing React components, fine-tuning re-renders, and squeezing every bit of performance out of our code. But what if I told you that some of the biggest performance wins aren’t in your JS at all?
CSS can have a huge impact on how fast and smooth your app feels - especially when it comes to animations, transitions, and rendering performance. In this talk, we’ll explore how the browser processes styles, why some CSS properties can block your UI thread, and how leveraging GPU-accelerated techniques can make everything feel effortlessly smooth.
We’ll break down real-world cases where CSS caused performance bottlenecks in React apps, and how small tweaks - without touching your JavaScript - unlocked massive improvements in responsiveness and animation speed.
What you’ll take away:
✅ How inefficient CSS can slow down your React components (and how to fix it)
✅ Why offloading work to the GPU makes your UI feel snappier
✅ Simple CSS optimizations that eliminate jank without touching your JS
✅ Real-world lessons from debugging slow animations and sluggish interactions
If you’re a React developer who wants your app to feel as fast as it runs, this talk will change the way you think about CSS performance.
Caching Real-Time Data at Scale: From Slow APIs to Instant UX
We all know caching boosts performance - but most systems still treat it as a trick for static assets. What if API responses could be cached just as effectively - and stay fresh, fast, and distributed, even without waiting for the backend?
In this talk, I'll share how we built a real-time, production-grade caching layer for API data using modern browser APIs: CacheStorage, Service Workers, WebSocket, and BroadcastChannel. This solution reduced backend load, enabled instant responses, and kept data fresh across tabs - at scale.
We'll explore:
✅ Smart API caching strategies
✅ Offline-capable responses with Service Workers
✅ Real-time freshness via WebSocket
✅ Cross-tab sync with BroadcastChannel
✅ Lessons from production
Whether you're building dashboards, data-heavy apps, or real-time views, you'll leave with practical tools to dramatically boost frontend performance without sacrificing consistency.
Never Wait for an API Again: Unlocking CacheStorage for Blazing Speed
We all know caching can speed up our apps - but most developers think of CacheStorage as a tool for storing assets like images, scripts, and stylesheets. What if I told you that the real power of CacheStorage lies in API response caching?
By intelligently storing and serving HTTP responses directly from the browser, we can significantly reduce server load, eliminate redundant network requests, and deliver near-instant data retrieval - all while keeping the cache fresh and up to date. This means faster page loads, better offline support, and a smoother user experience without sacrificing real-time data accuracy.
After implementing this approach in three different companies - and seeing firsthand how it dramatically improved load times, reduced backend strain, and made the app feel instantly responsive - I want to share the key strategies that make it work.
What You’ll Take Away:
✅ How CacheStorage API works and why it’s better than LocalStorage or IndexedDB for API caching
✅ How to cache API responses and serve data instantly without hitting the network
✅ Smart strategies for cache invalidation, versioning, and dynamic updates
✅ How to integrate CacheStorage with React Query / SWR for even better performance
✅ Real-world examples of how caching API responses can make your app feel native-fast
If you’ve ever struggled with slow API responses or unnecessary network calls, this talk will show you how to take control of caching and make your React app feel lightning-fast.
The Edge of Performance: Pushing Node.js to Its Limits
Node.js is great for I/O-heavy tasks - but what happens when you throw massive computations and high memory loads at it? How far can you push it before things start breaking?
After 10 years of writing JavaScript for massive datasets, I've seen Node.js crash and burn under extreme CPU and RAM pressure - and I've learned how to stop it. In this talk, I'll share real-world lessons from optimizing Node.js for heavy computation, covering what works, what doesn't, and what you should absolutely avoid.
We'll dive into worker threads, memory management, native bindings, and practical optimizations that can stretch Node.js beyond its usual limits. If you've ever found yourself battling CPU bottlenecks or dealing with mysteriously high memory usage - this talk is for you!
What you’ll take away:
✅ How far Node.js can go before CPU and memory become a problem
✅ The biggest pitfalls that slow down heavy computations
✅ Practical optimizations to boost performance under extreme load
✅ How to use worker threads, buffers, and native modules effectively
NodeTLV 2025 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top