--- title: Bringing serverless functions to the speed of wire description: Modal has redesigned its I/O plane for serverless Function Calls, reducing end-to-end latency by ~80ms at p50 and adding geographic distribution across 4+... canonical: https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Bringing serverless functions to the speed of wire | daily.dev og:description: Modal has redesigned its I/O plane for serverless Function Calls, reducing end-to-end latency by ~80ms at p50 and adding geographic distribution across 4+... og:url: https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r og:image: https://api.daily.dev/og/posts/sxzUeP07r.png og:image:alt: Bringing serverless functions to the speed of wire og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Bringing serverless functions to the speed of wire **[Modal](https://daily.dev/sources/modal_labs)** · 6 min read · 6 upvotes · 1 comments ## Summary Modal has redesigned its I/O plane for serverless Function Calls, reducing end-to-end latency by ~80ms at p50 and adding geographic distribution across 4+ regions. The new system lets users specify a routing_region to minimize network overhead between clients and containers. Key engineering changes include a full rewrite of the server layer from Python to Go (for better concurrency under gRPC load), moving non-critical work to async background tasks, minimizing hot-path Redis interactions, client-side metadata caching, and JWT-based auth refresh. The post also covers Redis 7.1 vs 7.2/Valkey tradeoffs for input queue performance, and offers user-facing tips: choose a nearby routing_region, keep payloads under 2MiB, and batch small inputs to reduce network hops. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### How much latency did Modal's new I/O plane save for Function Calls? End-to-end Function Call latencies dropped by roughly 80ms at p50 after Modal migrated all functions running on Modal to its new I/O plane in us-east. The new plane is also geographically distributed across at least 4 regions, and a routing_region Function flag lets callers specify which region routes their requests, cutting further network overhead for regionally distant clients. _Developers tuning serverless latency can follow infrastructure deep dives like this one on daily.dev._ ### Why did Modal choose Redis 7.1 over Redis 7.2 for their input queues built on Redis streams? Modal stuck with Redis 7.1 because engine CPU spiked aggressively on Redis 7.2 and later during input queue load testing using Redis streams. The specific culprit was traced to a change in a Redis pull request (PR #11012), which caused the CPU regression under their workload. _Anyone evaluating a Redis version bump can weigh production tradeoffs like this via daily.dev._ ### Why did Modal rewrite its server layer in Go instead of Python for its serverless I/O plane? Go's lightweight concurrency model makes it a better fit than Python for building highly concurrent gRPC servers. Async Python is cooperatively single-threaded, so its event loop is prone to lag under CPU-intensive operations like writing large payloads over the network, which hurts performance at scale. _Teams weighing Go versus Python for high-concurrency services can compare real tradeoffs via daily.dev._ ## Community discussion Top comments from developers on daily.dev. **@trevorsuna** · 0 upvotes > The 80 ms gain shows how much latency can live outside the function itself. Regional routing and client-side metadata caching are useful wins, but moving non-critical work off the hot path is probably the most reusable lesson for any high-volume RPC service. ## Similar posts on daily.dev - [Nobody Likes Lag](https://daily.dev/posts/nobody-likes-lag-2r6ajv0sw) · Hacker News · 1 upvotes · 0 comments --- Tags: [#golang](https://daily.dev/tags/golang), [#serverless](https://daily.dev/tags/serverless), [#distributed-systems](https://daily.dev/tags/distributed-systems), [#redis](https://daily.dev/tags/redis), [#grpc](https://daily.dev/tags/grpc) [View this post on daily.dev](https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Bringing serverless functions to the speed of wire","url":"https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r"},"datePublished":"2026-08-04T21:13:43.118Z","dateModified":"2026-09-13T19:55:26.504Z","description":"Modal has redesigned its I/O plane for serverless Function Calls, reducing end-to-end latency by ~80ms at p50 and adding geographic distribution across 4+...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b054718110fbeddac0d22d652674a1f8?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b054718110fbeddac0d22d652674a1f8?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Modal","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Modal","logo":"https://media.daily.dev/image/upload/s--HfKZHzC1--/f_auto/v1750946306/logos/modal_labs","url":"https://daily.dev/sources/modal_labs"},"commentCount":1,"discussionUrl":"https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":6},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":1}],"keywords":"golang,serverless,distributed-systems,redis,grpc","timeRequired":"PT6M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Modal","item":"https://daily.dev/sources/modal_labs"},{"@type":"ListItem","position":3,"name":"Bringing serverless functions to the speed of wire"}]} {"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r","comment":[{"@type":"Comment","text":"The 80 ms gain shows how much latency can live outside the function itself. Regional routing and client-side metadata caching are useful wins, but moving non-critical work off the hot path is probably the most reusable lesson for any high-volume RPC service.","datePublished":"2026-08-06T02:44:11.064Z","url":"https://daily.dev/posts/sxzUeP07r#c-WM5levi9v","author":{"@type":"Person","name":"Trevor Suna","url":"https://daily.dev/trevorsuna","image":"https://media.daily.dev/image/upload/s--dZ7gXxpp--/f_auto/v1784081551/avatars/avatar_EMoP47rpuw8DNjhp6R1b6?_a=BAMAMicg0"}}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/bringing-serverless-functions-to-the-speed-of-wire-sxzuep07r#faq","mainEntity":[{"@type":"Question","name":"How much latency did Modal's new I/O plane save for Function Calls?","acceptedAnswer":{"@type":"Answer","text":"End-to-end Function Call latencies dropped by roughly 80ms at p50 after Modal migrated all functions running on Modal to its new I/O plane in us-east. The new plane is also geographically distributed across at least 4 regions, and a routing_region Function flag lets callers specify which region routes their requests, cutting further network overhead for regionally distant clients. Developers tuning serverless latency can follow infrastructure deep dives like this one on daily.dev."}},{"@type":"Question","name":"Why did Modal choose Redis 7.1 over Redis 7.2 for their input queues built on Redis streams?","acceptedAnswer":{"@type":"Answer","text":"Modal stuck with Redis 7.1 because engine CPU spiked aggressively on Redis 7.2 and later during input queue load testing using Redis streams. The specific culprit was traced to a change in a Redis pull request (PR #11012), which caused the CPU regression under their workload. Anyone evaluating a Redis version bump can weigh production tradeoffs like this via daily.dev."}},{"@type":"Question","name":"Why did Modal rewrite its server layer in Go instead of Python for its serverless I/O plane?","acceptedAnswer":{"@type":"Answer","text":"Go's lightweight concurrency model makes it a better fit than Python for building highly concurrent gRPC servers. Async Python is cooperatively single-threaded, so its event loop is prone to lag under CPU-intensive operations like writing large payloads over the network, which hurts performance at scale. Teams weighing Go versus Python for high-concurrency services can compare real tradeoffs via daily.dev."}}]} ```