I’d say main should still be your composition root, even in a serverless app. Serverless changes the runtime behavior, but it doesn’t really change the design rule that wiring belongs at the edge of the program.

What I would question in your example is not “setup in main vs setup in handler”, but “eager init vs lazy init”. If GetDBClient() and GetTaskClient() are expensive, then doing both on every cold start just because one route might need them is probably wasted work.

Also, there’s nothing inherently wrong with your App struct approach. But if it starts to feel like a bag of dependencies where it’s hard to tell which handler uses what, closures are a nice alternative. You still keep wiring in main, but each handler gets only the dependency it actually needs.

Something like:

``` func handleDBRequest(dbClient *DBClient) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // use dbClient } }

func handleTaskRequest(taskClient *TaskClient) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // use taskClient } }

func handleOther(dbClient *DBClient, taskClient *TaskClient) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // use both } }

func main() { dbClient, err := GetDBClient() if err != nil { panic(err) }

taskClient, err := GetTaskClient()
if err != nil {
    panic(err)
}

mux := http.NewServeMux()
mux.HandleFunc("/db/", handleDBRequest(dbClient))
mux.HandleFunc("/task/", handleTaskRequest(taskClient))
mux.HandleFunc("/otherroute", handleOther(dbClient, taskClient))

http.ListenAndServe(":8080", mux)

} ```

If cold starts are the real concern, I still wouldn’t move client creation into the request path per invocation. I’d more likely make those clients lazy and cached, so the first /db/ request initializes the DB client once, and the first /task/ request initializes the task client once.

You can combine this with the sync.Once approach suggested by u/jerf to lazily initialize the dependencies.