Optimising Api

• first step was to identify the bottlenecks in the system.

  • essential to identify the slowest piece of the code, as fixing this will usually give you the most significant improvement.

• fixed the first bottleneck, it often reveals the next bottleneck.

• Repeat the process until you reached desired state

• requires constant monitoring and measurement.

• Sometimes there are quick fixes, but may not last long

  • increase number of replicas

  • increase timeouts

  • increase memory

• In general, the network calls all the longest

  • followed or similar to database queries

  • then data structure or the algorithm used

• Common bottlenecks to look for

  • calling the database from a loop

    • fix: Get all the data in one query, and do the looping on that retrieved data

  • Calling an external service multiple times

    • fix: If you need to make multiple calls to another service, try to convert that into one call and have the service aggregate the required data and return everything at once

  • Executing a complex calculation multiple times with identical parameters

  • doing queries on Non indexed database or full table scans

• Aim to reduce number of round trips (ie over network)

  • Instead of round trip per each thing, can it be done once

  • A round trip might be fast, but when dealing with lots of them it adds up (law of big numbers)

• Better to do processing of logic in the database (stored procedure) then getting the data and doing it in code

• Next step use parallelization

  • This should be considered later, as concurrency and parallel process can be complex and lead to complex failures (Race conditions etc)

  • Having multiple asynchronous calls to different services with no dependencies between them.

    • can send them all at once

  • Issues come when need to aggregate all the results

• Lastly introduce a cache

  • This adds a lot of complexity to get it right

  • it can introduce unwanted behavior when the data is stale.

  • When implementing caching, it's essential to consider the duration of the cache and the strategies to clear the cache when the underlying data changes.