How can I reliably convert request timestamps to a specific regional time zone in a Fiber handler?

Answer the exact question first

In a Fiber handler you can reliably convert an ISO‑8601 timestamp that is always in UTC to a user‑specified IANA zone by:

1. Parsing the string with time.Parse(time.RFC3339, ts) (or a custom layout if the format differs).
2. Loading the target zone once – loc, _ := time.LoadLocation("America/New_York") – and reusing that *time.Location for every request.
3. Converting the parsed UTC instant with t.In(loc).
4. Formatting the result back to a string (e.g., t.In(loc).Format(time.RFC3339Nano)) for storage or response.

This workflow is safe for high‑throughput because time.Location is immutable and can be shared across goroutines without locking.

Handling DST transitions safely

When the input is a UTC instant there is no ambiguity: the instant is unique in all zones. DST gaps or overlaps only matter when you are converting a local time to UTC. If your API ever receives a local timestamp, use time.ParseInLocation and then verify the offset:

t, err := time.ParseInLocation("2006-01-02T15:04:05", localStr, loc)
if err != nil { /* malformed */ }
// Detect a non‑existent time (DST gap)
if t.In(loc).Unix() != t.Unix() {
    // The parsed time was adjusted; you can reject or inform the caller.
}

For ambiguous times (the same local clock value occurs twice during a DST fall back), ParseInLocation returns the first occurrence. If you need the second, you must add the DST offset manually or ask the client to supply the UTC instant.

Reuse of *time.Location and performance impact

Loading a location with time.LoadLocation reads the tzdata database once and caches the result internally. The returned pointer is read‑only, so it is safe to store it in a package‑level variable and use it concurrently. Creating a new location per request would add unnecessary I/O and memory allocations, hurting throughput.

Validating the converted time

After conversion you should check that the resulting time.Time falls within any business‑rules bounds you enforce. For example:

converted := t.In(loc)
if converted.Before(minTime) || converted.After(maxTime) {
    // Reject or adjust
}

Additionally, you can ensure the offset matches the zone’s current rule by comparing converted.In(loc).UTC().Sub(converted.UTC()) to the expected offset for that instant.

What to ask next

If you ever receive timestamps that are not guaranteed to be UTC (e.g., a client sends a local time string), you’ll need to adjust the parsing logic to use ParseInLocation and perform the DST checks shown above.