How I Structure an AWS Amplify Gen 2 Application

I start an AWS Amplify Gen 2 architecture with user journeys, not a list of AWS services. The public visitor, signed-in user, editor, and scheduled job each need a clear path through the application. Once I can describe those paths, I can decide which data, authentication, storage, and function resources belong together.

Amplify lets a project define backend resources in TypeScript. That convenience does not remove architecture work. Resource names, permissions, failure handling, and deployment ownership still determine whether another developer can operate the application six months later.

Map the user-facing paths

I write a short sequence for each important action. A contact request might pass through browser validation, a server function, an email provider, and an audit event. A published article might pass through an editor identity, a data mutation, and cache revalidation. These paths show where trust changes and where a failure must be reported.

I keep optional features outside the first map. Building every possible resource at the start makes authorization and deployment reviews noisy. The first backend should support the smallest complete user journey.

Group resources by responsibility

I keep auth definitions with identity concerns, data schemas with their authorization rules, storage with path policies, and each function in a directory named for its job. The backend entry file composes those resources. It should read like an inventory rather than contain every implementation detail.

Functions get narrow names such as send-contact-notification or publish-scheduled-posts. A generic utilities function tends to collect unrelated permissions and makes incident diagnosis slower.

Define authorization with the data

Every model gets a stated audience and operation list. I decide public read, signed-in access, owner access, and administrator access before connecting the frontend. The Amplify authorization documentation is the reference for the rule syntax and its current limitations.

I also review fields that should never reach a public query. Splitting internal notes, delivery details, or private identifiers into a protected model can be clearer than relying on every query to omit them.

Keep external systems behind functions

Email providers, payment services, and private APIs need credentials that do not belong in browser code. I put those calls in an Amplify Function, validate its input, and return a small result that the interface can explain. The Amplify Functions documentation covers the current resource and handler structure.

A function also needs an owner, timeout expectation, retry decision, and logging policy. I avoid recording message bodies or credentials in logs. Operational details belong in the design because they affect support after launch.

Design environments before the first release

I decide which Git branches can deploy, which values differ by branch, and who can promote a change. Development can use synthetic data. Staging should resemble production without delivering mail or modifying real records. Production receives only changes that passed the same repeatable checks.

The Amplify fullstack branch deployment documentation explains isolated fullstack branch deployments. I still verify the generated outputs file and deployed commit because a successful build can point the frontend at the wrong backend.

Write rollback and ownership notes

Infrastructure changes can alter data models and permissions, so rollback is more than redeploying old frontend code. I record whether a schema change is backward compatible, how data will be restored, and which resources must be retained.

• Map each user journey and trust boundary.
• Keep resource files focused.
• Test authorization before UI polish.
• Separate branch configuration.
• Document deployment and recovery ownership.

Need help with Amplify?

Terry Hunt Dev helps teams plan and build full-stack applications through AWS development and Next.js development. Use the contact form to describe the user journeys and backend resources you need reviewed.