NEW
New: Deploy your application in minutes with Shard AI

Build and host your custom Docker images

Create an image from a Dockerfile in a ZIP or RAR archive, or import a GitHub repository. Review the Dockerfile, follow the build logs, then create an application from the finished image. Requires the Core plan or higher.

Bring your own Dockerfile

100 MB

max build context

Core+

plan required

GitHub

rebuild on push

Live

build logs

Comparison

Custom image, standard runtime or VPS?

Three ways to run a workload on Shard Cloud, and what each one leaves to you.

Runtime and system packages

Custom Docker image
Anything your Dockerfile installs
Standard runtime
The supported languages and versions
Virtual machine
Full root access to the OS

How it starts

Custom Docker image
The image's own ENTRYPOINT and CMD
Standard runtime
Auto-detected, or your own start command
Virtual machine
A service you write and supervise yourself

Build and deploy

Custom Docker image
ZIP, RAR or GitHub, with a rebuild on every push
Standard runtime
GitHub or a ZIP or RAR file
Virtual machine
Manual, over SSH

Storage

Custom Docker image
Persistent under /app; the rest of the image is read-only
Standard runtime
Persistent 10 GB disk, everything under /app is kept
Virtual machine
A full disk that you manage

HTTPS and domain

Custom Docker image
Free shardweb.app subdomain when the web option is on
Standard runtime
Free shardweb.app subdomain with SSL
Virtual machine
You issue and renew the certificate

Server maintenance

Custom Docker image
Your base image and its updates
Standard runtime
None
Virtual machine
OS, security and updates are on you

The standard runtimes are Node.js, Python, Go, Java, PHP, .NET, Ruby, Elixir and static sites. Custom images need the Core plan or higher.

Connected outcomes

A repeatable custom-image pipeline

Move from uploaded source to a running custom image without managing a separate registry or build host.

Explore capabilities

Archive or GitHub source

Upload a ZIP or RAR archive, or select a connected GitHub repository before the image build starts.

Review before building

Inspect your Dockerfile before creating or rebuilding the image.

Build logs, then deploy

Open the image logs as it builds, then create an application from the finished image in the Docker images dashboard.

Built to operate

A clear pipeline from source to a running image.

Builds run on Shard Cloud and the image is stored in an internal registry. Applications created from it show up on the image card, so you can see what depends on it.

ZIP, RAR or GitHub

Upload an archive of up to 100 MB with the Dockerfile at its root, or import a GitHub repository.

Built and stored for you

Builds run on Shard Cloud and the image lands in an internal registry, so there is no build host or registry for you to maintain.

Rebuild on push

Link a repository and every push to the branch you pick starts a rebuild. Running applications keep their current version until you restart or redeploy them.

Live build logs

Follow the build output as it streams in. If a build fails, the error shows on the image card.

Dockerfile preview

Review your Dockerfile before it's used to create or rebuild the image.

Progressive setup

From Dockerfile to running app, step by step.

Upload your source, watch the image build in real time, then create an application from it the moment it's ready.

Get started
01
Send the source
Name the image, then upload a ZIP or RAR (up to 100 MB) with a Dockerfile at its root, or import a GitHub repository.
02
Review and build
Check the Dockerfile preview, start the build and follow the logs until the image shows Ready.
03
Create an app from the image
Choose a name, RAM, optional environment variables and an optional web subdomain. Link GitHub to rebuild on every push.

From connection to the first decision, in one flow.

Frequently asked questions

Frequently asked questions about Docker images

Yes. Shard Cloud builds a Docker image from your Dockerfile and runs it as an application. Upload a ZIP or RAR archive with a Dockerfile at its root, or import a GitHub repository, then create an application from the finished image. The image's own ENTRYPOINT and CMD decide how it starts.

We always recommend using a standard runtime, and a custom Docker image only when the standard runtime can't do what you want. Standard runtimes cover the supported languages (Node.js, Python, Go, Java, PHP, .NET, Ruby, Elixir) and static sites: there is no Dockerfile to write, the platform detects how to start your app, and it doesn't need the Core plan. Choose a custom Docker image when you need something they don't offer, such as a different language or version, system packages, or a start process defined by your own Dockerfile. In exchange, you maintain the base image, and custom images need the Core plan or higher.

Custom Docker images need the Core plan or higher. Core includes 2 images, Pro includes 6 and Enterprise includes 20. Basic doesn't include them. The limit counts every image you have, whatever its build status.

Start with a ZIP or RAR archive (up to 100 MB), or import a repository through your GitHub integration; the creation flow lets you choose the source before building. The image is always built from your Dockerfile: there is no option to import a prebuilt image from another registry.

The archive must be a ZIP or RAR file of up to 100 MB with a file named Dockerfile at its root. The dashboard checks this before uploading and shows the Dockerfile for review. If it uses /app as its WORKDIR you get a warning, because application data lives in /app and any mounts there are erased.

Yes. Your source (ZIP, RAR, or GitHub repo) needs to already include a Dockerfile — the dashboard shows it to you in a preview step before you create or rebuild the image, it doesn't generate one for you.

The image defines how the application starts: whatever its ENTRYPOINT and CMD run is what runs. Language, version, entrypoint and custom command settings don't apply. When you create the application you choose its RAM, environment variables and, optionally, a web subdomain. Files under /app persist; the rest of the image's filesystem is read-only.

Once the image shows Ready, open Docker images in the dashboard and choose Create app on the image. You can create several applications from the same image. Afterwards, the application's Runtime settings show the image it uses, with its logs, update and GitHub rebuild options.

Yes. Choose Update image on the card and upload a new build context; the image keeps the same ID. Or link a GitHub repository and pick a branch so every push starts a rebuild. A rebuild is rejected while the image is already building.

No. A rebuild only updates the image. Applications running from it keep the version they last deployed until you restart or redeploy them.

Deleting an image also deletes every application created from it, so the dashboard asks you to type the image name to confirm. An image cannot be deleted while it is building.

Read the Custom Docker Images guide for the build flow, the limits and GitHub auto-rebuild.

Ready to move forward

Ship containers without assembling another pipeline.

Bring your image and use one flow to build, review, and operate.

From ZIP to running image
Upload your source and get a hosted image without a separate registry.

Reviewed before building
Preview your Dockerfile before it ever builds.

Build your first image
Upload a project or connect GitHub to start the pipeline.

A plan for every stage of your project

Rated 4.9/5 on TrustpilotTrusted by 50,000+ developers

Basic plan

Perfect for freelancers or individuals who need to host applications and bots.

From
$1.15/mo
1-2GB RAM
1-2 vCPU
4-8 projects
5-10GB CDN
Most popular

Core plan

For small teams and startups that need infrastructure for multiple projects.

From
$3.13/mo
4-8GB RAM
4-5 vCPU
16-32 projects
35-100GB CDN
Connect your own custom domain

Pro plan

Built for scaling companies with high project volume and advanced support.

From
$8.88/mo
12-24GB RAM
6-10 vCPU
48-96 projects
150-250GB CDN
Load balancers
Automatic backups

Pix or card · no lock-in · cancel anytime