From Localhost to the Internet: Deploying My First App on an Oracle VPS with Coolify

One of the biggest differences between building an application and actually shipping it is deployment.

On my local machine, my application worked.

But that doesn't mean it was actually ready for the internet.

I wanted to understand the deployment process myself instead of relying completely on managed platforms.

So I started exploring Oracle Cloud VPS, Docker, and Coolify.

Why a VPS?

A VPS gives me much more control over the environment.

Instead of simply connecting a repository to a hosting platform and clicking deploy, I can actually understand what's happening underneath:

GitHub
   ↓
VPS
   ↓
Docker
   ↓
Application Container
   ↓
Reverse Proxy
   ↓
Domain
   ↓
HTTPS

`

That stack was much more interesting to me than simply pressing a "Deploy" button.

Setting up the Oracle VPS

I used an Oracle Cloud VPS as the server.

The basic process involved:

• Creating the VPS
• Connecting through SSH
• Setting up the server
• Installing Docker
• Configuring networking
• Pointing my domain toward the server
• Setting up deployment infrastructure

At first, the server is basically just a remote Linux machine.

There isn't anything magical about it.

You have to configure it and understand what you're actually running.

Then I discovered Coolify

Managing Docker containers manually works, but once you have multiple applications, databases, domains, SSL certificates, environment variables, and deployments, doing everything manually becomes tedious.

That's where Coolify became useful.

Coolify provides a self-hosted platform for deploying and managing applications on your own infrastructure.

Instead of manually running deployment commands every time, I can connect my GitHub repository and let Coolify handle much of the deployment workflow.

The basic flow becomes:

text
Push code to GitHub
↓
Coolify detects the change
↓
Build application
↓
Create Docker container
↓
Start container
↓
Configure routing
↓
Application is live


That changes the development experience quite a bit.

The part I actually learned

The interesting part wasn't installing Coolify.

It was understanding what Coolify was doing for me.

When a deployment fails, I can't just think:

"Coolify is broken."

I need to understand the layers underneath it.

Is the application failing to build?

Is Docker failing?

Is the container crashing?

Is the port incorrect?

Is the reverse proxy configuration wrong?

Is DNS pointing to the wrong server?

Is the firewall blocking traffic?

Is an environment variable missing?

Deployment forced me to think about my application as something that has to exist outside my development machine.

Docker changed how I think about deployment

Before working with containers, deployment can feel like:

text
"Put my code on a server."


With Docker, I started thinking more like:

text
"My application needs a reproducible runtime environment."


The application, its dependencies, configuration, and runtime requirements need to work together.

That makes the deployment process much easier to reason about.

The biggest lesson

Getting an application to work on localhost is only one part of development.

A real application also needs:

• A reliable deployment process
• Proper environment configuration
• Domain and DNS configuration
• HTTPS
• Logs
• Container management
• Server monitoring
• Backups
• Security

And I'm still learning these parts.

But now I can deploy my own applications to my own VPS instead of treating deployment as some mysterious process that happens after development.

That's a pretty important step for me.

**Building the application is only half the job.

Learning how to ship and operate it is the other half.**

devops #docker #coolify #oraclecloud #vps #deployment #linux #buildinpublic