What data structure should I use so that my "calendar" api has maximum performance?

I have a micro service, which serves employees work calendars. The original data has the following file structure:

calendars / [year] / [employee].json

Contents of [employee].json:

{
// [date]: [hours]
"2023-02-01": 7,
"2023-02-02": 7,
}

Using Go, I convert all data to these two variables with types CalendarFast and CalendarSlow:

type Username = string
type Date = string
type Year = string
type Hours = float64

type CalendarFast map[Username]map[Year][]struct {
	Time  time.Time // "2022-01-01"
	Hours Hours // 7
}

type CalendarSlow map[Username]map[Year]map[Date]Hours

If i want, for example, from my API to return all hours for given date range I can write these two benchmarks to test which data structure is better:

func BenchmarkNew(b *testing.B) {
	c := make(CalendarFast)
	c.Update(context.TODO())

	from, _ := time.Parse("2006-01-02", "2023-01-01")
	to, _ := time.Parse("2006-01-02", "2023-02-01")

	isInRange := func(t, from, to time.Time) bool {
		return (t.After(from) && t.Before(to)) || t.Equal(from) || t.Equal(to)
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		// result is map[username]map[date]hours
		result := make(map[string]map[string]float64)
		for username, years := range c {
			if _, ok := result[username]; !ok {
				result[username] = make(map[string]float64)
			}

			for _, dates := range years {
				for i, n := 0, len(dates); i < n; i++ {
					if isInRange(dates[i].Time, from, to) {
						result[username][dates[i].Time.String()] = dates[i].Hours
					}
				}
			}
		}
	}
}

func BenchmarkOld(b *testing.B) {
	c := make(CalendarSlow)
	c.Update(context.TODO())

	from, _ := time.Parse("2006-01-02", "2023-01-01")
	to, _ := time.Parse("2006-01-02", "2023-02-01")

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		result := make(map[string]map[string]float64)
		for username, years := range c {
			if _, ok := result[username]; !ok {
				result[username] = make(map[string]float64)
			}

			for _, items := range years {
				for date, hours := range items {
					t, err := time.Parse("2006-01-02", date)
					if err != nil {
						continue
					}

					if (t.After(from) && t.Before(to)) || t.Equal(from) || t.Equal(to) {
						result[username][date] = hours
					}
				}
			}
		}
	}
}

I has following benchmarks, which shows that searching range in array is much faster, that search each element in map:

BenchmarkNew-4  285    4208045 ns/op  692965 B/op  6303 allocs/op
BenchmarkOld-4   39   29672935 ns/op  621877 B/op  1407 allocs/op

My Question is: how can I push performance even further? Should i change data structure to another?

I need speed because i receive a lot of calls to my current PHP API and find out that micro service in Go can easily handle 1k rps with only 10m cpu and 64Mib of memory in k8s

I already satisfied with array for "time.Time" approach, but curious of another implementations.

UPD:

From your description the data is static and you're only reading the source files once at program startup.

Why not order each employee's date array so once you get beyond the end date you can stop checking the rest of the dates?

Why does year map exist?. Just one more thing to iterate over.

And why store all dates as strings, then have to parse them each time you want to filter by date range? Why not use time.Time? Much more efficient in memory and removes the need to parse over and over again.

I would use a map[Username][]struct{date time.Time, hours int}, order the array after I read it once, then iterate more like this:

for username, dates := range c {
for shift := range dates {
if shift.date.Before(from) {
continue
} else if shift.date.After(to) {
break
}
if _, ok := result[username]; !ok {
result[username] = make(map[string]float64)
}
result[username][shift.date] = shift.hours
}
}