Yan Cui writes about AWS serverless architecture, Lambda, and Cognito, with some posts on functional languages and games.
Commenters recommend it for serverless topics, and cite his Cognito write-up on its shortcomings and his post on Lambda cold-start costs of dependencies.
I think there are times when the graph model shines.
https://theburningmonk.com/2015/04/modelling-game-economy-with-neo4j/
I read this article I found on HN a few years ago, and for some reason it came to my mind just now.
The neat thing about the graph model of course is being more immediately expressive to the query-er, and that takes cognitive load away from that person.
I'll never say a bad thing about SQL or the relational model. I completely agree that it's superior in terms of flexibility, performance (almost always), modelling (usually), etc but I guess there are times where you have a weird project and it's just I guess the convenience and ease of using Neo4j and a few cypher queries and then it's over.
In the case of the article I linked, there is also the benefit of having a convenient way to see how changes echo throughout the graph, something that is more involved to do with tables and joins and all that. I'm not a DBA, I've really only ever dabbled, but if I got dropped into that situation and DIDN'T have a graph model, I'd have no clue where to even start. Maybe I'd start trying to walk tables and build graphs out from each item type to each other item type. That'd be gross.
Of course, that's probably not a problem scenario that comes up very often. Most of the times I've interacted with databases in general I've been just dealing with sanitizing params, getting HTTPS configurations configurated, just boring infosec stuff. That problem is probably very…
I've started reading this book and I rate it highly so far: Serverless Development on AWS [0].
I agree that finding comprehensive, non-sales-oriented best practices can be challenging. One useful resource is Serverless Land from AWS [1], which offers a collection of practical examples and articles.
Mastering serverless involves more than just wiring up functions—it's about adopting Infrastructure as Code (IaC) principles. Over time, you'll develop reusable patterns and tools like Terraform modules that encapsulate best practices such as asynchronous Lambdas with EventBridge subscriptions, SQS Dead Letter Queues (DLQ), and appropriate error handling configurations.
For a deeper dive into the Serverless philosophy explicitly applied to AWS, I recommend checking out Yan Cui's blog [2]. Yan provides insightful articles on serverless architectures and patterns.
I suggest exploring the Reactive Manifesto [3] for principles and best practices in building responsive, scalable systems if you're interested in asynchronous messaging patterns.
[0] https://www.oreilly.com/library/view/serverless-development-on/9781098141929/ [1] https://serverlessland.com [2] https://theburningmonk.com [3] https://www.reactivemanifesto.org
The link invites readers to
explore our MCP directory https://www.anthropic.com/partners/mcp
The CloudFlare and Linear MCP servers (at a minimum) seem to use the same approach, the mcp-remote npm package, e.g.
https://github.com/cloudflare/mcp-server-cloudflare/tree/main/apps/workers-builds#access-the-remote-mcp-server-from-from-any-mcp-client
{ "mcpServers": { "cloudflare": { "command": "npx", "args": ["mcp-remote", "https://builds.mcp.cloudflare.com/sse"] } } } But mcp-remote is clearly documented as experimental:
> Note: this is a working proof-of-concept but should be considered experimental
https://www.npmjs.com/package/mcp-remote
I'm not sure how this could be considered anything other than professional negligence. I'm reminded of Kyle Kingsbury's CraftConf talk, Hope Springs Eternal: https://theburningmonk.com/2015/06/craftconf15-takeaways-from-jepsen-iv-hope-springs-eternal/
> The point is pretty moot though, because you can schedule Cloudwatch Events every 4 minutes to keep a lambda warm, if necessary.
I encourage you to read this article, https://theburningmonk.com/2018/01/im-afraid-youre-thinking-about-aws-lambda-cold-starts-all-wrong/ , because if you're running a web API with Lambdas, keeping one instance warm with the "cloudwatch event every 4 minutes" trick will most definitely not solve your cold start issues.
I wrote this in another comment here, but just so you don't miss it: Don't.
Dependencies for the dynamic languages matter A LOT! Take a look at what it'll cost you for requiring the AWS SDK in Node.js, for your cold starts https://theburningmonk.com/2019/03/just-how-expensive-is-the-full-aws-sdk/
Personal benchmarks puts Rust as the most optimal language that I've tried to run on AWS Lambda so far.
Every year or so I check back in to see if Cognito has gotten any better. I hasn't. I'd love to use it, but some very basic things are just not done correctly. Yan Cui has a nice writeup on Cognito [0] that touches on some of its shortcomings.
[0]: https://theburningmonk.com/2021/03/the-case-for-and-against-amazon-cognito/