How We Built a Partner-Ready Crypto Node Provisioning and Management Platform

Industry: Crypto / blockchain infrastructure.

Workload: Managed blockchain nodes.

Services: Infrastructure selection, DevOps deployment, REST API development, node lifecycle management, monitoring, metrics collection.

About the project

Running a blockchain node looks simple from the outside: choose a project, rent a server, install the software, and keep it online. In practice, the infrastructure requirements vary significantly between protocols. Different projects require different CPU, RAM, storage, network, and operational configurations. Nodes also need to be installed, monitored, updated, restored, suspended, and maintained over time. For technically experienced users this is manageable, but for a broader crypto audience the infrastructure layer quickly becomes a barrier to participation.

Together with a crypto media and community partner Unihost worked on a service designed to make node deployment accessible to users who did not want to manage the underlying server infrastructure themselves.

Challenge

The project required more than simply offering a list of dedicated servers. The partner needed a system that could connect its customer-facing frontend with Unihost’s infrastructure and automate the operational lifecycle of blockchain nodes. The initial requirements were relatively high-level, and no detailed technical specification for the integration was provided. That meant the Unihost team had to define much of the backend architecture independently.

The system needed to support several core functions:

• receiving node orders from the partner’s frontend;
• processing and tracking those orders;
• maintaining records of deployed nodes;
• handling node renewals;
• collecting operational metrics;
• reporting node status;
• installing and removing nodes;
• suspending and unsuspending nodes;
• restoring nodes from backups;
• returning node information to the customer’s account interface.

At the same time, the infrastructure itself had to remain flexible because each blockchain project could have different hardware requirements.

What the Unihost Team Did

The project was split into two interconnected layers:

• the partner integration and management platform;
• the underlying node infrastructure and DevOps operations.

1. Designed the REST API Backend

Because the partner did not provide a complete technical specification for the integration, the Unihost development team took responsibility for designing the backend interaction model. A REST API backend was developed to act as the control layer between the partner’s frontend and the node infrastructure.

The backend handled:

• incoming node orders;
• order processing;
• node records;
• node lifecycle data;
• renewals;
• operational information received from infrastructure services.

This gave the partner a stable backend interface without requiring its frontend to communicate directly with individual servers or blockchain nodes.

2. Built a Dedicated Node Management Service

A separate service was developed in Python to interact with the deployed nodes and collect infrastructure data.

Its responsibilities included:

• collecting metrics from installed nodes;
• checking node status;
• installing nodes;
• removing nodes;
• suspending nodes;
• unsuspending nodes;
• restoring nodes from backup.

This service acted as the operational layer between the REST API backend and the actual infrastructure. Instead of implementing infrastructure-specific logic inside the partner-facing API, node operations were handled by a dedicated management component.

3. Connected Infrastructure Metrics to the Customer Interface

The Python service continuously collected information about deployed nodes and passed the relevant data to the REST API backend.

This allowed the partner’s customer interface to display operational information such as:

• node status;
• node-related metrics;
• project points where applicable;
• other project-specific node information.

The result was a separation between the infrastructure layer and the customer-facing application. The frontend only needed to communicate with the API, while infrastructure-specific operations remained behind the integration layer.

Architecture

Partner frontend – Node order / renewal / management request – Unihost REST API backend – Order and node lifecycle processing – Python node management service – Installation / removal / suspend / unsuspend / restore – Blockchain node infrastructure

And in the opposite direction: Blockchain nodes – Status and metrics collection – Python management service – REST API backend – Partner customer area

This architecture kept the customer-facing application separate from the underlying infrastructure logic.

4. Analyzed Infrastructure Requirements for Each Blockchain Project

The server configuration could not be standardized across every node. Different blockchain projects had different hardware requirements. The Unihost team analyzed the technical requirements of supported projects and selected appropriate infrastructure characteristics for each node deployment.

This included evaluating the required:

• CPU resources;
• memory;
• storage;
• network capacity;
• other project-specific infrastructure requirements.

The objective was to avoid both under-provisioning and unnecessarily expensive configurations.

5. Automated Node Deployment Through the DevOps Team

Once the appropriate infrastructure had been selected, Unihost handled the technical deployment of the nodes. The DevOps team was responsible for the server-side work required to bring the nodes into operation.

The customer therefore did not need to:

• select and configure the server manually;
• perform node installation;
• maintain deployment procedures;
• troubleshoot the underlying infrastructure independently.

The infrastructure layer became part of the service rather than a separate technical responsibility for the end user.

6. Added Custom Health Checks and Monitoring

Running a node is not a one-time deployment task. After installation, the infrastructure needs to remain operational and the node itself needs to remain healthy. Unihost configured monitoring and custom health checks for the deployed nodes. The monitoring layer allowed the team to track operational status and provide the management platform with the information required to display node state to users. Combined with the Python management service, this created a full operational loop: deploy – monitor – collect metrics – manage – restore when required.

Division of Responsibilities

A clear separation of responsibilities was established between the two partners.

Unihost handled the technical and infrastructure side:

• analysis of blockchain projects;
• assessment of node hardware requirements;
• server configuration selection;
• infrastructure provisioning;
• node deployment by the DevOps team;
• REST API backend development;
• Python node management service;
• metrics collection;
• node lifecycle operations;
• custom health checks;
• monitoring;
• ongoing infrastructure support.

The partner focused on:

• marketing;
• communication with the crypto audience;
• customer acquisition;
• the customer-facing experience.

This allowed each side to concentrate on its core expertise instead of attempting to build and operate the entire service independently.

Why the API Layer Mattered

Without the integration layer, every node order would have required significantly more manual coordination between the partner, customer, and infrastructure team. The API changed the operational model. Instead of treating every node as a standalone server deployment, the system treated nodes as managed service objects with their own lifecycle.

A node could be: ordered – provisioned – installed – monitored – suspended – resumed – renewed – restored – removed.

The partner’s frontend did not need to understand how each of those infrastructure operations was implemented. It only needed a consistent interface to the backend.

Why a Separate Python Service Was Used

The REST API and the node management service had different responsibilities. The API handled partner-facing business and lifecycle logic, while the Python service handled communication with the infrastructure and the deployed nodes. Keeping these responsibilities separate made it possible to centralize infrastructure operations such as installation, status collection, suspension, and backup restoration without exposing those mechanisms directly to the frontend. It also created a single source of operational data that could feed node status and metrics back into the customer’s account.

Results

The resulting service gave users a way to participate in blockchain projects without having to manage the underlying server and node infrastructure themselves. For the partner, the project provided a backend system capable of receiving and processing node orders while exposing the operational data needed by the customer-facing platform. For Unihost, the project went beyond conventional hosting.

The team combined:

• infrastructure sourcing;
• DevOps;
• monitoring;
• backend development;
• API integration;
• lifecycle automation.

This transformed individual server deployments into a managed node platform that could be integrated into a partner’s own product.

Engineering Takeaway

The difficult part of a managed blockchain node service is not simply installing node software on a server.

The real challenge is everything around the installation:

• How does a customer order the node?
• How is the correct server selected?
• How is the deployment triggered?
• How is the node state tracked?
• How are metrics returned to the customer?
• How is the node suspended, restored, renewed, or removed?

For the partner Unihost built the infrastructure and management layer that connected those processes into a single workflow. The project demonstrates a broader model for infrastructure partnerships: the partner owns the audience and customer experience, while Unihost provides the infrastructure, automation, API, and operational expertise behind the service.

Results at a glance: REST API backend developed for partner integration, custom Python service for node management, automated node lifecycle operations, node metrics and status available to the partner frontend, project-specific infrastructure selection, DevOps-managed node deployment, custom monitoring and health checks, backup restoration capability, end users did not need to manage the server layer themselves.