Tell me more about how you reduced P95 Latency…

To reduce P95 latency (95th percentile delay), I employed several approaches:

Profiling and identifying bottlenecks: Using profiling tools (pprof, trace) to determine which parts of the code or requests cause the highest delays.
Optimizing algorithms and data structures: Replacing inefficient algorithms with faster ones, caching results, reducing allocations.
Parallelization and asynchrony: Converting blocking operations to asynchronous, using goroutines for parallel processing.
Optimizing interaction with external services: Minimizing network requests, using connection pools, implementing timeouts and retries.
Load balancing and scaling: Distributing load across multiple service instances.

Example of code optimization to reduce delay:

// Before optimization: sequential requests
func fetchData() ([]Data, error) {
    var results []Data
    for _, id := range ids {
        data, err := fetchFromDB(id)
        if err != nil {
            return nil, err
        }
        results = append(results, data)
    }
    return results, nil
}

// After optimization: parallel requests with goroutines
func fetchData() ([]Data, error) {
    var wg sync.WaitGroup
    results := make([]Data, len(ids))
    errs := make(chan error, len(ids))

    for i, id := range ids {
        wg.Add(1)
        go func(i int, id string) {
            defer wg.Done()
            data, err := fetchFromDB(id)
            if err != nil {
                errs <- err
                return
            }
            results[i] = data
        }(i, id)
    }
    wg.Wait()
    close(errs)

    if len(errs) > 0 {
        return nil, <-errs
    }
    return results, nil
}

This approach significantly reduced maximum delays and improved the stability of the service response.

Tell me more about how you reduced P95 Latency.