deployra

Documentation

Supported Languages

Deploy applications built with your favorite programming languages on Deployra's modern cloud platform.

Deployra provides comprehensive support for modern programming languages including Node.js, Bun, Python, Ruby, Go, Rust, and Elixir. Our platform automatically detects your application type and configures the optimal build environment. For maximum flexibility, you can deploy applications written in virtually any programming language using custom Docker containers.

Why Choose Deployra for Multi-Language Development?

  • • Zero-configuration deployment for popular frameworks
  • • Automatic dependency management and build optimization
  • • Built-in support for modern package managers (npm, yarn, pnpm, pip, poetry, bundler, cargo, mix)
  • • Scalable cloud infrastructure with global CDN
  • • Integrated CI/CD pipeline with GitHub integration

Automatic Detection

While creating a service, just link your GitHub repo and specify a branch to deploy. If a Dockerfile is found, Deployra will build your image using it. Otherwise, it will use Paketo Buildpacks to automatically detect and build your application.

LANGUAGES

Natively Supported Programming Languages

Deploy these languages with zero configuration using Paketo Buildpacks. Deployra automatically detects your application type, installs dependencies, and optimizes your build for production deployment.

Node.js / Bun

JavaScript & TypeScript

Deploy Node.js and Bun applications with automatic dependency installation, build step execution, and production optimization. Supports all major package managers and modern JavaScript frameworks.

Express.jsNext.jsNestJSKoa.jsReactVue.jsNuxt.jsSvelte

Python

Web apps & APIs

Deploy Python web applications and APIs with automatic virtual environment setup, dependency management using pip or Poetry, and production-ready WSGI/ASGI server configuration.

DjangoFlaskFastAPIPyramidStreamlitTornado

Ruby

Web frameworks

Deploy Ruby applications with bundler for dependency management and environment configuration.

RailsSinatraHanami

Go

Fast & efficient

Deploy Go applications with automatic dependency resolution, building, and optimization for production.

GinEchoFiberChi

Rust

Performance & safety

Deploy Rust applications with cargo for dependency management, building, and optimization.

Actix WebRocketWarpAxum

Elixir

Scalable & fault-tolerant

Deploy Elixir applications with mix for dependency management, compilation, and release building.

PhoenixCowboyPlug

DOCKER

Custom Docker Deployments

You can deploy any application using a custom Docker image. Include a Dockerfile in your repository, and Deployra will build and deploy it automatically.

Benefits of Docker Deployments

Support for any language

Use any programming language or framework that can run in a container.

Custom dependencies

Install specific system libraries and tools needed by your application.

Optimized builds

Create multi-stage builds to keep your production images small and efficient.

Dockerfile portability

Use the same Dockerfile for local development and production deployment.

Example Dockerfile

A basic multi-stage Dockerfile for a Node.js application:

# Build stage
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/package*.json ./
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]

BUILDPACKS

Automatic Buildpack Detection

If your repository doesn't include a Dockerfile, Deployra uses Paketo Buildpacks to automatically detect your application type and build it with optimized settings.

Node.js detection

Detected by the presence of a package.json file. Supports npm, yarn, and pnpm.

Python detection

Detected by requirements.txt, pyproject.toml, or Pipfile.

Go detection

Detected by go.mod files or .go source files in the repository.

Ruby detection

Detected by a Gemfile in the repository root.

Rust detection

Detected by Cargo.toml in the repository root.

Elixir detection

Detected by mix.exs in the repository root.

Custom Build Commands

You can always specify custom build commands and environment variables in your service configuration, regardless of the detected language or framework.

FAQ

Frequently Asked Questions

What programming languages does Deployra support?

Deployra natively supports Node.js, Bun, Python, Ruby, Go, Rust, and Elixir through automatic buildpack detection. Additionally, you can deploy applications written in any programming language using custom Docker containers.

How does automatic language detection work?

Deployra uses Paketo Buildpacks to analyze your repository structure and automatically detect your application's language and framework. For example, a package.json file indicates Node.js, while requirements.txt indicates Python.

Can I use multiple programming languages in one project?

Yes! For monorepos or projects with multiple components, you can use Docker containers to deploy applications that use multiple languages. You can also deploy different services separately using Deployra's microservices architecture.

What if my language isn't natively supported?

You can deploy applications written in any programming language (PHP, Java, C#, Kotlin, Scala, etc.) by creating a Docker container. Simply include a Dockerfile in your repository, and Deployra will build and deploy it automatically.

Do you support database integrations?

Yes, Deployra applications can connect to various databases including PostgreSQL, MySQL, MongoDB, Redis, and more. You can use environment variables to configure database connections securely across all supported languages.