AWS Builder Center
How I Deployed My Portfolio with Docker, Nginx, and AWS

How I Deployed My Portfolio with Docker, Nginx, and AWS

In this article, I share my experience deploying my personal developer portfolio on AWS using Docker, Nginx, Ubuntu, DNS, and HTTPS. I explain the deployment architecture, containerization process, reverse proxy configuration, and key DevOps lessons I learned while making the application production-ready.

How I Deployed My Portfolio with Docker, Nginx, and AWS

Building a portfolio website is not only about creating a good-looking frontend. For me, it was also an opportunity to apply the DevOps concepts I have been learning to a real-world project.
I wanted my portfolio to showcase not only my projects and skills, but also my ability to build, containerize, deploy, and manage a web application using modern DevOps practices.
You can view my portfolio here:

Technology Stack

For this deployment, I worked with:
  • AWS EC2
  • Ubuntu Linux
  • Docker
  • Nginx
  • Git and GitHub
  • DNS
  • HTTPS/SSL

Deployment Architecture

The basic architecture of my deployment is:
User ↓ devdawood.site ↓ AWS EC2 ↓ Nginx ↓ Docker Container ↓ Portfolio Application
This architecture helped me understand how different components of a production deployment work together.

Containerizing the Application with Docker

I used Docker to package my portfolio application and its required dependencies into a container.
The basic workflow was:
Application ↓ Dockerfile ↓ Docker Image ↓ Docker Container ↓ AWS EC2
Using Docker makes the application environment more consistent and makes deployment easier to reproduce.
Instead of installing all application dependencies directly on the server, the application runs inside a container.

Deploying on AWS EC2

I deployed the application on an AWS EC2 instance running Ubuntu Linux.
After setting up the server, I installed Docker and ran my portfolio application inside a container.
The application was exposed on its internal application port, while Nginx handled incoming web traffic.
This gave me practical experience with AWS infrastructure, Linux server administration, Docker, networking, and application deployment.

Using Nginx as a Reverse Proxy

One of the most useful parts of this project was configuring Nginx as a reverse proxy.
Instead of allowing users to access the application container directly, Nginx acts as the public entry point.
The flow looks like this:
Internet ↓ Nginx ↓ Docker Container ↓ Portfolio Application
Nginx receives the request and forwards it to the application running inside Docker.
This approach provides a clean separation between the public-facing web server and the application.
It also gives me a foundation for adding additional features such as SSL termination, security headers, caching, and load balancing in the future.

Domain and DNS

I connected my custom domain, devdawood.site, to the AWS-hosted application using DNS configuration.
DNS translates a human-readable domain name into the destination required to reach the server.
Working with DNS also helped me understand that deploying a website involves more than simply running an application on a server.
There are several infrastructure layers involved:
Domain ↓ DNS ↓ AWS EC2 ↓ Nginx ↓ Docker ↓ Application

HTTPS and SSL

I also configured HTTPS for my portfolio so that visitors can securely access:
HTTPS encrypts communication between the browser and the server and is an important part of a production-ready web application.

What I Learned

This project gave me practical experience with several important DevOps concepts.

1. Docker and Containerization

I learned how to package an application into a Docker image and run it as a container.

2. Linux Server Administration

Working with Ubuntu helped me become more comfortable with SSH, file permissions, processes, networking, services, logs, Nginx configuration, and Docker commands.

3. Reverse Proxy

I learned how Nginx can receive public traffic and forward requests to an application running on another port.

4. DNS

Configuring my domain helped me understand how DNS connects a domain name with a server.

5. Cloud Deployment

Deploying the portfolio on AWS EC2 gave me hands-on experience with cloud infrastructure.

6. Production Deployment

The biggest lesson I learned is that deploying software involves much more than writing application code.
A simplified deployment lifecycle looks like:
Develop ↓ Version Control ↓ Build ↓ Containerize ↓ Deploy ↓ Configure Infrastructure ↓ Secure ↓ Monitor

What's Next?

This project is part of my journey toward becoming a stronger DevOps Engineer.
My next areas of focus include:
  • CI/CD automation
  • Terraform
  • Kubernetes
  • Prometheus and Grafana
  • AWS architecture
  • Infrastructure as Code
  • Automated deployments
  • Cloud security
I want to continue moving from manual deployments toward automated CI/CD pipelines and more scalable infrastructure.

Final Thoughts

My portfolio started as a way to showcase my projects and skills, but deploying it on AWS turned it into a practical DevOps learning project.
It gave me hands-on experience with AWS, Docker, Linux, Nginx, DNS, networking, HTTPS, and application deployment.
The most valuable part was not simply getting the website online. It was understanding how all these technologies work together.
I'm continuing to build, experiment, and learn one deployment at a time.
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