Setting up a golang API that queries a database every hour to refresh its data

I'm relatively new to golang and could use some high-level tips on how to structure this. I'm trying to a build a REST API:

• The user would provide a small JSON payload via POST method
• The API compares the user’s input data against a reference dataset stored as a slice of structs and calculates a value
• This value is returned to the user
• Every hour a database is queried to and replaces the slice of structs dataset with another slice of structs dataset. Basically this refreshes the reference data
• I'd like this refreshing job to be async so it doesn't slow down the user experience

I'm using the golang's Echo framework (https://echo.labstack.com/). Here is my attempt in golang-like pseudocode.
How would you structure this API to refresh the data hourly async?

To clarify, the part Im stuck on is the “query the DB every hour async in the background” bit. Im unsure how to do that in thos scenario.

func main() {

	e := echo.New()
	e.POST("/", func(something) {
		
		// This func queries the DB and saves reference dataset result as a slice of structs
		dataset := refreshDB() 

		// Does some calculations on input JSON data and reference dataset
		result := doCalcs(inputJSON, dataset)

		// Prep response in neat JSON
		responseForUser := prepOutput(result)

		return responseForUser
	
	})
	
}

For async code in Go you can use a goroutine, to execute the code periodically you can use a ticker.

package main

import (
	"fmt"
	"time"
	"sync"
)

var rwm sync.RWMutex
var sliceOfStructs []struct{/* ... */}

func main() {
	go func() {
		tick := time.NewTicker(time.Hour)
		for range tick.C {
			rwm.Lock()
			sliceOfStructs = []struct{}{ /* refresh with new data */ }
			rwm.Unlock()
		}
	}()
	
	// start server
}

• If sliceOfStructs needs to be accessible across multiple packages then you'll need to export it and move it to a non-main package, i.e. one that can be imported. And do the same for rwm.
• Make sure that any code that reads sliceOfStructs invokes rwm.RLock before reading and rwm.RUnlock when done.
• If you have more than one goroutine that needs to write sliceOfStructs then you should change rwm from sync.RWMutex to sync.Mutex.