AWS Builder Center
What Building a Ship-It Project Taught Us About AWS !

What Building a Ship-It Project Taught Us About AWS !

How to ship something during hack, what surprised us, what annoyed us, and what we'd tell you before you start

i love transition from kernel to cloud

So, a bit of context :>

We spent hackathon building a real, deployed project not a slide deck, not a "this would work in theory" demo, an actual thing with a live URL that real people could break. And in doing that, we ended up spending a lot of quality time with a handful of AWS services.
This post isn't about the project. It's about the services. What worked, what tripped us up, what we'd tell a friend starting from zero. Let's get into it.

AWS Amplify Hosting > the "wait, that's it?" moment

Honestly this was almost suspiciously easy. we connected our GitHub repo, hit deploy, and our React frontend was just... live. No server to configure, no build pipeline to babysit. If you've ever lost an afternoon to Nginx configs, you'll understand why this felt like cheating a little.

Amazon API Gateway > does the boring stuff so you don't have to

We went with the HTTP API flavor (cheaper, simpler than REST) and let it handle auth checks, CORS, and rate limiting for us instead of writing that logic ourselves. The one moment of "wait, why isn't this working" came from CORS being picky about origins our local dev URL and our live Amplify URL are different, and we had to remember to allow both. Small gotcha, easy fix, but it'll get you at 2am if you're not expecting it.

AWS Lambda > one function to rule them all

We could've split our backend into a dozen tidy little Lambda functions. We didn't. We shoved everything into one function, and honestly? For a small team on a deadline, that was the right call. One place to debug, one set of logs to check, one IAM role to think about. Is it the "correct" microservices way to do it? No. Did it let us actually ship? Yes.

Amazon Cognito > good bones, but read the fine print

Signup and login worked pretty much out of the box. Where it got interesting was when we wanted certain user data (their registered area, in our case) to be locked in permanently the moment they sign up no editing it later, even if someone tries to mess with their token. Cognito can absolutely do this, but you have to dig a bit to find exactly how to mark an attribute as truly immutable. Don't assume it's the default.

Amazon DynamoDB > great, once you stop thinking like it's SQL

On-demand billing meant zero capacity planning, which is exactly what you want when you don't have time to plan anything. But if you're coming from a relational database background like we were, get ready for a small mental shift: there's no built-in "unique constraint" here. Want to stop someone from doing the same action twice? You're building that yourself with conditional writes and careful key design. Once it clicks, it's fine. Getting there takes a minute.

Amazon S3 > signed URLs are your best friend

We needed users to upload photos without ever making our bucket public. The answer was short-lived signed upload URLs (locked to specific file types and sizes) and signed URLs again for viewing. Once you've set this pattern up once, you'll want to use it everywhere — it keeps everything private while still letting the browser talk directly to S3 instead of routing files through your backend.

Amazon Bedrock > impressive, but don't trust it blindly

This was easily the most fun and the most nerve-wracking part. We used Nova Lite to generate plain-language summaries from real data. Two honest notes: getting IAM permissions scoped down to just one specific model took more digging than we expected. And more importantly — if you're having a model summarize anything with numbers in it, check those numbers against your real data before showing anyone. We ended up building our own little verification layer just for this, plus a fallback for when generation fails. Worth the extra hour, every time.

IAM and IAM Identity Center > boring, but this is the part that keeps you safe

Locking down our Lambda's permissions to exactly what it needed (specific tables, specific S3 folders, one Bedrock model, nothing more) took some patience but was worth every bit of it. And for logging into AWS ourselves, IAM Identity Center meant nobody on the team had a long-lived access key sitting on their laptop. One less thing to accidentally leak, one less thing to worry about.

AWS SAM / CloudFormation > one command, whole backend

Our entire backend — API, Lambda, Cognito, tables, permissions — lives in one template. Anyone on the team can blow it away and redeploy the whole thing with a single command, which is a great feeling when you're moving fast. The downside: once that template grew, even tiny code tweaks triggered a full stack diff, which slowed down our rapid "change it, test it, change it again" loop during crunch time. Worth it overall, just know it's a tradeoff.

Amazon CloudWatch > nothing fancy, but you'll live in it

Basic Lambda logs, short retention. Nothing exciting to say here except that we opened it constantly while debugging, so setting up sensible logging early saved us a lot of squinting later.

The actual takeaway :)

None of these services are new or exotic you've probably heard of every single one already. But there's a real difference between reading about a service and actually deploying something real on it under a ticking clock. That's where you find out what's genuinely easy, what needs a workaround, and what's going to bite you if you're not careful.
The credits we got for this hackathon are the reason we got to learn all of this hands-on instead of just theorizing about it so, genuinely, All thanks to WeMakeDevs and AWS team !
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article