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
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
Three ways to run a workload on Shard Cloud, and what each one leaves to 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.
Move from uploaded source to a running custom image without managing a separate registry or build host.
Explore capabilitiesUpload a ZIP or RAR archive, or select a connected GitHub repository before the image build starts.
Inspect your Dockerfile before creating or rebuilding the image.
Open the image logs as it builds, then create an application from the finished image in the Docker images dashboard.
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.
Upload an archive of up to 100 MB with the Dockerfile at its root, or import a GitHub repository.
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.
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.
Follow the build output as it streams in. If a build fails, the error shows on the image card.
Review your Dockerfile before it's used to create or rebuild the image.
Upload your source, watch the image build in real time, then create an application from it the moment it's ready.
Get startedFrom connection to the first decision, in one flow.
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.
Bring your image and use one flow to build, review, and operate.
Guided setup with no commitment
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.
Perfect for freelancers or individuals who need to host applications and bots.
For small teams and startups that need infrastructure for multiple projects.
Built for scaling companies with high project volume and advanced support.
Pix or card · no lock-in · cancel anytime