diff --git a/src/bun.js/api/server/RequestContext.zig b/src/bun.js/api/server/RequestContext.zig
index 42ed6a3bf6..8e522b9567 100644
--- a/src/bun.js/api/server/RequestContext.zig
+++ b/src/bun.js/api/server/RequestContext.zig
@@ -1871,6 +1871,9 @@ pub fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool,
                         switch (stream.ptr) {
                             .Invalid => {
                                 this.response_body_readable_stream_ref.deinit();
+                                // Stream is invalid, render empty body
+                                this.doRenderBlob();
+                                return;
                             },
                             // toBlobIfPossible will typically convert .Blob streams, or .File streams into a Blob object, but cannot always.
                             .Blob,
diff --git a/test/regression/issue/26394.test.ts b/test/regression/issue/26394.test.ts
new file mode 100644
index 0000000000..b186ee7f55
--- /dev/null
+++ b/test/regression/issue/26394.test.ts
@@ -0,0 +1,86 @@
+import { expect, test } from "bun:test";
+
+// https://github.com/oven-sh/bun/issues/26394
+// Race condition in Bun.serve() where requests can arrive before routes are fully registered,
+// causing the default "Welcome to Bun!" response instead of the configured handler's response.
+
+test("concurrent Bun.serve instances should not return Welcome to Bun", async () => {
+  const serverCount = 60;
+  const servers: ReturnType<typeof Bun.serve>[] = [];
+
+  try {
+    // Create many servers concurrently
+    for (let i = 0; i < serverCount; i++) {
+      servers.push(
+        Bun.serve({
+          port: 0,
+          fetch: () => new Response("OK"),
+        }),
+      );
+    }
+
+    // Make concurrent requests to all servers
+    const responses = await Promise.all(
+      servers.map(async server => {
+        const res = await fetch(`http://127.0.0.1:${server.port}/`);
+        return res.text();
+      }),
+    );
+
+    // Verify no "Welcome to Bun!" responses - check for both debug mode message and production mode
+    for (let i = 0; i < responses.length; i++) {
+      expect(responses[i]).not.toContain("Welcome to Bun");
+      expect(responses[i]).not.toBe(""); // Production mode returns empty for renderMissing
+      expect(responses[i]).toBe("OK");
+    }
+  } finally {
+    // Clean up - guaranteed to run even if assertions fail
+    for (const server of servers) {
+      server.stop();
+    }
+  }
+});
+
+test("Bun.serve should be ready to handle requests immediately after returning", async () => {
+  // Test a single server with immediate fetch - this tests if the server is ready synchronously
+  using server = Bun.serve({
+    port: 0,
+    fetch: () => new Response("handler response"),
+  });
+
+  // Immediately fetch - if there's a race condition, this might return "Welcome to Bun!"
+  const response = await fetch(`http://127.0.0.1:${server.port}/`);
+  const text = await response.text();
+
+  expect(text).toBe("handler response");
+});
+
+test("multiple sequential Bun.serve instances with immediate requests", async () => {
+  // Create servers sequentially and immediately request from each
+  const results: string[] = [];
+  const servers: ReturnType<typeof Bun.serve>[] = [];
+
+  try {
+    for (let i = 0; i < 20; i++) {
+      const server = Bun.serve({
+        port: 0,
+        fetch: () => new Response(`server-${i}`),
+      });
+      servers.push(server);
+
+      // Immediately fetch from the server
+      const response = await fetch(`http://127.0.0.1:${server.port}/`);
+      results.push(await response.text());
+    }
+
+    // Verify all responses match expected
+    for (let i = 0; i < results.length; i++) {
+      expect(results[i]).toBe(`server-${i}`);
+    }
+  } finally {
+    // Clean up - guaranteed to run even if assertions fail
+    for (const server of servers) {
+      server.stop();
+    }
+  }
+});