API Integration Challenges

I remember a junior developer on my team once came to me, frustrated that an API call was taking way too long — around 19 seconds in total. He was using async/await and assumed it was automatically the most efficient approach. But when I looked at the code, I immediately spotted the issue: const res1 = await fetchA(); const res2 = await fetchB(); const res3 = await fetchC(); Each call was waiting for the previous one to finish — completely sequential. No wonder it was slow. I suggested a small change that made a huge impact: const [res1, res2, res3] = await Promise.all([ fetchA(), fetchB(), fetchC(), ]); Just like that, the total response time dropped from 19 seconds to just 90ms. All because the API calls started running in parallel, not one after the other. Key takeaway: Using async/await doesn’t automatically mean your code is fast. When your async calls don’t depend on each other, Promise.all() can make a night-and-day difference. I love moments like these — small tweaks, big wins. Have you ever made (or fixed) a similar async/await mistake? Would love to hear! #FreelanceDeveloper #FullStackDeveloper #JavaScriptDeveloper #ReactJS #AngularDeveloper #NodeJS #WebAppDevelopment #RemoteDeveloper #TechTips

Long-running API requests are a scalability problem hiding as a user experience problem. The obvious approach is simple: User sends request → API does the work → API returns the result. That works fine until the request takes several minutes. Now your API is holding requests open. Users are staring at a loading screen. Traffic spikes become much harder to handle. And your app server is doing two jobs at once: serving regular API traffic and processing expensive work. A better progression: Return 202 Accepted immediately Store the work in a jobs table Process it in the background Let users check status or receive async notifications Introduce a queue when you need buffering Scale with competing consumers The key idea: Your API should accept the work. Your workers should process the work. Your queue should absorb the spikes. I break down the full architecture step by step here: https://lnkd.in/dX5eSucP

Case Study - Data inconsistency on frontend due to API Race condition While working on a feature on frontend, I ran into one issue - I was trying to add a new user but even if CREATE USER api returned OK response. I was not getting the new user in GET USERS api. Actually, there was a race condition happening. ----------------------------- What is a Race Condition? A race condition in software programming happens when multiple operations run at the same time, and their outcome depends on the order in which they execute—something that isn't guaranteed. This can lead to unexpected and incorrect behavior. For Example: Suppose two people trying to withdraw money from the same bank account at the exact same time. Both check the balance—$100. Both decide to withdraw $50. Each withdraws $50, thinking there's enough money. Instead of one withdrawal succeeding and leaving $50, both succeed, and the account incorrectly shows $0 instead of $50. ----------------------------- So in my case, the two API calls (creating a user and fetching users) were running in parallel. The list API was executing before the user was actually saved. In order to fix this issue, I made sure the users list API ran after the user was created, instead of calling both APIs at the same time. Key Takeaways - ↪ APIs don’t always sync instantly. (just because one request succeeds doesn’t mean the next will reflect the change.) ↪ Race conditions can cause inconsistent data when dependent calls are made in parallel. ↪ Always ensure sequence where necessary. (use await, promises, or event listeners to maintain order) Have you ever faced something similar? How do you handle such issues?

Your async method is running. The user already left. You're still burning CPU, memory, and I/O for nothing. That's what happens without CancellationToken. CancellationToken is .NET's cooperative cancellation model. It doesn't kill your code. It asks nicely, and your code decides when and how to stop. Here's everything you need to know: 𝐖𝐡𝐲 𝐈𝐭 𝐄𝐱𝐢𝐬𝐭𝐬 → Users navigate away. Timeouts fire. Apps shut down. → Without cancellation, your operations keep running long after they're needed. → With it, you stop work early and free resources immediately. 𝐖𝐡𝐚𝐭 𝐈𝐭 𝐈𝐬 CancellationToken is a lightweight struct. It doesn't cancel anything by itself. → CancellationTokenSource (CTS) is the controller. It owns the cancel signal. → CancellationToken is the read-only handle you pass to your operations. → When you call cts.Cancel(), the token gets the signal and your code observes it. 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐔𝐬𝐞 𝐈𝐭 → Long-running loops and CPU-bound work → Any async I/O: HttpClient, streams, database calls → User-triggered actions ("Cancel" button) → Timeouts: cts.CancelAfter(TimeSpan.FromSeconds(30)) 𝐇𝐨𝐰 𝐭𝐨 𝐎𝐛𝐬𝐞𝐫𝐯𝐞 𝐭𝐡𝐞 𝐓𝐨𝐤𝐞𝐧 Three options. Pick based on context: → Check the flag: if (token.IsCancellationRequested) — fast, lets you clean up before exiting → Throw if requested: token.ThrowIfCancellationRequested() — short, unwinds the stack immediately → Pass it down: most BCL APIs accept a token directly (Task.Delay, HttpClient, ReadAsync) The right pattern: call ThrowIfCancellationRequested() inside loops and before expensive operations. Pass the token all the way down your call chain. ❌ Don't swallow OperationCanceledException unless you're genuinely handling cancellation. ❌ Don't reuse a CancellationTokenSource after cancelling. Create a new one per operation. ❌ Don't forget to Dispose the CTS. It holds timers and registrations. 𝐈𝐧 𝐀𝐒𝐏 .𝐍𝐄𝐓 𝐂𝐨𝐫𝐞 The framework injects a CancellationToken automatically in Minimal API endpoints and controller actions. It fires when the client disconnects. You just need to accept it as a parameter and pass it along. This is one of those things senior .NET devs use without thinking about it. Juniors wonder why their APIs are slow under load. Want to know what else separates junior from senior .NET developers? 👇 https://lnkd.in/g9bWNzkR

𝟭𝟬 𝗔𝘀𝘆𝗻𝗰 𝗠𝗶𝘀𝘁𝗮𝗸𝗲𝘀 𝗞𝗶𝗹𝗹𝗶𝗻𝗴 𝗬𝗼𝘂𝗿 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗖𝗼𝗿𝗲 𝗔𝗽𝗽 I've reviewed dozens of .NET Core backends that suffered mysterious slowdowns and memory spikes. Every time, the root cause was the same: bad async code. These async mistakes aren't obvious. They don't throw errors. They just slowly kill your app. Here are the 10 most common async pitfalls I see (and how to fix them): Stop making these costly errors 👇 𝟭/ 𝗡𝗼𝘁 𝘂𝘀𝗶𝗻𝗴 𝗖𝗮𝗻𝗰𝗲𝗹𝗹𝗮𝘁𝗶𝗼𝗻𝗧𝗼𝗸𝗲𝗻 ↳ Requests keep running after clients disconnect ↳ Wasted CPU cycles and memory leaks ✅ Always pass CancellationToken through your async chain 𝟮/ 𝗕𝗹𝗼𝗰𝗸𝗶𝗻𝗴 𝗼𝗻 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 ↳ Using .Result, Wait(), GetAwaiter() .GetResult() ↳ Thread pool starvation = application freezes ✅ Use await consistently, never block on async calls 𝟯/ 𝗡𝗼 𝘁𝗶𝗺𝗲𝗼𝘂𝘁𝘀 𝗼𝗻 𝗼𝘂𝘁𝗯𝗼𝘂𝗻𝗱 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 ↳ HttpClient calls hang forever waiting for responses ↳ Resource exhaustion brings down your entire service ✅ Set HttpClient .Timeout and use CancellationTokenSource with timeout 𝟰/ 𝗡𝗼𝘁 𝗺𝗮𝗸𝗶𝗻𝗴 𝘁𝗵𝗲 𝗲𝗻𝘁𝗶𝗿𝗲 𝗰𝗮𝗹𝗹 𝗰𝗵𝗮𝗶𝗻 𝗮𝘀𝘆𝗻𝗰 ↳ Mixing sync/async patterns breaks everything ↳ Deadlocks and poor scalability under load ✅ Go async all the way: controller → service → repository 𝟱/ 𝗨𝘀𝗶𝗻𝗴 𝗧𝗮𝘀𝗸.𝗥𝘂𝗻 𝗶𝗻𝘀𝗶𝗱𝗲 𝗰𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿𝘀/𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 ↳ Offloading I/O work to thread pool unnecessarily ↳ Context switching overhead kills performance ✅ Use Task .Run only for CPU-intensive work, not I/O operations 𝟲/ 𝗕𝘂𝗳𝗳𝗲𝗿𝗶𝗻𝗴 𝗵𝘂𝗴𝗲 𝗽𝗮𝘆𝗹𝗼𝗮𝗱𝘀 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 ↳ Loading 500MB responses into memory at once ↳ OutOfMemoryException crashes your app ✅ Use IAsyncEnumerable and Stream .CopyToAsync instead 𝟳/ 𝗨𝘀𝗶𝗻𝗴 𝗧𝗮𝘀𝗸.𝗪𝗵𝗲𝗻𝗔𝗹𝗹 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗹𝗶𝗺𝗶𝘁𝘀 ↳ Firing 1000 concurrent requests to external APIs ↳ Rate limiting and cascade failures ✅ Control concurrency with small chunks or Parallel .ForEachAsync 𝟴/ 𝗧𝗵𝗲 𝗮𝘀𝘆𝗻𝗰 𝘃𝗼𝗶𝗱 𝘁𝗿𝗮𝗽 ↳ async void methods outside event handlers ↳ Unhandled exceptions crash your entire process ✅ Always return Task or Task<T> from async methods 𝟵/ 𝗙𝗶𝗿𝗲-𝗮𝗻𝗱-𝗳𝗼𝗿𝗴𝗲𝘁 𝗱𝗶𝘀𝗮𝘀𝘁𝗲𝗿𝘀 ↳ Starting background tasks without proper tracking ↳ Silent failures and resource leaks everywhere ✅ Use OutBox or BackgroundService to process background tasks 𝟭𝟬/ 𝗠𝗶𝘀𝘀𝗶𝗻𝗴 𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗲𝗔𝘄𝗮𝗶𝘁(𝗳𝗮𝗹𝘀𝗲) ↳ Library code captures synchronization context unnecessarily ✅ Use ConfigureAwait(false) in all library async methods 👉 Join 𝟭𝟱,𝟬𝟬𝟬+ people in my .NET Newsletter. Weekly best practices, real-world examples, and pro tips to craft better software today! 𝗕𝗼𝗻𝘂𝘀: every subscriber gets a PDF with 650+ exclusive resources for mastering C#, .NET, ASP .NET Core, EF Core, and Microservices. — ♻️ Repost to help others avoid common async mistakes ➕ Follow me ( Anton Martyniuk ) to improve your .NET Skills

I see this mistake in almost every codebase I review. Developers awaiting async calls one by one: var user = await GetUserAsync(); var orders = await GetOrdersAsync(); var stats = await GetStatsAsync(); Each await waits for completion before starting the next. 3 calls at 200ms each = 600ms total. You should learn about Task.WhenAll(). var userTask = GetUserAsync(); var ordersTask = GetOrdersAsync(); var statsTask = GetStatsAsync(); await Task.WhenAll(userTask, ordersTask, statsTask); Now your total wait time = the slowest task. 600ms becomes ~200ms. I use Task.WhenAll() whenever I have: - Multiple API calls that don't depend on each other - Dashboard data fetching from different sources - Notifications going to multiple channels (email, SMS, push) - Cache invalidation across multiple keys Why I love it: - No extra threads needed, just smarter scheduling - Async I/O waits for responses, doesn't block - One simple change, massive performance gain Some lessons I learned the hard way: - Only works when tasks are truly independent - If Task B needs Task A's result, you can't parallelize - For thousands of tasks, I add SemaphoreSlim for throttling Trust me, go check your codebase right now. You'll find at least one place where this applies. Join my free .NET Web API Zero to Hero Course: https://lnkd.in/gHjTfixw Found this useful? Repost it to help a fellow developer. #dotnet #csharp #aspnetcore #performance #asyncawait

🚀 Boosting Performance with C# Parallel.ForEach[Async] 🚀 When dealing with multiple I/O-bound operations—like HTTP requests to a REST API—sequential execution (`foreach`) can slow down performance significantly. Fortunately, `Parallel.ForEach` and `Parallel.ForEachAsync` allow us to execute these operations concurrently, unlocking massive speed improvements. 🔥 The Problem: Sequential Execution Consider the scenario where we need to make N remote calls where N=6. Assuming the remote endpoint takes 2 seconds to respond, using a `foreach` loop will take 12 seconds to complete (left code). Borrowing from the big O notation, this runs in O(N) time, meaning the time is linearly relative to the number of iterations (N), so 100 calls would take around 200 seconds (over 3 minutes) to complete, which is enormous. ⚡ The Solution: Parallel Execution With `Parallel.ForEachAsync`, we can execute the calls in parallel. Assuming the server has enough resources to send the N requests simultaneously, it would take only about 2 seconds to complete the execution of the endpoint, no matter what the value of N is (right code). In big O terms, this runs in O(1) time, meaning the time it takes to complete the execution is constant and will always be the same (a.k.a. two seconds). Since we live in a discreet world, we do not have unlimited resources, so the actual execution time would be O(N/k), where k is the MaxDegreeOfParallelism (a.k.a. the maximum number of calls we can do at once). 📊 Results—100 remote calls using my personal computer 🏆 `Parallel.ForEachAsync`: 10.2095184 seconds. 😞 `foreach` loop: 3:20.9339857 minutes. 📖 Conclusion While `Parallel.ForEachAsync` can dramatically reduce execution time, the real-world performance boost depends on the system's ability to handle parallel execution. ✅ Ideal for independent I/O-bound operations like HTTP requests. ✅ Use MaxDegreeOfParallelism to control how many requests to send in parallel. ✅ Be cautious of shared state (e.g., List<T>)—use thread-safe collections like ConcurrentBag<T> instead. 📌 Tip You can use `Parallel.ForEach` to execute synchronous operations in parallel, while `Parallel.ForEachAsync` allows you to use async/await code. 💬 What’s your experience with parallel execution? Have you tried `Parallel.ForEachAsync`, or do you have a different approach? Do you have stories to share? Drop your thoughts in the comments! 🚀👇 #ParallelProgramming #Performance #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign #ProgrammingTips #CleanCode

If you are building agents, it's time to revisit the fundamentals: sync vs async. 🔹 𝐖𝐡𝐲 𝐚𝐬𝐲𝐧𝐜 𝐦𝐚𝐭𝐭𝐞𝐫𝐬  LLM API calls take ~2 seconds. → Sync (single worker): User 1 blocks for 2s → Users 2, 3… queue up → 50th user waits 100 seconds. → Async: User 1 hits await → event loop picks up User 2 → all 50 users get responses in ~2 seconds. Async doesn't make one request faster. A 2s call in sync is still 2s in async. It just doesn't block while waiting. 🔹 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐚𝐬𝐲𝐧𝐜 𝐯𝐬 𝐬𝐲𝐧𝐜 I/O bound (waiting on an external service)? Async unblocks you. ✅ API calls (OpenAI, document processing API, etc.) ✅ Databases (PyMongo Async, asyncpg) ✅ Vector stores (Pinecone, Weaviate) ✅ Streaming responses CPU bound? Sync is fine — async won't help. ❌ Local model inference (CPU/GPU busy with matrix math) ❌ JSON parsing, numpy operations ❌ Local document processing (pypdf) For heavy CPU work, use a background job queue instead (e.g. Celery). 🔹 𝐒𝐨𝐦𝐞 𝐩𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐈 𝐮𝐬𝐞 𝐢𝐧 → Async DB queries: every await db.query() releases control so the loop handles others in the meantime. → Multi-step RAG pipelines (query rewrite → route → search → rerank → generate): each await releases control, the pipeline doesn't block other users. → Streaming with AsyncGenerator: tokens stream as they arrive instead of waiting for the full response. ⚠️ 𝐓𝐡𝐢𝐧𝐠𝐬 𝐭𝐨 𝐰𝐚𝐭𝐜𝐡 𝐨𝐮𝐭 → Agent fan-out: Multiple API calls per request means 100 users can turn into 500+ requests fast. API rate limits hit quickly. Use semaphores to cap concurrency, and retry with exponential backoff. → Missing timeouts: always set one. A stuck call holds resources indefinitely. → Mixed sync/async: I have a FastAPI service that hits PostgreSQL on almost every request. 𝘴𝘺𝘯𝘤 drivers in 𝘢𝘴𝘺𝘯𝘤 endpoint blocks the event loop on every DB call, reducing concurrency and throughput. Where has async bitten you in production?

Tired of Waiting for All Tasks to Complete? Meet Task.WaitAny! Imagine you’re making multiple API calls or querying multiple databases at the same time. Instead of waiting for all tasks to finish, what if you could process results as soon as the first one completes? That’s exactly what Task.WaitAny helps with! The Problem You have multiple asynchronous operations running, but you don’t need to wait for all of them to complete before taking action. ❌ Bad Approach – Blocking Until All Tasks Finish 𝐓𝐚𝐬𝐤.𝐖𝐚𝐢𝐭𝐀𝐥𝐥(𝐭1, 𝐭2, 𝐭3); // 𝐁𝐥𝐨𝐜𝐤𝐬 𝐮𝐧𝐭𝐢𝐥 𝐀𝐋𝐋 𝐭𝐚𝐬𝐤𝐬 𝐟𝐢𝐧𝐢𝐬𝐡 Issue: If one task takes significantly longer than the others, everything is delayed unnecessarily. ✅ The Solution – Process the First Completed Task with Task.WaitAny 𝐢𝐧𝐭 𝐜𝐨𝐦𝐩𝐥𝐞𝐭𝐞𝐝𝐈𝐧𝐝𝐞𝐱 = 𝐓𝐚𝐬𝐤.𝐖𝐚𝐢𝐭𝐀𝐧𝐲(𝐭𝐚𝐬𝐤𝐬); Why Use Task.WaitAny? ✅ Faster Response Times – You can process results as soon as one task completes. ✅ Efficient Resource Use – No unnecessary waiting for slower tasks. ✅ Better User Experience – Improves responsiveness in UI and web apps (when used correctly). When to Use Task.WaitAny? ▪️ Handling multiple API calls and processing the first available response. ▪️ Running background jobs where you don’t need all tasks to complete. ▪️ Load balancing tasks and using the first available result. Tip: Process Tasks as They Complete Want to process each completed task as soon as it's done? Use a loop with Task.WaitAny to handle them one by one. ⚠️ Key Considerations 1. Blocking Behavior: ▪️ Task.WaitAny blocks the current thread. Avoid in UI/web apps. ▪️ Use await Task.WhenAny for non-blocking behavior in async apps. 2. Error Handling: ▪️ Always check task.IsFaulted to handle exceptions. When to Use? ▪️ Task.WaitAny: Console apps, background services. ▪️ Task.WhenAny: UI/web apps for non-blocking async operations. Have you used Task.WaitAny or Task.WhenAny? Share your tips below!