Creating a New Application

Creating a new Quant Cloud application is a straightforward process that takes you through a guided setup form. This comprehensive guide walks you through each section of the creation process, providing insights and best practices to help you get the most out of your deployment.

Getting Started

To begin creating your application, navigate to the “Applications” section in your Quant Cloud dashboard’s left sidebar. Click the “Create New Application” button to open the guided creation form. This form is designed to collect all the necessary information to deploy your application efficiently while giving you the flexibility to configure advanced options as needed.

Step 1: Basic Information

The first section establishes the fundamental identity of your application within your organization.

Organization Context Your application will be created within your currently selected organization. If you’re a member of multiple organizations, it’s important to verify you’ve selected the correct one before proceeding, as this cannot be changed after creation without recreating the application.

Choosing an Application Name The application name serves as the primary identifier throughout the Quant Cloud platform. Choose a descriptive name that clearly indicates the application’s purpose, such as ecommerce-frontend, user-authentication-api, or data-processing-worker.

The name should use lowercase letters, numbers, and hyphens only. Avoid spaces or special characters, as this name will be used in various technical contexts including URLs, logs, and resource naming. A well-chosen name makes it easier to identify your application in dashboards, logs, and when working with multiple applications.

Step 2: Import Configuration (Optional)

One of Quant Cloud’s most powerful features is the ability to import existing Docker Compose configurations, dramatically reducing setup time and ensuring consistency with your development environment.

Docker Compose Import If you already have a docker-compose.yml file that defines your application stack, you can upload it directly into the creation form. Click “Choose file” to select your compose file from your local system. The platform will automatically parse the file and populate the appropriate form fields below.

This import process handles most standard Docker Compose directives including services, images, ports, environment variables, volumes, dependencies, and health checks. The system intelligently translates your compose configuration into Quant Cloud’s native format while preserving your application’s structure and relationships.

Tip

When importing a Docker Compose file, the platform will automatically create persistent storage volumes for any named volumes in your compose file. This ensures your data persistence requirements are maintained without additional configuration.

Benefits of Using Import Importing your existing configuration not only saves time but also reduces the risk of configuration errors. It ensures that your production deployment closely matches your development environment, maintaining consistency across your deployment pipeline. Additionally, any team members familiar with your Docker Compose setup can immediately understand the Quant Cloud configuration.

Step 3: Initial Task Configuration

This section defines the fundamental compute resources and architecture for your application. These settings affect both performance and cost, so it’s worth understanding the implications of each choice.

Selecting Your Architecture Quant Cloud supports both X86_64 (Intel/AMD) and ARM64 architectures. Your choice here must match the architecture your Docker images were built for. Most Docker images are available for both architectures, but always verify compatibility before proceeding.

Note

ARM64 instances typically provide better price-performance ratios compared to X86_64. If your Docker images support ARM64 (most modern images do), choosing ARM64 can reduce your compute costs by 10-20% while often providing better performance per dollar. Check your image documentation or try pulling with --platform linux/arm64 to verify compatibility.

CPU Allocation Strategy The CPU allocation represents the total compute units available to your entire application stack. This resource is shared among all containers within your application. For most web applications, start with a moderate allocation and monitor usage patterns. You can always scale up if needed, but over-provisioning initially increases costs unnecessarily.

Consider your application’s CPU profile: web servers typically need burst capacity for handling traffic spikes, while background processing applications might need sustained CPU availability. Database workloads often benefit from consistent CPU allocation to maintain query performance.

Memory Planning Memory allocation works similarly to CPU but requires more careful planning since running out of memory can cause container failures. The total memory is shared across all your containers, so consider each component’s requirements.

Factor in your application’s memory usage patterns: does it cache data in memory, process large datasets, or maintain persistent connections? Web applications typically need memory for connection pooling and session management, while data processing applications might require significant memory for buffering and computation.

Step 4: Optional Resources

Quant Cloud can provision managed resources that integrate seamlessly with your application, reducing operational overhead and improving reliability.

Storage & Database Services

Persistent Storage (PTS) Most applications need some form of persistent storage for user uploads, logs, configuration files, or cached data that should survive container restarts and deployments. Enabling Persistent Storage creates a high-performance, shared filesystem that can be mounted into your containers.

This storage is particularly valuable for applications that generate user content, maintain local caches, or need to persist data between deployments. The storage is automatically backed up and maintained by Quant Cloud, removing the operational burden from your team.

Dedicated Database (DDB) For applications requiring a database, Quant Cloud’s managed database service provides enterprise-grade database instances without the operational complexity. The service supports multiple database engines including MySQL and PostgreSQL, with automatic backups, monitoring, and maintenance.

The managed database integrates automatically with your application through environment variables, making connection configuration seamless. This eliminates the need to run database containers within your application stack, improving resource efficiency and reliability.

Note

Using a managed database instead of running your own database container provides several advantages: automatic backups, point-in-time recovery, automated security updates, and dedicated resources that don’t compete with your application containers. This is especially valuable for production workloads where data reliability is critical.

Production Environment Setup The checkbox to “Configure Initial Production Environment Details” determines whether the system will immediately set up a production-ready environment for your application. For most use cases, enabling this option is recommended as it provides a complete, deployable environment from the start.

Step 5: Initial Production Environment Configuration

This section configures how your application will run in the production environment, including scaling behavior and container specifications.

Instance Scaling Configuration The minimum and maximum instance settings control your application’s scaling behavior. The minimum instances represent the number of application copies that will always be running, ensuring availability and providing a baseline capacity for handling traffic.

Setting the minimum to 1 is appropriate for development or low-traffic applications. For production applications that require high availability, consider setting the minimum to 2 or higher to ensure redundancy. The maximum instances setting controls how far your application can scale out during traffic spikes.

Tip

For applications with predictable traffic patterns, setting minimum and maximum instances to the same value provides consistent performance and predictable costs. For applications with variable traffic, allowing auto-scaling (higher maximum than minimum) can optimize costs during low-traffic periods while ensuring performance during peaks.

Container Configuration Deep Dive

The container configuration section is where you define the actual services that comprise your application. Each container represents a distinct service or component of your overall application architecture.

Container Naming and Organization Choose descriptive names for your containers that reflect their role in your application architecture. Names like web-frontend, api-backend, worker-queue, or cache-redis immediately communicate the container’s purpose to your team. These names appear throughout the Quant Cloud interface and in logs, making clear naming essential for operational efficiency.

Image Selection and Management Specify the Docker image for each container using the standard registry format: registry/image:tag. Always use specific version tags rather than latest for production deployments to ensure consistency and predictable behavior. For example, use nginx:1.21.6 instead of nginx:latest.

Ensure your images are accessible from Quant Cloud’s infrastructure. Public images from Docker Hub work immediately, while private registry images may require additional authentication configuration.

Port Configuration and Exposure Configure the ports your containers expose to handle incoming traffic. Specify both the container port (where your application listens inside the container) and the protocol. Most web applications expose port 80 or 8080 for HTTP traffic, while APIs might use custom ports like 3000 or 8000.

The platform automatically handles load balancing and routing to your exposed ports, so you only need to specify which ports should receive traffic.

Storage Mount Points If you enabled Persistent Storage, configure mount points to specify where the shared filesystem should be accessible within each container. Common mount points include /app/uploads for user-generated content, /app/logs for application logs, or /app/cache for temporary files that should persist between container restarts.

Resource Limits and Optimization

Container-Level Resource Controls While the task-level CPU and memory settings provide the total resources available to your application, container-level limits allow you to control how those resources are distributed among your services. This is particularly useful in multi-container applications where different services have different resource requirements.

For example, a web frontend might need moderate CPU but significant memory for caching, while a background worker might need substantial CPU for processing but minimal memory. Setting appropriate limits prevents any single container from consuming all available resources and affecting other containers.

Memory Limit Strategy Quant Cloud provides both soft and hard memory limits. Soft limits allow containers to use additional memory when available but prioritize other containers when resources become constrained. Hard limits strictly enforce memory usage and will terminate containers that exceed the limit.

Use hard limits judiciously, as they can cause application failures if set too low. Monitor your application’s memory usage patterns before setting strict limits, and always leave some headroom for traffic spikes or unexpected usage patterns.

Advanced Configuration Options

Environment Variables and Secrets Environment variables provide a secure and flexible way to configure your application without hardcoding values into your container images. Use environment variables for configuration that might change between environments, such as API endpoints, feature flags, or non-sensitive configuration options.

For sensitive information like database passwords, API keys, or encryption keys, use the Secrets management system instead of plain environment variables. Secrets are encrypted at rest and in transit, providing better security for sensitive configuration data.

Tip

Follow the twelve-factor app methodology for configuration: store configuration in environment variables rather than config files. This makes your applications more portable and easier to manage across different environments.

Health Checks and Monitoring Configure health check endpoints to help Quant Cloud monitor your application’s health and automatically restart containers that become unresponsive. A good health check endpoint should verify that your application can perform its core functions, such as connecting to databases or external services.

Implement health checks that respond quickly (under 1 second) and don’t consume significant resources. Simple endpoints that return HTTP 200 with basic status information are usually sufficient.

Container Dependencies and Startup Order For multi-container applications, use dependency configuration to ensure containers start in the correct order. For example, ensure your database container is ready before starting your application container, or start your cache service before your web application.

Proper dependency management prevents startup failures and reduces the need for complex retry logic in your application code.

Step 6: Create Application

After configuring all sections, take a moment to review your settings. Pay particular attention to resource allocations, as these affect both performance and costs. Verify that your container images are correct and accessible, and ensure any required environment variables or secrets are properly configured.

Click “Create Application” to begin the provisioning process. Quant Cloud will validate your configuration, provision any requested managed services (databases, storage), and deploy your containers. This process typically takes a few minutes, depending on the complexity of your application and the size of your container images.

You’ll be redirected to the application overview page where you can monitor the deployment progress in real-time. The interface provides detailed status information for each component, helping you identify and resolve any issues that might arise during deployment.

After Creation

Once your application is successfully created and deployed, Quant Cloud provides comprehensive monitoring and management tools. The application dashboard shows real-time metrics including CPU usage, memory consumption, request rates, and error rates.

Take time to verify that all components are functioning correctly by checking the application logs and testing your application’s functionality. Monitor resource usage patterns over the first few days to ensure your initial resource allocations are appropriate.

Optimization and Best Practices

Start Simple, Scale Smart Begin with basic configurations and add complexity as needed. It’s easier to scale up resources or add features than to troubleshoot an over-complicated initial deployment. Monitor your application’s behavior and adjust configurations based on real usage patterns rather than theoretical requirements.

Resource Monitoring Keep a close eye on CPU and memory usage after deployment. Quant Cloud provides detailed metrics that help you understand your application’s resource consumption patterns. Use this data to optimize resource allocations and identify potential performance bottlenecks.

Testing and Validation Thoroughly test your application after deployment to ensure all components work together correctly. Pay particular attention to database connectivity, file storage access, and inter-service communication if you’re running a multi-container application.

Next Steps

With your application successfully deployed, you can enhance its capabilities and operational efficiency:

• Configure custom domains to provide branded access to your application
• Set up environment variables and secrets for secure configuration management
• Configure scaling policies to handle traffic variations efficiently
• Monitor application health to ensure optimal performance and reliability

Each of these next steps builds upon your initial deployment, helping you create a robust, scalable, and maintainable application infrastructure.