Fullstack GraphQL with AppSync - Mintbean

Episode Description

Anthony Campolo introduces GraphQL fundamentals and demonstrates building a GraphQL API using AWS AppSync's managed console.

Episode Summary

Anthony Campolo walks through a beginner-friendly introduction to GraphQL, starting with its core concept as a query language for APIs that mediates communication between front-end and back-end systems. He explains foundational elements like schema definition language (SDL), queries, mutations, and type definitions using the official GraphQL documentation before transitioning into a live demonstration with the AWS AppSync console. In the demo, he creates a simple blog post API from scratch, defining a schema with query and mutation types, auto-generating a DynamoDB table, and then running queries and mutations to create and retrieve posts. The interactive tooling built into AppSync's query editor highlights one of GraphQL's strengths: built-in error correction and introspection that guides developers toward correct syntax. A Q&A session follows covering topics like database flexibility within AWS, comparisons to Firebase's pricing model, the distinction between GraphQL and graph databases like Neo4j, how AppSync relates to Apollo Server, integration possibilities with Gatsby, and recommended learning resources, particularly the tutorials of developer advocate Nader Dabit.

Chapters

00:00:00 - What Is GraphQL and Why It Matters

Anthony sets the stage for a casual walkthrough of GraphQL, explaining that they'll review official documentation before jumping into the AWS AppSync console. He defines GraphQL as a query language for APIs, breaking down both terms for newcomers — a query language retrieves data from a database, and an API is simply how two computers communicate.

He introduces the schema definition language (SDL), showing how you define data types like a "project" with a name, tagline, and list of contributors. This leads into a comparison with REST APIs, positioning GraphQL as an opinionated alternative that provides clean conventions for how front-end and back-end systems exchange data, serving both sides of the stack equally.

00:03:34 - Queries, Arguments, and Getting Data Back

Anthony explains that while GraphQL is called a query language, it also supports writing data through mutations. He demonstrates a basic query that requests a specific project's tagline, showing how GraphQL returns only the fields you ask for — a key advantage over traditional approaches. The response comes back as a familiar key-value structure similar to JavaScript objects or Python dictionaries.

He then walks through defining query types and user types in a schema, showing how queries can accept arguments to fetch specific records. The hierarchical nature of GraphQL queries becomes clear as he builds up from a simple "get me" query to one that fetches a specific human's name and height from a list, illustrating how you progressively narrow down the data you want.

00:07:20 - Getting Started with AWS AppSync

The focus shifts to AWS AppSync, a managed service that handles the difficult work of setting up and hosting a GraphQL API. Anthony explains that while writing GraphQL is straightforward, actually creating and deploying a GraphQL API server is a significant challenge — which is exactly what AppSync solves. He compares it to frameworks like RedwoodJS that also abstract away GraphQL infrastructure.

Inside the AppSync console, he creates a new API from scratch, deliberately avoiding wizards and imports to maximize the learning experience. He defines a minimal schema with query and mutation types for a simple blog post system, explaining concepts like primary keys and CRUD operations along the way. He notes the interesting technical detail that all GraphQL operations use HTTP POST requests under the hood.

00:13:02 - Building a Database and Running Mutations

Anthony demonstrates AppSync's resource creation feature, which automatically generates a DynamoDB table and wires it to the GraphQL API based on the schema. This auto-generation also expands the schema with full CRUD mutations (create, update, delete) and their corresponding input types. He explains why input types are extracted separately — they map directly to front-end form fields and event handlers in frameworks like React.

With the infrastructure in place, he moves to the query editor and creates his first post with a "Hello, Mint Bean" title. The demo showcases GraphQL's built-in error detection and correction, where the editor automatically fixes incomplete queries by adding required fields like the post ID, demonstrating the developer-friendly tooling that makes GraphQL productive to work with.

00:17:55 - Querying Posts and Exploring the Tooling

Anthony continues the live demo by showing how to query individual posts and request specific fields like title or ID, or both. He creates a second post and then runs a list query to retrieve all posts at once, demonstrating the items-based structure of list responses. The AppSync query editor's click-based interface allows developers to build queries visually without writing everything by hand.

The built-in validation catches errors in real time, showing red underlines and helpful messages when queries are malformed. This highlights one of GraphQL's strongest selling points — the introspection and tooling ecosystem that keeps developers on track. Anthony wraps up the demo portion and opens the floor for questions from the audience.

00:21:07 - Q&A: Databases, Pricing, and Ecosystem

The Q&A session covers a wide range of topics. Anthony addresses Gatsby integration, pointing to Nader Dabit's tutorials as the best resource since Gatsby already has built-in GraphQL support. He clarifies that the demo used a simple post-only schema intentionally as a learning tool. Questions about real-world applications lead him to explain how Amplify adds authentication and user-specific data access on top of AppSync.

Discussion turns to pricing, where Anthony notes that AppSync's free tier covers most development and proof-of-concept work, with costs primarily driven by the underlying database like DynamoDB. He clarifies the common confusion between GraphQL and graph databases like Neo4j, explains how AppSync compares to Apollo Server, and recommends Nader Dabit as the top resource for newcomers to the AWS GraphQL ecosystem.

00:29:52 - Closing Remarks

Anthony and the moderator wrap up the session, with Anthony sharing his Twitter handle (@AJCWebDev) and encouraging attendees to reach out with questions. He mentions his active presence in the Mint Bean Discord community and notes this is his fourth talk for the group with plans for more.

The session closes with Happy New Year wishes from both Anthony and the moderator, who invites everyone to attend future workshops in the community.

Transcript

00:00:09 - Anthony Campolo

Let me go ahead and share my screen so we can start looking at some stuff together. So as I said originally, I usually have like slides and a whole talk with, you know, code and it's very clear and well thought out. But I want this to be a little more casual and I'm going to go through some of the GraphQL documentation just to give you all some context about what it looks like. And if you do want to get deeper into GraphQL, you'll be going through a lot of these materials yourself. So I think it's good to get kind of your feet wet with it. And then we will actually get into the AWS AppSync console and start learning in that. One of the challenges with AWS is it has a reputation for not having very user friendly interfaces. But I actually think the AppSync one is actually pretty good. It's bare bones. But if you do understand what GraphQL is and how to work with it, you can get spun up pretty quickly with it. So that's why I wanted to just talk about what is GraphQL? How do you write a GraphQL query, a mutation, all that kind of stuff.

00:01:17 - Anthony Campolo

But we're already getting ahead of ourselves. So let's just first talk about what is GraphQL. GraphQL is what we call a query language for APIs. Now, there's a couple terms in there that you may or may not be familiar with. So a query language means it's a language we can use to get data out of, say, a database. So if you have a database, you have a database that has a bunch of blog posts, and you say, I want to get those blog posts, you would write a query to get those blog posts. Now, an API is a really fancy term. Application Programming Interface is a really fancy term for a way for two computers to talk to each other. So normally this would be your front end and your back end, your front end and your back end, they speak GraphQL to each other. So you'll frequently hear people talk about, is GraphQL for front end developers or is it for backend developers? The answer is yes, it's for backend and front end because it is a language that mediates between your front end and your back end. This is a really cool little description here where you describe your data.

00:02:27 - Anthony Campolo

And what you're describing here is you're describing a project, and your project is something that has a name, it has a tagline, and then it has contributors who are working on that project. So this is what we call an SDL, short for schema definition language. So a schema is just a fancy way for defining your data type that your front end and your backend are going to use to talk to each other. So once you define your schema, you say, okay, this is what a project is. A project, it has a name, it has a tagline. Both of those things are just gonna be strings, so it's just gonna be text. And then each project is also going to have a list of contributors. So if you know what an array is, and you see these brackets here, you should say, ok, it's the brackets. It's an array. This is an array of users. So there's also a user type that we would need to define as well. Once we do that, we can ask for the exact data that we want. So going back to why you would even want this in the first place.

00:03:34 - Anthony Campolo

Part of the problem with what we were doing before GraphQL if you've ever worked with something called a REST API, a REST API is the traditional way that our front ends and our back ends would speak to each other. Having your front, your back end speak the same language and understand each other. This is not a new thing. GraphQL is just a specific, opinionated way of how your front end and your back end should talk to each other. It gives you a way to have really nice conventions over how to query that data from the back end. But something that is actually going to be really interesting that we're going to see as we go on, is that even though it's a query language for APIs, it's not just for querying. Querying just means getting data from the database. But what if I wanted to write to the database? What if I wanted to, instead of just query the projects, what if I wanted to create a project as well? And that's actually something that you can also do with GraphQL, which is pretty cool. So this is just a query. You're asking for the project and you're specifying which project you want to get back.

00:04:46 - Anthony Campolo

So you're not just saying, give me any old project, you're saying, I specifically want the GraphQL project. And what I want is I want the tagline, I don't want the name, and I don't want the list of contributors. I only want the tagline. So if that's not super clear, that's what we're gonna demonstrate once we actually get into AppSync. So that will be a little bit clearer. But once we run this query, this is what you get back. So as I say, you ask for a project and you ask specifically for the tagline. And that's why it's just giving us the project and it's giving us only the tagline. If you know what like an object in JavaScript is, or a dictionary in Python, that's kind of what we're looking at here. This is called a key value pair. The key here is tagline, and the value is a query language for APIs. So that's kind of like your GraphQL hello world. Now, if you look here, this is what's going to talk a little bit about how you actually create the schema that GraphQL is able to understand. So you're gonna say, before you define your query, you're first gonna say, I wanna define a query in the first place.

00:06:04 - Anthony Campolo

So first you're gonna say, all right, I wanna define a query. What I want that query to do is I want it to return the users, and then we want to get the ID and the name for the user. So we're defining our query, and then we're actually defining the type of the thing that we're going to get from the query. Then once we do that, we can just say, I want to get me, and I want to get my name, and my name is of course, Luke Skywalker. That is your simplest possible hello world GraphQL query. Now, once you have figured that out, then you can start doing queries with specific arguments. So if we see here, what we're doing is we're just asking for the name of me. But what we really want to do is we want to be able to define objects. So we want to say we have a list of everybody, and then I can ask for a specific person in that list of everybody. So now here we have human, and we're going to have a list of humans, and I want to get back the name and the height of that human.

00:07:20 - Anthony Campolo

So this is what you say is like, they say it's like hierarchical. Basically, you start by saying, this is what I want, and then you say what you want from it specifically. And let's kind of get into the console here and start to look at some of the things we can do here. So this is the AWS AppSync console. So if you just Google AWS AppSync, this will take you to AWS AppSync's homepage. And let's talk a little bit about what this is first. AWS AppSync is managed service for GraphQL APIs right now we've just been talking about GraphQL. I've been showing you how to write a GraphQL query, how to get data back from a GraphQL API. And it should be fairly intuitive in terms of, like, the syntax and what we're writing. We're just saying what we want, what kind of data we want. But you have to think about, okay, well, how do I get the GraphQL API though, in the first place? Like, once you start kind of getting into GraphQL and you start seeing, okay, yeah, it's really nice and easy to work with. But then you ask the question, okay, but where is this GraphQL API coming from?

00:08:34 - Anthony Campolo

And how do you actually create a GraphQL API that's going to take you a whole nother month? So what you really want is you want to be able to access a GraphQL API that has already been created for you. If the GraphQL API is already there, all you really have to do is just say, hey, here's my schema, here's the things I want to get. Then you can start creating the things, you can start getting them back. But getting to that point is actually really hard. It's really challenging for as nice and as simple as GraphQL is to write. And it is very challenging to set up. This is why something like Redwood JS is an extremely nice framework, because it's giving you so much GraphQL power kind of out of the box. And this is the same idea with AWS AppSync. It's saying, okay, we're going to worry about how to actually create a GraphQL API. You just have to tell us what you want your schema to be and then you can start interacting with it directly. And it's really nice and it's super easy to get spun up and get going.

00:09:40 - Anthony Campolo

So this is the main splash page. You'll see you're going to want to say, get started with aws. And this is going to be your first kind of like, hello, world console. See here, this is kind of the test app that I was building out before I started here. So we're going to go to create API. There's gonna be a lot of different ways to go about doing this. I'm going to do it as much from scratch as possible. Thing that's always going to be the most useful for actually learning. So we're not going to use the wizard and we're not going to import any tables. We're just going to build everything from scratch. So we're going to do that and we're going to click Start and we're going to call this Mint Bean appsync and then we're going to create it. They're going to give you a couple different options. And the first thing we want to do is you want to define our schema. This is the very first thing that we're looking at over here is this is our schema and we are going to have a schema that is going to have query, which is just going to be a query, and mutation, which is a mutation.

00:10:58 - Anthony Campolo

This is basically saying what we want to do with this API is we want to be able to query it, we want to be able to get posts, then we want to also do mutations, we want to be able to create posts, we want to be able to update posts, and we want to be able to delete posts. If you've ever heard of CRUD — create, read, update, delete, or create, retrieve, update, delete, destroy. There's many different kind of terms that all mean the same thing. If you're familiar with get, post, put and patch, and those types of things with HTTP, those are also similar. But in GraphQL, you actually only do posts. If that doesn't make any sense to you, you don't need to worry about that at all. But that's kind of an important thing, is that GraphQL is only doing posts, which is a weird thing to wrap your mind around. After we say we want to create a query type, we're then going to create the actual query. And this query is doing what it says in the comment: get a single value of type post by primary key.

00:11:57 - Anthony Campolo

Primary key just means that every post in the database is going to have something that's going to identify it. So you're going to say this is post number one, and only this post can be post number one. Nothing else can be post number one. And then you could say, I want to get the post. And you would use the id, you would say number one to then get back that post. So that is your query type, your mutation type, as it says again in the comment. Put a single value of type post and then it's going to allow you to. So this is just put post right now, after we enter this, it's going to generate some more stuff that actually lets us create the posts and all that. So I will hold off on that for a quick second. And then this is your actual post type. It has an id, which is what identifies it. And then it just has a title. So this is like the simplest possible thing you can kind of create. This is like a good kind of hello world example with a GraphQL API. Cause you're just saying, all I want my API to have is just some posts.

00:13:02 - Anthony Campolo

I just want those posts to be a thing with a title. That's all we're doing here. It's very, very basic. Once we do that, we're going to click Save schema and now we're going to actually create a resource. So this is really what you're getting here, is you're getting the actual database wired up to your API for you. This is the part that is very challenging, requires all sorts of specialized knowledge and figuring out how your database is going to map to GraphQL. Because every database is different, every database is going to work with GraphQL differently. But what AppSync is doing is it's going to automatically use the existing type that you created. You're gonna say, I wanna use that post type that I created and I wanna create a posts table. And what this is going to do is this is going to create our database for us with a table already set up for our posts. And this is really, really nice. Cause not only is it going to do that, it's also then going to give us all of this extra stuff. So before we only had put post, but now if we look at our mutations, we have create post, we have update post and we have delete post.

00:14:20 - Anthony Campolo

And for each of those, they're taking an input and they're taking Create post input or Update post input or Delete post input. And these are down here, this is something called input types. This is actually in the GraphQL documentation that we were looking at earlier. And it's a way to basically keep your input fields separate. Because when you actually start wiring this up to a front end with a React app or something like that, you're going to have input fields where you'll actually be inputting the data. And with the way React and a lot of this stuff works, you'll have like event handlers and change handlers and things like that. And just like your input is something that is very special, you want to always make sure it's separate and you know exactly what it is, where it is, what it's doing. That's kind of why you extract out the input specifically as its own type. And then there's a whole bunch of other stuff here that we don't really need to get into right now. You don't really need to worry about. So we're just gonna go ahead and create this.

00:15:25 - Anthony Campolo

Sometimes it will yell at you. Cause I already created a post table because I've already done this once before. So I'm just gonna give that a Post 2 and now it won't yell at me. Now what we're going to be able to do is our GraphQL API is. It's set up, it's good to go, we're ready to start creating posts and getting the posts back. So if we go over here, we're now going to go to queries. And here is where you really start to see why GraphQL is so amazing. I'm not sure if you guys are seeing all these, but let me just close that just in case. What's really, really nice about GraphQL is that you are able to always see exactly what you can do with that GraphQL API. So what do I mean by that? If we look over here where it says mutations, this is. These are the mutations that you can do on this GraphQL API. You can create a post, you can delete a post, or you can update a post. And if we select Create post, you see how this is changing over here and you say, okay, I want to create a post and I want to give it a title.

00:16:45 - Anthony Campolo

So now it's saying, okay, you want to do a mutation. You want this mutation to create a post. You want the input that is going to be that post to have a title. And you want that title to say, hello, Mint Bean. Once you've done that, you're going to then click plus. And you also want to add an ID in there, which it. Just look at that. I did the query wrong and it fixed it for me. So you actually need to have ID there. And now it's created this id or it's created this post, this post with that id. And now we want to get rid of that. We want to do a query now. And with our query, we want to get a post, we want to get this post with the id and we want to get the ID back. So that's not going to be very exciting. All it does is give us back the post with the id, but you say, actually no, I want to get the title for my post. And then now you get back the title instead of the id. And if you want both, then you can do that.

00:17:55 - Anthony Campolo

And you don't need to use this thing on the left here. I can just edit this over here and I can change that and get the different things on the side. The only thing that is with this over here, you can just kind of click it and you can just tell it kind of what you want. So it's about integrating all these tools together with really nice interfaces and then say, instead of getting a post, I want to get all of the posts. I want to get the title of all of the posts. Right now I've only got one. Let's say I want to create another one. So let's create a second post and it's going to have title that's going to say, hello, Mint Bean again and we need to have. And so you also see here how it's got this red underline right there. So it says field create post or type post must have a selection of subfields. Did you mean create post post, Blah, blah, blah. So this is why when I said, when I ran this query, this should actually break. This should give you an error. But when I run this query, it says, actually, no, you needed this ID right here.

00:19:04 - Anthony Campolo

So there's all of this tooling built in to basically have your back and make sure that even when you don't quite do the thing you want to do correctly. It's like, I know what you want to do. You actually want to do this. You want that ID right there, I know you do, so I'm going to give it to you. So now we can go back to query and we can do list posts and we want to get the title of all the posts. So here we're saying list posts. We want all the items and we want the title of all the items. So now we're getting back both hello, Mint Bean and hello, Mint Bean again. Cool. So that was pretty much all I wanted to show you guys. If you guys have questions, be happy to answer those. And yeah, let me know how that went. Yes, what database? Everything uses DynamoDB. Under the hood you can get things wired up. The great thing about AppSync and this larger suite of tools called amplify is that AppSync is this piece that sits as a glue layer between a lot of your services.

00:20:19 - Anthony Campolo

So when you do this kind of stuff out of the box, it usually is going to just give you DynamoDB by default because that's like the database that Amazon is like built around. But it's extremely easy to get it wired up with rds, which is like your kind of relational database. So if you're more used to something like MySQL or Postgres, you're not as smooth with like a no SQL document key value kind of database, then you can get wired up with a relational database and it's essentially just as easy. It's the schema is what is universal and then you're allowed. You can take that schema, you can map it to any kind of data source you want and that's what AWS is giving you. It's doing that mapping between your GraphQL API and whatever database you want to talk to.

00:21:07 - Moderator

Awesome. Anthony. Guys, if you have any questions, feel free to unmute yourself or drop the questions in the chat.

00:21:18 - Anthony Campolo

How easy is it to integrate with Gatsby? Sure. So Gatsby has GraphQL baked in out of the box. So I have not personally built a Gatsby project with AppSync or Amplify. I know Nader Dabit has a lot of really great videos about this. If you just search Nader Dabit, Gatsby AppSync, he has a tutorial that will walk you through exactly how to hook up Gatsby to AppSync. I would imagine it would be fairly simple because GraphQL is already integrated with Gatsby and that's the whole point of AppSync. As I said though I've not done it myself so I can't really speak to that. But I would look for Nader Dabit's videos and then why post only? I just wanted to do a very basic, simple example just to kind of show what all of this stuff is. Obviously this is not even close to like a production ready application. Like this is a total toy example, but it's just like a way to kind of start wrapping your mind around these tools and these types of things that you can do with them.

00:22:21 - Moderator

Awesome, awesome. So guys, again please don't be shy, drop all your questions. Maybe it won't be SQL related, just general questions to a web developer.

00:22:39 - Anthony Campolo

Yeah, so projects you could do with this, anything that requires like writing to a database. So if you think about anything that involves like having users that need to have like different accounts and each of those accounts are going to have their own data that they need to get access to. So something that I haven't shown because like I said, I want this to be like a really basic kind of GraphQL101 type talk. But once you have your GraphQL API set up using things like Amplify, you can get authentication set up with just like a few commands and then you can have users and then those users will have access to their own specific kind of data. So I would say like data intensive kind of applications that are going to have users is what this is really, really built for. Like what I showed, like I said, is a very simple example, but you can build really powerful applications. And then because it's attached to DynamoDB and to all this AWS infrastructure, you don't ever have to scale it, you don't ever have to set up load balancers, you don't have to worry about the infrastructure, you don't have to worry about any of that kind of stuff.

00:23:49 - Anthony Campolo

Everything is set to scale by default. That also means your cost might start going up as well, and that's something you need to be aware of. But the service is set to work and if you do happen to get a spike of a thousand users on one day, all of a sudden your app will still work, it's not going to crash. What's the pricing like? So that's a great question. What I showed was all on the free tier, so I haven't paid for anything in terms of like AppSync itself. I don't think there is a cost. Like it's really more about the database. And that's why I say you're gonna be more worried about like what's the cost of your DynamoDB table. That is, that is getting set up. So it's, it's set up so everything is on the free tier automatically. And then once you start hitting certain usage limitations is when you start to get into some of the Firebase. Exactly. Yeah. Firebase is a perfect example of what this is aiming for. You get paid based on once you hit certain usage limitations. But those usage limitations aren't really going to be until you already have users and you have demand.

00:25:04 - Anthony Campolo

Like anything you're building out just as like a proof of concept or see how this stuff works, you're never going to hit usage limitation. And so I would say you'd want to look into pricing for like DynamoDB or pricing of whatever database you have set up, because different databases, all different pricing, they'll have different access kind of stuff. So the database stuff is always really going to be the complicated layer. And AppSync is just giving you kind of nice interface into that database. So that's why I don't think there is a cost for AppSync as far as I know. So. [unclear]. Okay. Someone asked about Neo4j and Cassandra. Yes, this is a great question. Neo4j is what's known as a graph database. This is very confusing because GraphQL has nothing to do with graph databases. It's just a kind of like name that they happen to share. So GraphQL is agnostic to your database. You can use GraphQL with any database. That's kind of what we've been talking about here with like DynamoDB versus like a relational database like a MySQL or a Postgres. So you can use GraphQL with Cassandra, you could use GraphQL with Neo4j.

00:26:18 - Anthony Campolo

You won't necessarily be able to do that with AppSync because AppSync is going to be integrated with AWS databases specifically. So DynamoDB and Cassandra are fairly similar. Cassandra was actually originally based on the first DynamoDB paper and then after the DynamoDB paper was turned into a service, the service was based on Cassandra. It's very confusing history. And so, yeah, so you are going to most likely be using AppSync with a AWS type database, but you can use GraphQL with all sorts of other databases. This is something like, if you've heard of Hasura, like Hasura is a company that exists just to give you a GraphQL interface into Postgres specifically. So this is why, like, this is a huge space. It's like there's so many tools, there's like so many things along. There's so much stuff. That's why it's like I want to give people kind of an end. So it's like by doing AWS AppSync, you can get connected to a database, you can get going without having to necessarily think about all that stuff. But once you're in, you have access to a wide range of databases within aws. So any type of database you'd want, like they have their own version of Neo4J, they have some sort of graph database.

00:27:35 - Anthony Campolo

I don't know what it's called. Then they have like a relational database and then they have a document database. So they have all the different kinds of databases that should fit whatever kind of database model you're familiar with. And then the question of it being middleware like Apollo. So Apollo is many things. Apollo is being used by Redwood. So I'm a little familiar with Apollo. But like I said, it's many things. So there's like the Apollo client and then there's the Apollo server. Like those are two different things. So some people are using both, some people are using one or the other. So I would say AppSync, I believe, would be the equivalent of Apollo Server. I think that may not be 100% correct, but you can think of it as AppSync is the back, the backend piece. And so that is what is like the Apollo Server part, whereas Apollo Client is like the front end piece. And we didn't get into any of the front end client stuff. So if you worked with Apollo Server, that may have some similarities to AppSync, but really it's usually when people talk about Apollo, they're actually talking about Apollo Client.

00:28:43 - Anthony Campolo

So it's just, it's kind of confused there and then for recommendations for newbie resources. Yeah, so unfortunately there's not a ton when it comes to this kind of stuff. Like I said, AWS kind of has a, a reputation for not being super, like, welcoming to new developers. Like, their, their tech is like, it's super powerful and it's actually not as complicated as you think, but it can be hard to kind of get a foot in. I really, really recommend Nader Dabit. I've already mentioned him previously in this talk. Nader Dabit is kind of running the developer relations team at Amplify. So his whole job is really to communicate these technologies, create tutorials. He's got a YouTube channel where he creates lots and lots of projects with AppSync. And I'll go ahead and put his name in the chat for you. It is N-A-D-E-R, Nader, and then Dabit, D-A-B-I-T. Yeah, Fantastic developer advocate. And you could like, you just tweet Adam and he'll answer your questions like he, he's. He's a cool dude.

00:29:52 - Moderator

Yeah, cool. If that's all we have for today, then I think we can wrap it up.

00:30:02 - Anthony Campolo

And I am @AJCWebDev on Twitter. Please feel free to reach out. My DMs are always open. I'm also on the Mint Bean discord. Mint Bean is amazing. This is the fourth Mint Bean talk I have given. I plan to do many more. So definitely in the community. Happy to. Happy to help out.

00:30:22 - Moderator

Thank you, Anthony. Okay, thank you guys for joining us today.

00:30:27 - Anthony Campolo

Happy New Year, everyone.

00:30:29 - Moderator

Happy New Year, everyone. Hope to see you guys on our next workshop. Thank you.

00:30:34 - Anthony Campolo

Thank you. Have a good one.

00:30:35 - Moderator

Have a good one.