Spark Program | Corven – Cloud Development Infrastructure for CKB
Tag: Spark-Program
1. Project Overview
Project Name
Corven
One-Sentence Summary
Corven is a browser-based cloud development platform that enables developers to build, test, and debug CKB smart contracts without installing local development tools.
Project Type
Developer Tool
2. Team Profile
Core Member
Jimleston Osoi — Founder & Full-Stack Developer
Responsible for system architecture, backend services, cloud infrastructure, frontend development, and DevOps.
Background
- Full-stack software engineer
- CKBuilder Program participant
- Experience building NestJS microservices, cloud platforms, Docker-based systems, and React/Next.js applications
- Experience developing Rust smart contracts and experimenting with the CKB toolchain and Fiber Network
Links
GitHub: https://github.com/lestonEth/corven-platform
LinkedIn: https://linked/in/jimlestonosoi
Discord: leston2640
Email: [email protected]
Telegram: @lest_tonlest_ton
Site: https://corvan.vercel.app/
Demo: corvan v1.0 progress | Loom
3. Project Background
Developing on CKB requires developers to install and configure multiple tools before writing their first smart contract. A typical setup includes Rust, Cargo, Docker, the RISC-V target, CKB tooling, and other platform-specific dependencies. Installation issues and environment inconsistencies create a significant barrier for new developers.
During my participation in the CKBuilder Program, I experienced these challenges firsthand. Considerable time was spent configuring development environments instead of building applications.
While cloud IDEs such as GitHub Codespaces and Gitpod simplify general software development, they are not designed around CKB workflows. They lack built-in support for CKB project templates, Rust contract compilation, testing, and future Fiber development.
Corven addresses this problem by providing a cloud-native development environment specifically designed for the CKB ecosystem.
4. Solution
Corven provisions an isolated cloud workspace for every developer, preconfigured with the complete CKB development toolchain.
The initial MVP will focus on the core development workflow:
- Create a CKB project from a predefined template
- Open and edit project files in the browser
- Access an integrated terminal
- Compile Rust smart contracts using the CKB development environment
- Run project tests
- View build and test output
- Persist project files within the workspace
- Resume development from the browser
The initial Spark-funded scope intentionally focuses on the core developer workflow rather than attempting to deliver the full long-term Corven infrastructure platform.
Future development may introduce Fiber node provisioning, transaction simulation, advanced debugging, AI-assisted development, and larger-scale workspace orchestration.
5. Technical Approach
Technology Stack
Frontend - Next.js, TailwindCS, Monaco Editor
Backend - NestJS, PostgreSQL, Prisma, Redis
Infrastructure - Docker, MinIO, JWT Authentication, Redis Streams, Kubernetes (future)
Architecture
Corven is designed as a modular cloud development platform where the browser communicates with a backend API layer that manages authentication, workspace lifecycle, storage, and runtime execution.
The architecture is intentionally designed in two stages:
- MVP: lightweight Docker-based runtime suitable for validating the CKB development workflow.
- Future: scalable runtime orchestration capable of supporting larger numbers of concurrent workspaces.
This separation allows Corven to validate the developer experience without requiring Kubernetes or large-scale infrastructure during the Spark-funded phase.
5.1 High-Level Architecture
flowchart LR
id1[This is the text in the box]
The browser is the primary development interface. Developers do not directly communicate with the runtime container. All workspace operations are mediated through the backend services.
The API Gateway provides a single entry point for the frontend and handles authentication, routing, and request validation.
The Workspace Service manages workspace lifecycle operations such as creation, starting, stopping, and retrieving workspace metadata.
The Runtime Service is responsible for creating and controlling the isolated development environment.
The Storage Service manages persistent project files so that the developer’s work is not tied to the lifetime of a runtime container.
Technical Challenges
- Secure multi-tenant container isolation
- Fast workspace provisioning
- Persistent developer sessions
- Browser-based terminal streaming
- Integration of the CKB toolchain into cloud workspaces
The platform supports English as its primary language.
6. Development Plan
The Spark-funded scope has been reduced to focus on delivering a usable and verifiable MVP within a realistic timeline for a solo developer.
Week 1 – Backend Foundation & Authentication
Budget: USD200
The first week focuses on establishing the core backend infrastructure that all other platform components depend on. This includes finalizing the microservice architecture, implementing JWT-based authentication and user management, developing the Workspace Service responsible for workspace lifecycle management, and configuring PostgreSQL and Redis for persistent storage and caching. Communication between backend services will also be established to support future runtime orchestration.
Milestone: Developers can authenticate and create workspace records through a functional backend foundation.
Week 2 – Cloud Runtime & Workspace Provisioning
Budget: USD 200
The second week focuses on the cloud execution environment. The Runtime Service will be implemented to provision isolated Docker workspaces preconfigured with the CKB development toolchain. Persistent storage will be configured using Docker volumes, while WebSocket-based terminal support will provide real-time command execution. Workspace initialization from predefined project templates will also be completed.
Milestone: Developers can launch isolated cloud workspaces with persistent storage and an integrated terminal.
Week 3 – Browser IDE & CKB Development Workflow
Budget: USD 200
Development during the third week will focus on the browser-based development experience. Monaco Editor will be integrated alongside a file explorer, enabling developers to edit project files directly in the browser. The CKB toolchain will be integrated into workspace containers, allowing Rust smart contract compilation, test execution, and real-time build log streaming without requiring any local installation.
Milestone: Developers can create, edit, build, and test CKB smart contracts entirely from their browser.
Week 4 – CKB Workflow & Templates
Budget: USD 150
Integrate the CKB project workflow into the browser environment.
Activities:
- CKB project template
- Rust contract compilation
- Test execution
- Build output handling
- Basic error reporting
Milestone: A developer can create a CKB project, modify the contract, compile it, and run tests without local CKB tooling.
Week 5 – Testing & Stabilization
Budget: USD 150
Focus on reliability and end-to-end testing.
Activities:
- Authentication testing
- Workspace lifecycle testing
- Runtime testing
- Build/test workflow testing
- Persistence testing
- Browser compatibility testing
- Bug fixes and performance improvements
Milestone: The complete MVP workflow can be repeatedly executed without requiring local development dependencies.
Week 6 – Documentation & Public Release
Budget: USD 100
Prepare the project for public use and verification.
Activities:
- Developer documentation
- Installation/deployment documentation
- User onboarding guide
- Architecture documentation
- Public deployment
- Demonstration video
- Final verification
Milestone: A publicly accessible Corven MVP is available for CKB developers to test.
7. Required Funding
A. Required Funding
Total Requested: USD 1,000
The requested funding has been reduced from the original USD 2,000 proposal to align with the standard Spark Program funding limit for technical projects.
The revised scope deliberately focuses on the smallest useful version of Corven rather than attempting to fund the complete long-term cloud infrastructure platform.
The funding will be used primarily for development time and the infrastructure required to deliver and publicly demonstrate the MVP.
The reduced scope removes or postpones higher-cost features such as:
- Kubernetes-based orchestration
- Large-scale multi-user infrastructure
- Fiber node provisioning
- Transaction simulation
- Advanced debugging
- AI-assisted development
- Large-scale production infrastructure
These features remain part of the longer-term Corven roadmap and can be pursued through future funding opportunities such as the CKB Community Fund DAO.
B. Funding Breakdown
B. Funding Breakdown
| Category | Activities | Amount |
|---|---|---|
| Backend & Workspace | Authentication, workspace APIs, database, service integration | $200 |
| Runtime Infrastructure | Docker runtime, CKB environment, command execution, persistence | $200 |
| Browser IDE | Monaco Editor, file explorer, terminal, workspace UI | $200 |
| CKB Integration | Templates, contract compilation, tests and build output | $150 |
| Testing & Stabilization | End-to-end testing, debugging and performance improvements | $150 |
| Documentation & Release | Documentation, deployment and demonstration video | $100 |
| Total Requested | $1,000 |
The weekly development allocation and category breakdown are intentionally aligned so that the complete requested amount is accounted for across the six-week implementation period.
8. Deliverables & Acceptance Criteria
Deliverable 1 — Authentication & Workspace Management
Acceptance Criteria:
- User can register/login through the Corven interface.
- Authenticated user can create a workspace.
- User can view their workspace.
- User can start and stop the workspace.
Expected Result: A successfully authenticated user can create and manage a development workspace.
Deliverable 2 — CKB Development Runtime
Acceptance Criteria:
- Workspace contains the required CKB/Rust development environment.
- Developer can open the integrated terminal.
- Developer can execute CKB/Rust commands.
- Commands return their output to the browser.
Expected Result: CKB development commands execute inside the workspace without requiring the developer to install the toolchain locally.
Deliverable 3 — Browser IDE
Acceptance Criteria:
- Monaco Editor is accessible inside the workspace.
- Developer can open project files.
- Developer can modify and save files.
- Developer can access the integrated terminal.
Expected Result: A developer can edit a CKB smart contract entirely through the browser.
Deliverable 4 — CKB Project Template & Build Workflow
Acceptance Criteria:
- Developer can create a project from a CKB template.
- The template contains a valid Rust smart contract project.
- The project can be compiled successfully.
- Tests can be executed.
- Build/test output is visible in the browser.
Expected Result: A fresh CKB project can be created, modified, compiled, and tested without local CKB development dependencies.
Deliverable 5 — Persistent Workspace
Acceptance Criteria:
- Project files remain available after stopping the workspace.
- Developer can reopen the workspace.
- Previously saved project files are restored.
Expected Result: Developers can leave and return to their CKB project without losing their work.
Deliverable 6 — Public MVP & Documentation
Acceptance Criteria:
- Public demo is accessible through a modern web browser.
- User onboarding documentation is available.
- Project source code is publicly available under the MIT License.
- Demonstration video shows the complete workflow.
Expected Result: A CKB developer can access Corven, follow the documentation, create a project, and test the core development workflow.
9. How to Verify
The committee can verify the MVP entirely through the public demo.
Environment Requirements
The verifier requires:
- A modern web browser such as Chrome, Firefox, Safari, or Edge
- Internet connection
- No Rust, Cargo, Docker, CKB CLI, or other CKB development tools installed locally
Verification Workflow
Step 1 — Login
Create an account or use the provided test account.
Expected Output: The Corven workspace/dashboard is displayed.
Step 2 — Create Workspace
Create a new CKB workspace.
Expected Output: A workspace is successfully created and becomes available.
Step 3 — Create CKB Project
Select the provided CKB project template.
Expected Output: A valid CKB/Rust project appears in the file explorer.
Step 4 — Edit Contract
Open the contract source file and make a small modification.
Expected Output: The file can be edited and saved successfully.
Step 5 — Compile
Run the provided build/compile command through the integrated terminal.
Expected Output: The CKB/Rust contract compiles successfully and the build output is displayed.
Step 6 — Run Tests
Execute the project’s test command.
Expected Output: Tests execute and their results are displayed in the browser terminal.
Step 7 — Persistence
Stop or leave the workspace and reopen it.
Expected Output: Previously saved project files remain available.
Cost Control
The initial MVP is intentionally designed around a lightweight runtime model. The project does not require Kubernetes or large-scale infrastructure for the Spark-funded deliverable.
Workspace resources can be started only when required and stopped when inactive. This limits unnecessary compute usage during the MVP validation period.
The architecture also separates the runtime layer from the rest of the application so that future scaling can be introduced only when actual usage justifies i
0. Current State vs. Funded Work
Current State
Corven already has a working prototype containing the core backend architecture, including:
- API Gateway
- Authentication Service
- Workspace Service
- Runtime Service
- Docker integration
- Database connectivity
The project also has ongoing CKB toolchain integration and browser-based development work.
Funded Work
The Spark funding will focus on completing and publicly releasing the lightweight MVP by connecting the existing backend foundation with:
- Browser IDE
- CKB project templates
- Docker-based runtime
- Integrated terminal
- CKB compilation and testing
- Persistent workspace files
- Documentation
- Public demonstration
The goal is not to build the complete long-term Corven infrastructure platform within the Spark grant. The goal is to deliver a focused, functional MVP that validates the core developer experience.
11. CKB Alignment
Corven is built specifically to improve the developer experience within the CKB ecosystem by reducing the complexity of local development environment setup.
The initial MVP focuses on one clear problem:
How can a developer start building a CKB smart contract without spending significant time configuring the development environment?
Corven addresses this by providing a browser-based environment with the required development tooling already configured.
The initial release focuses on:
- CKB project templates
- Rust smart contract development
- Browser-based code editing
- Integrated terminal
- Contract compilation
- Test execution
- Persistent project workspaces
The longer-term roadmap includes Fiber development environments, one-click node provisioning, transaction simulation, debugging tools, and AI-assisted development.
These future capabilities are intentionally outside the Spark-funded MVP scope.
By starting with a focused and lightweight implementation, Corven can validate the developer experience with limited infrastructure requirements while establishing a foundation for a larger CKB developer infrastructure platform.
12. Long-Term Roadmap
Phase 1 — CKB Smart Contract MVP
Browser-based CKB development environment with templates, editing, compilation, testing, and persistence.
Phase 2 — CKB Developer Infrastructure
Improved runtime management, debugging, transaction simulation, and additional CKB tooling.
Phase 3 — Fiber Development
One-click Fiber node provisioning, development environments, testing, and debugging workflows.
Phase 4 — AI Developer Tooling
AI-assisted contract development, test generation, debugging, code explanations, and developer assistance.
The larger infrastructure phases can be pursued through future ecosystem funding, including the CKB Community Fund DAO, once the MVP has demonstrated demand and usage.
13. Summary
Corven’s revised Spark proposal focuses on delivering a small, functional, open-source CKB development MVP rather than attempting to build the complete long-term cloud infrastructure platform.
With USD 1,000 over six weeks, the project will deliver:
- Browser-based CKB development
- CKB project templates
- Monaco-based code editing
- Integrated terminal
- CKB/Rust compilation
- Test execution
- Persistent workspaces
- Public documentation
- Public demo
- MIT-licensed source code
The final MVP will allow a developer to go from:
No local CKB setup → Create project → Write contract → Compile → Test
entirely through a web browser.
This provides a focused and verifiable first step toward a larger developer infrastructure platform for the CKB ecosystem.