Deep backend
foundations, and
enough Go to be
dangerous.

// The leak: nobody ever receives, so this goroutine blocks forever.
// Its memory, its stack, and everything it closes over stay alive.
func leak() {
    ch := make(chan int)          // unbuffered
    go func() { ch <- expensive() }()  // blocks on send, forever
    return                        // caller walked away
}

// The fix: an exit path the goroutine can actually take.
func noLeak(ctx context.Context) (int, error) {
    ch := make(chan int, 1)       // buffered: send never blocks
    go func() { ch <- expensive() }()
    select {
    case v := <-ch:
        return v, nil
    case <-ctx.Done():            // caller gave up; we still unblock
        return 0, ctx.Err()
    }
}

// Bounded fan-out: 8 workers, backpressure built in, cancellable.
func process(ctx context.Context, jobs <-chan Job) error {
    g, ctx := errgroup.WithContext(ctx)
    for i := 0; i < 8; i++ {          // fixed concurrency, not one per job
        g.Go(func() error {
            for {
                select {
                case j, ok := <-jobs:
                    if !ok {           // channel closed: clean exit
                        return nil
                    }
                    if err := handle(ctx, j); err != nil {
                        return err     // cancels ctx for the whole group
                    }
                case <-ctx.Done():     // someone else failed, or caller gave up
                    return ctx.Err()
                }
            }
        })
    }
    return g.Wait()                    // first error, after all workers stop
}

// Layer boundary: add context going up, decide only at the top.
func (s *Service) Invoice(ctx context.Context, id string) (*Inv, error) {
    inv, err := s.repo.Get(ctx, id)
    if err != nil {
        // %w preserves the chain; the id is context only this layer has.
        return nil, fmt.Errorf("invoice %s: %w", id, err)
    }
    return inv, nil
}

// The one place that translates errors into a response.
func (h *Handler) Get(w http.ResponseWriter, r *http.Request) {
    inv, err := h.svc.Invoice(r.Context(), chi.URLParam(r, "id"))
    switch {
    case err == nil:
        writeJSON(w, 200, inv)
    case errors.Is(err, sql.ErrNoRows):
        http.Error(w, "not found", 404)          // expected, not an incident
    case errors.Is(err, context.DeadlineExceeded):
        http.Error(w, "timeout", 504)            // retryable, upstream slow
    default:
        h.log.Error("get invoice", "err", err)   // logged once, here
        http.Error(w, "internal", 500)
    }
}