Keep it simple and you will be good. We follow the following for all our lambdas: Use plain SQL query instead of jpa don't use Spring Boot or any other framework if your use case is simple you don't need dependency injection for simple use case that involves couple of classes. Just create static objects and pass them around. Create objects ( eg objectMapper, AWS clients) only once use RDS proxy instead of creating DB connection directly use SnapStart use shadow jar use minimal dependencies.. exclude unnecessary transitive dependencies if you do http calls to other services make sure they are performant. If possible use async calls, parallelize calls if possible use lightweight objects, don't use xml, Json libraries if you can(most of the time simple String append is faster) run the lambda locally and profile it etc More on reddit.com

Were they ever IN favor? Cold start times for JVM based lambdas were awful when I experimented with them a few years ago. I've read recently that improvements have been made, but honestly I like my lambdas to be extremely light weight, so interpreted languages just feel more in line with what I'm doing. More on reddit.com

Very often the best language for a team/org is not the "best" language for particular component. If it's a Java based team it often doesn't make sense to dump all that investment just for Lambda if Java performance there is acceptable. Personally I won't use Node for anything if I can possibly avoid it. If Python isn't fast enough and in particular if threading will help I'll use Go. But even as anti-Node as I admit I am, I absolutely respect that in shops with a lot of Javascript talent due to frontend work it often makes the most sense to go with Node for backend work despite its many hair pulling issues. It's much better to be pragmatic than "right". Lambda supports a ton of languages (effectively all of them if we count custom runtimes) because it's pragmatic. More on reddit.com

We decided to go against it. As frameworks go it is quite heavy and with lambdas you don't need to be concerned so much with routing and servers. Lambdas are best kept small, almost at the function level. I have seen them best work with much smaller dependency injections like guice or dagger to help maintain a good structure and avoid anti patterns along side a build tool like maven. Hope this helps More on reddit.com