The building blocks of LinqProtocol
Understanding these core concepts will help you get the most out of the platform.
Templates
A template is a pre-configured definition of an application or service, packaged for one-click deployment.
Includes:
- Container image - The Docker image to run
- Default environment variables - Sensible defaults for configuration
- Required secrets - Which credentials you need to provide
- Metadata - Name, description, category, version
You don't need to write Kubernetes YAML or understand container orchestration. Choose a template, provide your secrets, and deploy.
Examples:
Deployments
A deployment is a running instance of a template on a provider's infrastructure.
Includes:
- Container(s) - Your running application
- Configuration - Environment variables and secrets
- Resources - Allocated CPU, memory, storage
- Escrow - The on-chain funding for this deployment
- Endpoint - The URL where your app is accessible
Deployment states:
- • Pending - Being created
- • Running - Active and serving requests
- • Stopped - Manually stopped
- • Errored - Something went wrong
What you can do:
- View logs and metrics
- Restart the deployment
- Stop the deployment
- Redeploy from scratch
Escrows
An escrow is a smart contract that holds LNQ funds for a deployment, ensuring fair payment between developer and provider.
When you fund a deployment:
- 1LNQ tokens are transferred to the escrow contract
- 2Escrow balance is tracked on-chain
- 3The provider is assigned
- 4As work is performed, the provider can withdraw earnings
- 5When the escrow expires, unused funds return to you
Key properties:
- On-chain - Verifiable by anyone
- Non-custodial - We don't hold your funds; the contract does
- Automatic - Settlement happens without manual intervention
- Duration-locked - You fund for a specific period
Providers
A provider is an entity that supplies compute resources (CPU, memory, storage, GPU) to the LinqProtocol network.
Includes:
- Run Kubernetes clusters with the LPStack runtime
- Register on-chain with their capacity and pricing
- Receive deployments matched by the orchestrator
- Earn LNQ for resources they provide
Provider types:
- • Data centers with spare capacity
- • GPU clusters for AI workloads
- • Edge operators for low-latency deployments
- • Individual operators with personal hardware
Plans
A plan defines the amount of CPU, memory, and storage allocated to your deployment.
Includes:
- Resources - How much compute power your deployment gets
- Cost - How much LNQ you'll spend per hour/day
Typical tiers:
- • Starter - Light workloads, testing, small apps
- • Standard - Production web apps, APIs, databases
- • Pro - High-performance workloads, heavy traffic
Secrets & Environment Variables
Secrets are sensitive values (API keys, passwords) stored encrypted and injected at runtime. Environment variables are non-sensitive configuration values.
Secrets:
- Stored encrypted in the control plane
- Never written to disk in plaintext
- Injected only when your container starts
- Never appear in logs or YAML exports
Environment variables:
- • Configuration values for your app
- • Port numbers, feature flags, external URLs
- • Can override template defaults
Best practices:
- • Use secrets for anything sensitive
- • Don't hardcode credentials in code
- • Rotate secrets periodically
LNQ Token
LNQ is the native utility token of LinqProtocol, used for payments, provider earnings, and protocol fees.
LNQ is:
- Payment method - Fund deployments with LNQ
- Provider earnings - Providers are paid in LNQ
- Fee mechanism - Protocol fees are collected in LNQ
Why LNQ (not just ETH)?
- • Dedicated utility token for the compute marketplace
- • Protocol can set its own fee structure
- • Aligns incentives across the ecosystem
Provider Registry
An on-chain smart contract that maintains a list of all registered providers with their capacity and pricing.
The registry stores:
- Provider wallet addresses
- Capacity (CPU, memory, storage, GPU)
- Pricing (per-unit rates)
- Metadata (location, description)
- Usage (currently allocated resources)
Why on-chain:
- • Verifiable by anyone
- • No central database to trust
- • Immutable record of provider history
- • Enables trustless provider matching
LPStack (DefaultStack)
The default runtime bundle that providers use to run LinqProtocol workloads.
Industry-standard tools that are battle-tested at scale. The same stack Fortune 500 companies use.
LPStack includes:
- Kubernetes - Container orchestration
- FluxCD - GitOps delivery, Helm charts
- Istio - Ingress controller, load balancing, service mesh
- Cert-Manager - Automatic TLS certificates
- Argo Tunnels - Secure ingress without port forwarding
- Prometheus - Metrics collection
- Loki - Log aggregation
Putting it together
- 1You browse templates in the marketplace
- 2You create a deployment with your configuration
- 3You fund an escrow with LNQ
- 4The orchestrator finds a provider from the registry
- 5The provider runs your workload on LPStack
- 6You monitor via the dashboard
- 7Provider earns from the escrow
- 8Unused funds return when the escrow expires