Several months ago, I built Forever Notes, my first application on CKB.
At the time, it was simply a learning project that helped me connect concepts like wallet integration, transactions, and the Cell Model with a real application.
Since then, I’ve learned much more about the ecosystem through the CKBuilders program. Looking back now, it’s interesting to see how much my understanding has evolved and how differently I would approach the same project today.
I thought it would be a good time to revisit Forever Notes, share why I built it, walk through some of the technical decisions behind it, and reflect on what it taught me along the way.
Live Demo: forever-notes-ckb.netlify.app
GitHub Repository: github com/chidinmaik/forever-notes-ckb
Note: Forever Notes is open source and still evolving. If you have ideas, suggestions, or feedback, I’d love to hear them.
and for some reason im not allowed to make a post with links here.
What is Forever Notes?
Forever Notes is a simple note-taking application built on the CKB Testnet.
The goal was to explore how user-generated content could fit into CKB’s Cell Model through a familiar interface. Instead of trying to build a feature-rich note-taking application, I wanted to focus on understanding how a frontend could interact with CKB, from wallet connection to transaction creation.
Users can connect their wallet, create a note, and experience a simple workflow that introduces some of the core ideas behind building on CKB.
Although the project is small, it became an important part of my learning process because it gave me something practical to experiment with while working through the CKBuilders program.
Why I Built It
One of the best ways I learn new technologies is by building with them.
Once I understood the basics of CKB, I wanted a project that would help me apply those concepts in practice instead of only reading documentation or completing exercises.
A note-taking application felt like a good place to start. The idea was simple enough that I could focus on learning the platform while still dealing with real development challenges.
Building Forever Notes helped me think through questions like:
-
How should wallet connection fit into the user experience?
-
How should application data eventually become blockchain data?
-
How are transactions prepared before they’re submitted?
-
How does the Cell Model influence application design?
Having a real project made every new lesson easier to understand because I could immediately relate it back to something I had already built.
Tech Stack
Frontend
-
Next.js
-
React
-
TypeScript
-
Tailwind CSS
-
Yarn
Blockchain
-
CKB Testnet
-
CCC SDK
-
Wallet integration
-
Cell Model
-
Transaction construction
Building Forever Notes
The application started with a simple landing page before growing into a working interface where users could connect a wallet and prepare notes for blockchain storage.
One thing I wanted from the beginning was to make it feel like a real application instead of just a collection of UI components. Even though the blockchain functionality was still being developed, I wanted the flow to feel natural from connecting a wallet to creating a note.
Working on the project also helped me understand that building on CKB requires thinking differently.
Before CKB, I was used to thinking about smart contract functions.
CKB encouraged me to think about transaction construction, Cells, ownership, and state transitions instead.
That shift in perspective probably taught me more than writing the frontend itself.
Challenges
Like every first project, Forever Notes came with plenty of challenges.
The biggest one was understanding the Cell Model.
Coming from more traditional blockchain development, I naturally thought in terms of accounts and contract functions. CKB required me to think about transactions, inputs, outputs, ownership, and validation instead.
Wallet integration was another learning experience. Understanding how the frontend should prepare transactions before they reach the network was very different from what I had worked with before.
There were also the usual development challenges, including configuring the environment, testing on CKB Testnet, and refining the overall application flow.
Each challenge pushed me to understand another part of the ecosystem.
What I Learned
Looking back now, I realize Forever Notes taught me much more than I expected.
As I continued through the CKBuilders program, I learned about lock scripts, type scripts, Script Groups, xUDTs, transaction validation, custom scripting, and many of the concepts that sit underneath the applications users interact with.
Those lessons completely changed how I think about designing applications on CKB.
If I were starting Forever Notes today, I would spend much more time designing the Cell structure and transaction flow before writing the frontend.
I’d also make better use of CKB’s scripting capabilities to model application behavior instead of treating blockchain as just another backend.
That’s probably the biggest takeaway from this project.
The application hasn’t changed nearly as much as my understanding of the platform has.
Looking Ahead
Forever Notes started as a learning project, but I don’t see it as a finished one.
As I continue learning more about scripting, transaction construction, and the Cell Model, I plan to revisit some of these ideas and see how they can be applied to the project. There are plenty of features, improvements, and architectural changes that I’d like to experiment with as my understanding of CKB continues to grow.
One thing I’ve really enjoyed about the CKB ecosystem is seeing how different developers approach similar problems. That’s one of the reasons I wanted to share this project here.
If you have any feedback, ideas, or suggestions, I’d genuinely love to hear them.
How would you approach a project like this today?
Are there CKB features, design patterns, or architectural decisions that you think would improve Forever Notes?
The repository is open, and I’m always happy to learn from other builders and continue improving the project.
Thanks for reading, and thanks to everyone in the CKB community who shares their knowledge. Reading through other builders’ projects has been a huge part of my own learning, and I hope this post encourages someone else who’s just starting to build on CKB.