Introduction
When developers think about deploying a frontend application to AWS Amplify, one of the first things that comes to mind is connecting a Git repository.
The typical workflow involves pushing application code to GitHub, connecting the repository to AWS Amplify, configuring the build process, and allowing Amplify to automatically deploy the application whenever changes are pushed to the selected branch.
However, connecting a Git repository is not the only way to deploy an application with AWS Amplify.
AWS Amplify also supports manual deployments, which allow developers to deploy frontend applications by uploading a ZIP archive containing their application files.
This is particularly useful when:
- You have a static website that does not require a build process.
- You want to deploy a frontend application without creating a Git repository.
- You are working with HTML, CSS, and JavaScript files.
- You want to host a frontend application independently of your backend infrastructure.
- You need a straightforward way to publish a website directly from your local machine.
In this guide, we will walk through the process of deploying a frontend application to AWS Amplify without using Git.
We will use a simple static frontend application containing HTML, CSS, and JavaScript files to demonstrate the process.
By the end of this tutorial, you should have a publicly accessible website hosted on AWS Amplify.
1. Understanding AWS Amplify Hosting
Before deploying anything, it is important to understand what AWS Amplify does.
AWS Amplify Hosting is a managed hosting service designed for modern web applications and static websites.
It provides infrastructure for hosting frontend applications without requiring developers to manually configure web servers, manage operating systems, or maintain hosting infrastructure.
When you deploy an application using Amplify, AWS handles several hosting responsibilities, including:
- Hosting and serving your frontend files.
- Providing a publicly accessible application URL.
- Distributing application content through its hosting infrastructure.
- Supporting HTTPS for deployed applications.
- Managing deployment versions.
For this tutorial, we will use Amplify's manual deployment capability.
Unlike repository-based deployments, manual deployments do not require Amplify to connect to a source code repository.
Instead, we prepare our application files locally, compress them into a ZIP archive, and upload that archive through the Amplify Console.
The deployment process looks like this:
Local application files → ZIP archive → AWS Amplify Console → Manual upload → Deployment → Live application.
2. Prerequisites
Before proceeding, make sure you have the following:
- An active AWS account.
- Access to the AWS Management Console.
- A frontend application you want to deploy.
- A ZIP utility or the ability to create ZIP archives from your operating system.
- A modern web browser.
You do not need:
- A GitHub account.
- A GitLab account.
- A Bitbucket account.
- A connected Git repository.
- A configured CI/CD pipeline.
- An EC2 instance or web server.
For this demonstration, we will use a simple frontend project with the following structure:
my-frontend-app/ │ ├── index.html ├── styles.css └── main.js These files represent a basic static frontend application.
If your application uses React, Vue, Angular, or another frontend framework, you can also deploy it this way, provided you first generate its production build output.
For example, a React application built with Vite typically produces a dist directory. The contents of that directory, rather than the entire development project, are what you would package for deployment.
3. Prepare Your Application Files
The first step is to prepare the files that Amplify will serve.
Navigate to your frontend project directory.
Before proceeding, make sure that:
- Your HTML file exists.
- Your CSS and JavaScript references point to the correct paths.
- Your application works locally.
- All assets required by the application are included.
For applications that communicate with backend services, check that API endpoints and other environment-specific configuration values are correct for the environment you are deploying.
4. Create a ZIP Archive of Your Application
This is one of the most important steps in the entire process.
AWS Amplify expects the ZIP archive to contain the files that should be deployed.
A common mistake is compressing the entire project folder instead of compressing the contents of the folder.
For example, consider this ZIP structure:
my-frontend-app.zip │ └── my-frontend-app/ ├── index.html ├── styles.css └── main.js This structure introduces an unnecessary directory level.
For a simple static application, the preferred structure is:
my-frontend-app.zip │ ├── index.html ├── styles.css └── main.js The index.html file should be at the root of the archive so Amplify can serve it as the website's entry point.
Creating the ZIP file using Linux or WSL
If you are using Ubuntu, Linux, or Windows Subsystem for Linux (WSL), navigate into your frontend directory:
cd my-frontend-app Run:
zip -r ../frontend-deploy.zip . This creates a ZIP archive in the parent directory.
The important detail is the final dot (.).
It tells the zip command to archive the contents of the current directory rather than placing the entire directory inside the archive.
Creating the ZIP file using Windows
You can also create the archive using Windows File Explorer.
- Open your frontend project folder.
- Select the files you want to deploy.
- Right-click the selected files.
- Select Compress to ZIP file or Send to → Compressed (zipped) folder, depending on your Windows version.
- Give the archive a descriptive name, such as
frontend-deploy.zip.
Make sure you select the application files inside the folder rather than compressing the parent folder itself.
Verify the ZIP archive
Before uploading, inspect the contents of your ZIP file.
On Linux or WSL, run:
unzip -l frontend-deploy.zip The output should resemble:
index.html styles.css main.js If you see an additional enclosing project directory, recreate the archive with the correct structure.
This small verification step can prevent unnecessary deployment problems.
5. Open the AWS Amplify Console
Now that your ZIP archive is ready, we can move to AWS.
- Sign in to the AWS Management Console.
- Search for AWS Amplify in the services search bar.
- Open the AWS Amplify service.
- Navigate to the Amplify applications dashboard.
You can also access the service directly:
https://console.aws.amazon.com/amplify/
Make sure you are working in the AWS Region where you intend to manage your application.
6. Create a New
Inside the Amplify Console:
- Select Create new app.
- Look for the option to deploy without connecting a Git provider.
- Select the manual deployment workflow.
Depending on the current Amplify Console interface, this option may appear as Deploy without Git provider or under a manual deployment section.
The important thing is to avoid selecting GitHub, GitLab, Bitbucket, or another repository provider.
You are creating an application that will receive its deployment files through manual uploads.
7. Configure Your Application
The next step is to provide basic application details.
You may be asked to specify:
- Application name.
- Branch name.
- Deployment method.
For example:
| Setting | Example value |
|---|---|
| Application name | my-frontend-app |
| Branch name | production |
| Deployment method | Manual deployment |
The application name helps identify your project in the Amplify Console.
The branch name is a deployment identifier. It does not mean you need to create or connect a Git branch.
You can use a name such as production to represent the deployment environment.
After entering the required information, proceed to the deployment configuration screen.
8. Upload Your ZIP Archive
This is where the actual deployment package is provided.
On the manual deployment screen:
- Locate the ZIP file upload section.
- Select your
frontend-deploy.ziparchive. - If the console requests an application or branch selection, ensure you have selected the correct application and deployment branch.
- Review the deployment details.
- Start the deployment.
AWS Amplify will upload and process the archive.
Since we are deploying a static application without a build process, there is no need to configure a build specification such as amplify.yml.
Amplify can host the supplied static files directly.
Wait for the deployment to finish.
9. Verify the Deployment
Once Amplify successfully deploys your application, the deployment status should indicate that the application has been deployed.
The console will provide a default application URL.
It typically follows this format:
https://branch-name.application-id.amplifyapp.com Open the URL in your browser.
You should see your deployed application.
If you deployed the example from this tutorial, you should see:
Welcome to My Website This application is hosted on AWS Amplify. Also open your browser's developer tools and inspect the Console and Network tabs.
Check for:
- JavaScript errors.
- Missing CSS files.
- Missing JavaScript files.
- Failed asset requests.
- Incorrect API requests.
A successful deployment does not automatically mean every part of the application is functioning correctly. Always test the deployed application itself.
10. Updating Your Application Without Git
One advantage of manual deployment is that you can publish updates without pushing code to a repository.
Suppose you make changes to your frontend application.
For example, you update:
index.htmlstyles.cssmain.js
The process is straightforward.
Step 1: Modify your local application files.
Step 2: Test the changes locally.
Step 3: Create a new ZIP archive containing the updated application files.
Step 4: Open the AWS Amplify Console.
Step 5: Select your existing Amplify application and deployment branch.
Step 6: Start another manual deployment using the updated ZIP archive.
Step 7: Wait for Amplify to finish deploying.
Step 8: Open your application URL and verify the changes.
You do not need to create another Amplify application every time you update your website.
You simply create a new deployment for the existing application.
11. Common Problems and How to Fix Them
Although manual deployment is relatively straightforward, a few issues can prevent an application from working correctly.
Problem 1: The deployed website displays a 404 error
One possible cause is an incorrect ZIP archive structure.
For example:
frontend-deploy.zip └── frontend/ └── index.html For a simple static application, the entry point should be at the archive root:
frontend-deploy.zip └── index.html Solution: Recreate the ZIP archive using the contents of the frontend directory rather than the directory itself.
Problem 2: CSS files are not loading
This can happen when the paths specified in your HTML file do not match the deployed file structure.
For example:
<link rel="stylesheet" href="./styles.css"> This expects styles.css to be available relative to the HTML file.
Solution: Verify the paths and ensure all required files are included in the ZIP archive.
Problem 3: JavaScript files are not loading
Check that the JavaScript file exists and that its reference in your HTML file is correct.
For example:
<script src="./main.js"></script> Also inspect the browser's developer console for JavaScript errors.
Problem 4: The application loads, but API requests fail
This is particularly important for applications that communicate with backend services.
Your frontend might load successfully while requests to API Gateway, Lambda-backed endpoints, or other backend services fail.
Possible causes include:
- Incorrect API endpoint configuration.
- CORS configuration problems.
- Incorrect authentication tokens.
- Invalid Cognito callback or logout URLs.
- Backend authorization failures.
Solution: Verify the frontend configuration and inspect the browser's Network tab to identify the actual failing request.
If your application uses Amazon Cognito for authentication, make sure the deployed Amplify URL is registered as an authorized callback URL and logout URL in the Cognito app client.
Problem 5: Changes are not appearing after deployment
Sometimes your browser may continue displaying an older cached version of your application.
Solution:
- Confirm that the latest deployment completed successfully.
- Open the application in a private browsing window.
- Perform a hard refresh.
- Inspect the Network tab to verify which files are being loaded.
Also check whether your application uses a service worker or other caching mechanism.
12. Important Considerations When Using Manual Deployments
Manual ZIP deployments are convenient, but there are some limitations worth understanding.
No automatic deployment from Git
Because your application is not connected to a Git repository, Amplify will not automatically detect changes in your local project.
You must create and upload a new ZIP archive whenever you want to publish an update.
No automatic build process
A manual ZIP deployment is suitable for files that are already prepared for hosting.
For frameworks such as React, Vue, and Angular, generate the production build first and upload the resulting build output.
For example, with Vite:
npm run build This normally generates a dist directory.
You should package the contents of that directory, ensuring that index.html is at the root of the archive.
Do not upload your entire development project with node_modules and source files when the production build output is all that is required.
Backend services are not automatically deployed
Uploading a frontend ZIP archive does not deploy your backend infrastructure.
If your application depends on services such as:
- Amazon API Gateway
- AWS Lambda
- Amazon Cognito
- Amazon DynamoDB
- Amazon S3
- Amazon Bedrock
Those services must already be provisioned and configured separately.
Amplify Hosting is responsible for hosting the frontend files in this deployment workflow.
Authentication and API configuration still matter
For applications that use authentication or communicate with backend services, make sure the production configuration is correct before uploading your archive.
A website can be successfully deployed while authentication or backend integration remains broken.
13. Conclusion
Deploying a frontend application to AWS Amplify does not always require a Git repository.
With manual deployments, developers can prepare their application files locally, package them into a ZIP archive, and upload the archive directly through the AWS Amplify Console.
The process is particularly useful for static websites, small frontend applications, prototypes, and projects where a repository-based deployment pipeline is unnecessary.
The overall workflow is simple:
- Prepare your frontend application.
- Ensure the required files are available.
- Create a ZIP archive with the correct directory structure.
- Open the AWS Amplify Console.
- Choose the manual deployment option.
- Upload the ZIP archive.
- Deploy the application.
- Verify the live website.
- Repeat the process whenever you need to publish an update.
The important lesson is that Git is not a mandatory requirement for hosting a frontend application on AWS Amplify.
If your application is already prepared for production, a ZIP archive is enough to get it deployed.
Additional Resources
Disclaimer: AWS Console labels and deployment screens may change over time. The exact wording of the manual deployment option may vary, but the ZIP-based deployment workflow remains the central approach described in this guide.



