Deploy CarphaCom on Vultr Marketplace in Minutes – Quick Guide

Developers often need a ready‑made e‑commerce stack that can be up and running in minutes, without wrestling with manual server setup.

The fastest way is to use the CarphaCom image on the Vultr Marketplace; a single click creates a fully configured instance ready for customization.

Why choose CarphaCom on Vultr Marketplace

Ready‑to‑run e‑commerce stack

CarphaCom’s Developer Edition arrives as a fully configured virtual appliance on the Vultr Marketplace. The image installs Medusa v2, a headless commerce engine, together with PostgreSQL and a Next.js front‑end in a single step. This eliminates the manual compilation of Node.js modules, the creation of database schemas, and the wiring of environment variables. As soon as the instance boots, the API endpoint at https://your‑instance.vultrusercontent.com/admin is reachable, and the storefront renders at the root URL.

Local payment and courier support out of the box

The pre‑built image includes the Romanian payment gateway integrations that CarphaCom ships with, namely PayU Romania and Netopia, plus the native courier adapters for Fan Courier and Sameday. These connectors are pre‑registered in the Medusa configuration file (medusa-config.js) and already contain the required webhook URLs for order status updates. Deployers therefore avoid the typical back‑and‑forth with payment providers to obtain sandbox credentials and test callbacks.

Zero‑maintenance infrastructure

Vultr supplies automatic OS updates, snapshot scheduling, and a built‑in firewall that can be toggled from the control panel. Because the CarphaCom image is built on Ubuntu 22.04 LTS, security patches are applied without interrupting the Medusa service. The bundled PostgreSQL instance runs with default secure settings (password authentication, SSL disabled only for local traffic) and is backed by Vultr’s block storage, which can be expanded on demand.

Scalable performance for growth

Each CarphaCom deployment starts on a 2 vCPU, 4 GB RAM plan, but the marketplace listing provides a one‑click “Resize” button that re‑allocates resources while preserving the running containers. Because the application is containerised with Docker, scaling the Next.js front‑end or adding additional Medusa workers is a matter of adjusting the docker‑compose.yml file and restarting the stack. This flexibility lets small retailers launch quickly and later upgrade to the larger plans required for high‑traffic campaigns.

Proven track record in robotics and AI

The same CarphaCom platform powers the award‑winning CarphaCom Robotised solution that combined NVIDIA Isaac Sim with Google Gemini for warehouse automation. Its success at lablab.ai “AI Meets Robotics 2026” demonstrates that the underlying stack can handle intensive data flows and real‑time inventory updates, which translates into reliable performance for pure e‑commerce use cases.

For a deeper look at the platform, visit the CarphaCom product page. To start the deployment, open the CarphaCom listing on the Vultr Marketplace and select the desired plan. The combination of a pre‑installed commerce engine, local payment adapters, and Vultr’s managed infrastructure makes CarphaCom the fastest path from idea to live store.

Prerequisites before you start

Required accounts

To launch CarphaCom from the Vultr Marketplace you must have an active Vultr account. The Marketplace image is available in the Developer Edition, which is free to provision but still requires a valid payment method on file for any additional resources such as bandwidth or storage.

If you plan to enable optional paid licences—for example, premium AI‑agent modules or extended support—you will also need a PayPal account. The licensing step is optional because the base CarphaCom image includes the core e‑commerce engine (Medusa v2) and the robotics simulation stack (NVIDIA Isaac Sim + Google Gemini) without any additional keys.

Technical knowledge

Deploying CarphaCom is a server‑side operation, so familiarity with a Linux terminal is essential. You should be comfortable navigating the file system, editing configuration files with nano or vim, and running basic commands such as apt update and systemctl restart. SSH access is the primary method for post‑deployment administration; make sure you have an SSH client installed (OpenSSH on Linux/macOS, PuTTY on Windows) and that your local public key is added to the Vultr instance during creation.

Understanding of Docker is helpful but not mandatory. The Marketplace image runs CarphaCom inside pre‑configured containers, so you will not need to build images from scratch. However, knowing how to inspect container logs with docker logs will speed up troubleshooting.

Environment preparation

Before you click “Deploy” on the Marketplace, verify that you have at least 2 vCPU, 4 GB RAM, and 80 GB SSD allocated for the instance. These specifications match the recommended baseline for the combined Medusa backend and Isaac Sim simulation workloads. If you intend to run heavy AI inference with Google Gemini, consider scaling to 4 vCPU and 8 GB RAM.

Prepare a static IP address or enable Vultr’s floating IP feature if you need a stable endpoint for webhooks from Romanian couriers and payment gateways. The CarphaCom image expects PostgreSQL to listen on the default port 5432; ensure that no local firewall rules block inbound traffic on that port.

Documentation and support resources

The official CarphaCom documentation is bundled with the Marketplace image under /opt/carphacom/docs. For remote management scripts, see the Remote Operations guide. If you encounter integration issues with third‑party logistics providers, the QuBIOS repository contains sample API adapters.

Tip: Create a separate SSH key pair for the CarphaCom instance and store the private key in a password‑protected password manager. This isolates the deployment from your personal keys and simplifies key rotation later.

Step‑by‑step deployment on Vultr

Deploying CarphaCom from the Vultr Marketplace takes only a few minutes once you have a Vultr account. Follow the numbered procedure below to launch the self‑hosted Developer Edition with all required integrations.

1. Create a Vultr account. Visit vultr.com, click Sign Up, and verify your email. After logging in, add a payment method; the Marketplace image is free to launch, but you will be billed for the chosen compute resources.
2. Navigate to the Marketplace. In the Vultr dashboard select Marketplace from the left‑hand menu, then search for “CarphaCom”. The entry appears as “CarphaCom – Developer Edition (Medusa v2)”. Click the tile to open the detail page.
3. Choose a region and instance size. Pick a data centre close to your target users to minimise latency (e.g., Frankfurt or New York). For a test deployment start with a vc2-2c/4gb instance; production workloads typically require vc2-4c/8gb or higher depending on traffic.
4. Configure storage and networking. Allocate at least 40 GB SSD to accommodate the PostgreSQL database and media assets. Enable a public IPv4 address and, if needed, a private network for internal services. You can also attach a static IPv6 address for future expansion.
5. Set environment variables. In the Advanced Settings panel, add the following variables: DB_HOST=localhost, DB_USER=carpha, DB_PASSWORD=your_secure_password, and NEXT_PUBLIC_API_URL=https://your‑instance‑ip/api. These values are read by the Next.js front‑end at startup.
6. Review and launch. The summary screen shows the total monthly cost based on your selections. Click Deploy Now. Vultr provisions the VM, pulls the Docker‑based CarphaCom image, and starts the Medusa, PostgreSQL, and Next.js containers automatically.
7. Access the web console. Once the instance status changes to Running, click View Console to verify that the Docker services are healthy. You should see log lines indicating “Medusa server started on port 80” and “Next.js ready”.
8. Open the application. Open a browser and navigate to http://your‑instance‑ip. The CarphaCom storefront loads, and the admin panel is reachable at /admin. Use the default credentials (admin / admin) and change the password immediately via the UI or via the remote management tool.

After the instance is up, you can proceed to the initial configuration section to connect Romanian courier APIs, set up payment gateways, and enable the optional robotics simulation module.

Initial configuration after launch

Connect to the instance

After the CarphaCom Developer Edition finishes provisioning, locate the public IP address in the Vultr dashboard. Open a terminal and run:

If you used a custom SSH key during deployment, the command will authenticate automatically. Otherwise, you will be prompted for the root password that Vultr emailed to you.

Run the built‑in setup wizard

The CarphaCom image ships with a guided wizard that creates the database, installs dependencies, and generates initial configuration files. Start it with:

The wizard asks for the PostgreSQL superuser password, the desired admin email, and the base URL for the storefront. Accept the defaults for the Medusa v2 version unless you have a specific domain to bind.

Configure Romanian courier integrations

CarphaCom supports the major Romanian couriers through environment variables. Edit .env.production located in the project root:

Add or modify the following lines with the credentials you received from the courier partners:

• COURIER_FANCO=api_key_fanco
• COURIER_SF=api_key_sf
• COURIER_TNT=api_key_tnt

Save the file and reload the services:

This restarts Medusa, the Next.js front‑end, and the PostgreSQL container with the new variables applied.

Verify the web front‑end

Open a browser and navigate to http://<YOUR_IP> or the domain you configured. You should see the CarphaCom landing page with the default product catalog. Log in using the admin email you set in the wizard, then go to Settings → Shipping → Couriers to confirm that FanCo, SF, and TNT appear as active options.

To test the checkout flow, add a sample product to the cart and proceed to the payment page. The integration page will display a mock payment gateway; you can complete the transaction to ensure the order is recorded in the PostgreSQL database.

Tip: Keep a copy of the original .env.production file in a secure location. If you need to roll back courier credentials, you can restore the backup and restart the containers without re‑running the entire setup wizard.

Next steps

With the core services running, you may want to explore additional modules such as the AI‑driven recommendation engine (Products) or connect the warehouse simulation (Robotics) for automated fulfillment. For remote management, the Carpathron Remote tool provides a web‑based SSH console and log viewer.

Feature checklist for a production‑ready CarphaCom

Before you expose CarphaCom to customers, verify that the core infrastructure components are hardened and scalable. The table below lists the most common production settings and the exact actions required on a Vultr instance running the Developer Edition.

Once the checklist is complete, you can lock down the instance further by disabling password authentication for SSH and switching to key‑based login only. This step reduces the attack surface without affecting the automated deployment pipeline.

For remote management of CarphaCom, see our remote control module, which provides a web‑based console for firmware updates and robot‑task scheduling. Integrating the module with the production checklist ensures that any future firmware roll‑out respects the same security and scaling policies.

Finally, document the verified configuration in a version‑controlled README.md inside your GitHub repository (github.com/qubitpage). Keeping the checklist in source control makes it easy to replicate the exact setup across new regions or when performing disaster recovery drills.

Common pitfalls and how to avoid them

Port conflicts on the host server

CarphaCom’s default web interface listens on port 3000 while the Medusa API uses 8080. On a fresh Vultr instance these ports are usually free, but if you have previously deployed other services they may already be bound. Verify the current bindings with sudo lsof -i -P -n | grep LISTEN. If a conflict appears, stop the offending service or reassign CarphaCom’s ports by editing .env (set NEXT_PUBLIC_APP_PORT=3001 and MEDUSA_SERVER_PORT=8081) and restart the containers with docker compose up -d. The change propagates automatically to the NGINX reverse‑proxy configuration generated by the deployment script.

Missing or malformed environment variables

CarphaCom relies on a set of environment variables for courier APIs, payment gateways, and the PostgreSQL connection string. The deployment script creates a sample file named .env.example. Copy it to .env and fill every placeholder; leaving a variable empty causes the application to abort during startup, which appears as “Error: Cannot read property ‘…’ of undefined” in the logs. After editing, run docker compose down && docker compose up -d to reload the configuration. For sensitive values such as JWT_SECRET or GOOGLE_GEMINI_KEY, use Vultr’s secret manager and reference them with ${VULTR_SECRET_NAME} inside the .env file.

Database connection errors

The PostgreSQL instance bundled with the Marketplace image runs on the same VM but on the internal network address 127.0.0.1. A common mistake is to point the DATABASE_URL to the public IP, which triggers “connection refused” because the firewall blocks external PostgreSQL traffic. Ensure the URL follows the pattern postgresql://carphacom:StrongPass@127.0.0.1:5432/carphacom. If you have migrated the database to a separate managed instance, add the remote host to the VM’s security group and update DATABASE_URL accordingly. Test the connection with psql $DATABASE_URL -c "\dt" before restarting the services.

Incorrect file permissions for uploads

CarphaCom stores product images and robot logs in the /var/www/carphacom/storage directory. When the Docker containers start as a non‑root user, the directory may be owned by root, leading to “Permission denied” errors during upload. Fix the ownership with sudo chown -R 1000:1000 /var/www/carphacom/storage (assuming UID 1000 is the app user) and set permissions to 755. After adjusting, clear the cache (docker exec carphacom_app npm run cache:clear) to ensure the changes take effect.

SSL termination mismatches

If you enable a custom domain and terminate TLS at the Vultr load balancer, the internal NGINX proxy still expects HTTP traffic. Forgetting to set NEXT_PUBLIC_APP_URL=https://yourdomain.com and MEDUSA_SERVER_URL=https://yourdomain.com/api causes mixed‑content warnings and API failures. Update the variables, reload the containers, and verify the response headers with curl -I https://yourdomain.com to confirm a 200 status and a valid certificate chain.

Addressing these issues early saves hours of troubleshooting. For a deeper dive into remote management tools, see our remote operations guide. If problems persist, the Qubitpage support team is reachable at contact@qubitpage.com.

Frequently asked questions

How long does it take to launch CarphaCom from the Vultr Marketplace?

From selecting the CarphaCom Developer Edition to having a reachable instance typically requires 5–7 minutes. The process includes provisioning a virtual machine, attaching the pre‑configured PostgreSQL database, and initializing the Medusa v2 e‑commerce core. After the initial boot, the Next.js front‑end becomes available on the assigned public IP.

Do I need a CarphaCom licence to run the Marketplace image?

No separate licence is required for the Marketplace image; the Developer Edition is provided as a self‑hosted package. The image includes all necessary binaries and default configuration files, allowing you to start testing or running a production store immediately. If you later upgrade to the Enterprise tier, a licence key can be applied through the admin dashboard.

Can I customize the payment gateways after deployment?

Yes. CarphaCom exposes the Medusa payment service API, and the Next.js admin panel includes a “Payment Settings” section where you can add, remove, or re‑configure providers. The platform ships with Romanian courier and payment integrations out of the box, but you can also register Stripe, PayPal, or local banks by editing the medusa-config.js file and restarting the service.

What is the recommended server size for a small online store?

For a store handling up to 500 daily visitors and a catalog of 1 000 products, a Vultr instance with 2 vCPU, 4 GB RAM, and a 80 GB SSD provides sufficient headroom. This configuration matches the “High‑Frequency” plan in the Marketplace and includes a dedicated PostgreSQL node for reliable transaction handling. Scaling to larger traffic can be achieved by adding a load balancer and a read‑replica database.

How do I enable automatic backups on Vultr for CarphaCom?

Navigate to the instance dashboard, select “Backups” and toggle the “Automatic backups” switch. Choose a daily backup frequency and a retention period of at least 7 days to protect both the application files and the PostgreSQL data volume. After enabling, Vultr will snapshot the entire VM each night and store the images in a separate region for disaster recovery.

Wrap‑up and next steps

After following the steps above you should have a fully functional CarphaCom instance running on a Vultr virtual machine. Verify the Medusa admin panel, confirm the PostgreSQL connection, and test the Next.js storefront to ensure all Romanian courier and payment modules respond correctly. If you plan to extend the platform with AI agents or robotics simulations, allocate additional CPU/GPU resources in the Vultr dashboard before installing NVIDIA Isaac Sim or Google Gemini.

Next, secure the deployment by enabling firewall rules for ports 80, 443, and 5432, and generate TLS certificates via Let’s Encrypt. Schedule regular backups of the PostgreSQL database using Vultr snapshots to protect order data. Finally, monitor performance metrics in the Vultr control panel and adjust the instance size as traffic grows.

Ready to accelerate your e‑commerce operations or explore advanced robotics integration? Explore Qubitpage’s full suite of solutions and let our team help you tailor the next phase of your deployment.