Building fullstack Amplify applications with the new AWS MCP

by Galib Sarayev

AWS has announced AWS MCP with additional Standard Operational Procedures (SOPs) that helps frontend developers to design, build, and deploy fullstack applications with AWS Amplify. Instead of manually piecing together guidance from documentation, examples, forum posts, trial-and-error or best practices, Amplify developers can now rely on an MCP-powered workflow that provides structured, high-quality guidance for fullstack Amplify development.

Amplify is a proven service that makes building cloud-connected apps much easier for frontend and fullstack developers. It offers clear, high-level tools that simplify both the backend and the frontend implementation. On the backend, features like authentication, APIs, storage, and serverless functions can be defined declaratively. On the frontend, Amplify integrates smoothly with popular frameworks like React, Next.js, and React Native. The new agentic experience provided by AWS MCP builds on this foundation by adding an agent-ready layer of structured guidance that developers can use directly inside AI tools.

Instead of generating arbitrary advice, agents equipped with AWS MCP now follow curated Standard Operating Procedures (SOPs) that reflect established Amplify best practices. These SOPs capture recommended patterns for backend setup, frontend integration, and deployment workflows. The result is output that is not only functional but aligned with the way Amplify is intended to be used.

Fullstack Guidance Through SOPs

The AWS MCP offers several Amplify-specific SOPs that guide the agents through the lifecycle of building and deploying an application with Amplify:

amplify-backend-implementation
Helps the agent implement well-structured backend applications using Amplify's capabilities such as Auth, Data, Storage, and Functions etc. It promotes recommended patterns, secure defaults, and idiomatic use of Amplify's backend abstractions.

amplify-frontend-integration
Guides integration of the Amplify backend with modern JavaScript and TypeScript frameworks. This includes state management recommendations, data binding patterns, and configuration best practices using the Amplify libraries.

amplify-deployment-guide
Walks the agent through deploying the application using Amplify. It covers branch-based workflows, CI/CD configuration, environment setup, and operational guardrails.

These SOPs ensure the agent does not simply generate code but produces code that aligns with Amplify's design principles.

Curated, Agent-Optimized Documentation

In addition to SOPs, the AWS MCP includes curated Amplify documentation that has been optimized for retrieval and consumption by agents. Rather than relying on generic search results or unstructured pages, agents can now query well-organized, purpose-built instructional materials.

This curated content allows agents to provide more precise implementation details, produce fewer incorrect assumptions, and reference supported patterns. Developers benefit from clearer explanations, more robust examples, and recommendations that correspond to the current Amplify ecosystem.

What This Enables

You can now:

• Generate consistent fullstack Amplify project scaffolds aligned with best practices
• Get detailed and up-to-date backend guidance including Auth, Storage, APIs, Functions etc.
• Receive frontend integration steps for frameworks such as React, Vue.js, Angular, Next.js etc.
• Implement secure deployment flows using environment-aware Amplify Hosting
• Ask architectural questions and get answers that reflect recommended Amplify usage
• Accelerate prototyping and reduce implementation errors

Getting Started

Prerequisites

Note: You can see the whole list of prerequisites in the MCP's official documentation.

Before setting up the AWS MCP Server, make sure you have the following:

Core Requirements

• Python 3.10+ installed on your machine
• uv package manager installed
• AWS credentials configured locally (via aws configure, SSO, or environment variables)
• An MCP-compatible AI client (e.g., Kiro CLI, Claude Desktop, etc.)

IAM Permissions (Required if you're not using an Administrator role)

Note: Skip this section if your AWS credentials already use an Administrator role.

If you're using a non-admin IAM user or role, you must explicitly grant permissions for AWS MCP Server operations.

To configure IAM permissions:

1. Open the IAM console: https://console.aws.amazon.com/iam/
2. Select the user or role associated with your AWS credentials
3. Attach the following IAM policy:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "aws-mcp:InvokeMCP",
            "aws-mcp:CallReadOnlyTool",
            "aws-mcp:CallReadWriteTool"
         ],
         "Resource":"*"
      }
   ]
}

Additional Credential Requirements for Amplify

• To deploy Amplify Gen 2 sandbox environments, your credentials must include permissions equivalent to the AmplifyBackendDeployFullAccess AWS-managed policy.
• To create or manage Amplify applications and deploy Amplify Gen 2 backends, use credentials with the AdministratorAccess-Amplify AWS-managed policy.

Configuration

Configure the MCP server in your MCP client configuration. For this blog we will focus on Kiro CLI. Edit .kiro/settings/mcp.json:

{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "timeout": 100000,
      "transport": "stdio",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://aws-mcp.us-east-1.api.aws/mcp",
        "--metadata", "AWS_REGION=us-west-2"
      ]
    }
  }
}

Replace us-west-2 with your preferred default AWS Region. If you do not provide a region as metadata, operations default to us-east-1.

You can see the full set up guide in the official AWS MCP documentation.

Example Use Case With Kiro CLI

In this example, we'll build a fullstack React application using an Amplify Gen 2 backend and the Amplify JavaScript and UI libraries with the help of AWS MCP.

Step 1: In your terminal, run kiro-cli chat to start using Kiro CLI and run /tools to check the tools from AWS MCP are available.

Step 2: Prompt the agent to implement backend for your application. Allow the SOP to execute aws___retrieve_agent_sop tool to retrieve amplify-backend-implementation SOP.

Step 3: Prompt the agent to implement frontend for the application and integrate it with the already implemented backend using Amplify libraries. In case agent asks, allow it to execute aws___retrieve_agent_sop tool to retrieve amplify-frontend-integration SOP.

Step 4: Ask agent to deploy the Amplify backend as sandbox for the testing purposes. Observe the agent executing aws___retrieve_agent_sop tool to retrieve amplify-deployment-guide SOP (in case agent asks, allow it to execute the tool).

The agent will follow the deployment guide, deploy the backend as a sandbox environment, and generate amplify_outputs.json to connect the frontend to the deployed backend.

Step 5: Start the frontend locally, and see the integration with Amplify backend. Continue iterating on the application.

Step 6: If satisfied with the final state of the application, ask the agent to deploy the application to production and set up CI/CD for it using Amplify Hosting.

The agent will go through the deployment guide and:

• Verify required dependencies are installed
• Verify project structure
• Set up a git repository
• Create a new Amplify app
• Connect the amplify to the git repository created for the CI/CD deployment
• Push changes to the git
• Start and monitor deployment, if the deployment fails, agent will troubleshoot it for you and fix accordingly

Step 7: When you need to search for knowledge about Amplify, the agent can use the search_documentation with amplify as topic filter.

Step 8: When you no longer need the environments you created, clean them up to avoid unnecessary costs:

• To delete the sandbox environment, run npx ampx sandbox delete following the Amplify documentation, or delete the sandbox directly from the AWS Console.
• To delete the production deployment, run aws amplify delete-app --app-id <your-app-id> via the AWS CLI, or remove the application from the AWS Console.

Conclusion

The introduction of AWS MCP support for Amplify marks a meaningful step forward in how developers build cloud-connected applications. By combining Amplify's high-level abstractions with structured SOPs and curated documentation, AI tools can now generate applications that are not only functional but aligned with recommended patterns. This reduces friction, accelerates development, and improves the reliability of AI-assisted workflows. Whether you are experimenting with new ideas or building production systems, the Amplify MCP offers a clearer, more consistent path to delivering well-architected fullstack applications on AWS. The new AWS MCP does not replace developer expertise, but it amplifies it—removing friction, reducing misconfigurations, and accelerating how fullstack cloud apps are built.

Comments

[Art light]

Thanks for sharing this — you explained the new AWS MCP capabilities in such a clear and helpful way. I really appreciate how you broke down the SOPs and showed their real value for fullstack Amplify development. It definitely makes me more interested in trying this workflow myself. Great job putting this together!

[AWS FAN]

Great writeup! Thanks for sharing this!