Forem: Parshuram Singh

From Code to Cloud: How Docker, CI/CD, and Deployment Platforms Work (Step by Step)

Parshuram Singh — Mon, 08 Sep 2025 07:11:57 +0000

Introduction

Ever wondered how the code you write on your laptop becomes a live website that anyone in the world can access?

Behind the scenes, several tools and platforms work together:
GitHub to manage and share your code
Platforms like Vercel for quick hosting
Docker containers for portability
CI/CD pipelines for automation
Cloud servers for scalability

In this blog, we’ll break the process step by step using a simple React web app as an example.

Step 1: Local Development

Every project starts on your computer.

Example: a React app that displays your projects.

npx create-react-app my-app
cd my-app
npm start

You’ll see the app running locally at http://localhost:3000
.
At this point, only you can see it.

Step 2: Pushing Code to GitHub

Before deploying, you push your project to GitHub.

Why? Because GitHub acts as your project’s source of truth:

Stores your raw code (React files, configs, Dockerfile, CI/CD workflows).
Tracks every change (commits, branches, pull requests).
Enables collaboration with teammates.
Serves as the trigger point for CI/CD pipelines.

👉 Think of GitHub as the workshop where your blueprints (code) live.

Step 3: Deploying with Platforms like Vercel

Platforms such as Vercel make deployment simple:

Connect your GitHub repo to Vercel.
Every time you push code, Vercel:
Pulls your latest code from GitHub
Runs npm run build
Hosts the app on a public URL

✨ Key points:

Vercel = serverless hosting → no need to manage servers.
Handles HTTPS, CDN, caching, and scaling for you.
Great for static sites or simple web apps.

✅ Benefit: beginner-friendly and fast
❌ Limitation: less control over runtime and environment

Step 4: Introducing Docker

What if you want more control or want your app to run anywhere (cloud, on-premise, or another laptop)?

That’s where Docker helps.

Docker Image = your app + OS + runtime + dependencies → all packaged together.
Docker Container = a running instance of that image.

Example Dockerfile:

# Step 1: Build stage
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Step 2: Serve with Nginx
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Build & run:

docker build -t my-app:v1 .
docker run -p 8080:80 my-app:v1

Now your app runs inside Docker, independent of your machine setup.

Step 5: Docker Hub (Image Repository)

To share images, we use Docker Hub (like GitHub but for containers).

docker tag my-app:v1 yourusername/my-app:v1
docker push yourusername/my-app:v1

Others can pull & run it:

docker pull yourusername/my-app:v1
docker run -p 8080:80 yourusername/my-app:v1

✅ Benefit: your app is now portable.

👉 Notice the difference:

GitHub = raw source code, where changes are tracked.
Docker Hub = built images, ready to run anywhere.

Both are essential parts of the workflow.

Step 6: Cloud Deployment

Instead of running containers locally, deploy them to cloud services:

Google Cloud Run
AWS ECS / Fargate
Azure App Service for Containers

Flow:

Cloud pulls the image from Docker Hub.
Runs it inside a container.
App becomes publicly accessible.

Step 7: Continuous Integration & Deployment (CI/CD)

Up until now, you’ve learned how to:

Build Docker images locally
Push them to Docker Hub
Deploy them on the cloud

That works fine for small projects, but imagine doing it manually every time you make a change.

🔴 The Manual Process (Repetitive & Error-Prone)

Let’s say you change one line of code in your React component. To update your app online, you’d need to:

# Build a new Docker image
docker build -t my-app:v2 .

# Tag the image correctly
docker tag my-app:v2 yourusername/my-app:v2

# Push it to Docker Hub
docker push yourusername/my-app:v2

# SSH into cloud & pull image
docker pull yourusername/my-app:v2

# Stop old container, run new one
docker stop my-app
docker run -d -p 8080:80 --name my-app yourusername/my-app:v2

Now imagine doing this every single time you fix a bug, add a feature, or update content.

It’s repetitive.
It’s easy to forget a step.
Versioning can get messy (v2, v3, final-v3, final-final-v4 😅).
On a team, multiple developers could overwrite or conflict with each other’s deployments.

Clearly, this doesn’t scale.

🟢 The Automated Process with CI/CD

This is where CI/CD (Continuous Integration / Continuous Deployment) saves the day.

Here’s how it works:

You push your code to GitHub.

This acts as the trigger.
No need to run manual Docker commands.

CI (Continuous Integration) kicks in.

A GitHub Actions workflow (or Jenkins, GitLab CI, CircleCI, etc.) automatically:
Checks out the latest code.
Installs dependencies.
Runs tests (optional but recommended).
Builds a new Docker image with the latest code.

The image is pushed to Docker Hub automatically.

The pipeline logs in with your Docker Hub credentials (stored securely as secrets).
Tags the image with latest (or a commit hash / version number).
Pushes it to Docker Hub without you lifting a finger.

CD (Continuous Deployment) takes over.

Depending on your setup, the pipeline can also:
Trigger your cloud provider (Google Cloud Run, AWS ECS, Kubernetes, etc.).
Pull the new image.
Redeploy the container automatically.

End Result: Within minutes of pushing code, your app is updated online.

✅ Why This Matters

Consistency → Same steps run every time, no “works on my machine” issues.
Speed → Deployments take minutes, not hours.
Team-Friendly → Multiple developers can push code, pipeline handles merges and deployments.
Error Reduction → No forgotten commands, no wrong tags.
Scalability → Works the same whether you deploy once a week or 20 times a day.

Example: GitHub Actions CI/CD

name: Docker Build & Deploy

on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Build Docker image
        run: docker build -t yourusername/my-app:${{ github.sha }} .

      - name: Login to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Push Docker image
        run: docker push yourusername/my-app:${{ github.sha }}

🔑 Notice:

The image is tagged with the commit SHA (${{ github.sha }}) so every build is uniquely tied to a version of the code.

No manual tagging, no mistakes.

👉 Bottom line:

Without CI/CD → You’re a human deployment robot, repeating commands.
With CI/CD → Deployments are automatic, reliable, and scalable.

This is exactly how real-world companies ship code dozens or even hundreds of times per day without breaking things.

End-to-End Summary

Conclusion

GitHub → the workshop where code lives, collaboration happens, and pipelines are triggered.
Vercel → quick, beginner-friendly deployments.
Docker → makes apps portable and production-ready.
Docker Hub → stores built images for sharing and deployment.
Cloud → runs containers at scale.
CI/CD → automates builds, tests, image pushes, and deployments.

Together, these tools form the modern deployment pipeline that real companies use daily.

With this setup, any project, portfolio, blog, or web app can be:

✅ Built locally
✅ Tracked in GitHub
✅ Dockerized
✅ Hosted anywhere
✅ Updated automatically with CI/CD

📌 Thanks for reading!

If you found this guide helpful, let’s stay connected:

📝 Follow me on Dev.to
💼 Connect on LinkedIn
🖥️ Peek into my work on GitHub
🌐 Explore my Portfolio

🚀 Let’s code, learn, and build together!

AI Meets Blockchain: The Ultimate Guide to the Future of Trust, Automation & Intelligence

Parshuram Singh — Mon, 11 Aug 2025 03:36:45 +0000

“AI without trust is dangerous. Blockchain without intelligence is static. Together, they’re unstoppable.”

We’ve all heard the hype around Artificial Intelligence and Blockchain.

But here’s the truth: Most people talk about them separately. Few truly understand the power of combining them.

Hi, I’m Parshuram Singh — Full Stack & Blockchain Developer, diving deep into the exciting overlap between Hyperledger Fabric, Web3, and AI-powered applications.

Over the past months, I’ve been experimenting with how AI can make blockchain smarter and how blockchain can make AI safer and what I’ve discovered has blown my mind.

This isn’t just about buzzwords.

It’s about building a future where AI makes blockchain smarter and blockchain makes AI safer, fairer, and more transparent.

Whether you’re a student, developer, startup founder, or industry leader, this guide will take you:

From zero to hero on AI + Blockchain basics
Into real-world use cases no one talks about
Through deep insights into where this tech is heading
With actionable steps so you can be part of it

Part 1: Let’s Start Simple — AI & Blockchain in Plain English

What is AI?

Artificial Intelligence (AI) is software that learns from data and makes decisions or predictions — from ChatGPT writing code to Google Maps predicting traffic.

What is Blockchain?

Blockchain is a tamper-proof digital ledger where data is stored in blocks and linked in a chain. It’s decentralized, meaning no single company owns it.

🔄 Why Combine AI + Blockchain?

Individually:

AI is powerful but opaque — we don’t always know how it decides something.
Blockchain is transparent but static — it records data but doesn’t analyze it.

Together:

AI adds intelligence to blockchain apps (predictive analytics, automation).
Blockchain adds trust to AI (proof that AI outputs are genuine and unbiased).

This combo solves two major problems in tech today:

Making AI more explainable and trustworthy
Making blockchain more adaptive and useful

Part 2: Real-World AI + Blockchain Use Cases (From Now to the Future)

1️⃣ Healthcare Data Security & AI Diagnostics

Blockchain stores encrypted patient records securely.
AI analyzes patterns for early disease detection.
Why it matters: Hospitals can share data without risking privacy, and AI diagnoses are verifiable.

Example:

BurstIQ — blockchain-powered health data exchange with AI insights.

2️⃣ Decentralized AI Marketplaces

Blockchain enables marketplaces where anyone can share/sell AI models.
Smart contracts ensure fair payment and usage rights.
Why it matters: No single corporation controls AI — democratizing access.

Example:

Ocean Protocol — tokenized data and AI marketplace.

3️⃣ AI-Enhanced Smart Contracts

Smart contracts are automated agreements on blockchain.
AI makes them adaptive — adjusting terms based on real-world data.
Why it matters: Supply chain contracts can adjust prices dynamically based on demand, weather, or risks.

4️⃣ Fighting Deepfakes & AI Misuse

Blockchain stores a verifiable origin of images, videos, and AI-generated content.
AI scans for manipulation.
Why it matters: Journalism, elections, and art remain authentic.

Example:

Truepic — blockchain-based media verification.

5️⃣ Supply Chain + Predictive AI

Blockchain ensures each product’s journey is recorded (authenticity).
AI predicts shortages, delays, or fraud before they happen.
Why it matters: From farmers to retailers, everyone gains efficiency.

Part 3: The “Insider” Layer — Crucial Details Few Talk About

🔒 Blockchain Solves AI’s Black Box Problem

AI often can’t explain its decisions (the “black box” issue). By storing AI training data, model versions, and decision logs on blockchain, every AI decision becomes traceable.

💰 Tokenized AI Economies

Imagine owning a fraction of an AI model and earning tokens whenever it’s used. Blockchain makes it possible through fractional ownership smart contracts.

⚠️ Challenges (Yes, There Are Some)

Scalability: AI needs fast computation; blockchain is slower for consensus.
Privacy: Not all AI training data can be made public.
Energy: Combining compute-heavy AI with blockchain must be energy-efficient.

Part 4: How YOU Can Get Started

🎓 If You’re a Student:

Learn Python for AI + Solidity/Hyperledger for blockchain.
Build small projects (e.g., AI chatbot on blockchain).

💼 If You’re a Professional Developer:

Explore AI inference in decentralized apps (dApps).
Integrate AI APIs into Web3 platforms.

🏢 If You’re a Business Owner:

Identify processes needing both trust and intelligence.
Start with pilot projects — e.g., AI-powered supply chain tracking.

Part 5: The Future of AI + Blockchain

We’re heading towards:

AI DAOs (Decentralized Autonomous Organizations) — fully AI-run organizations with blockchain governance.
Self-owning AI agents — AI systems that own wallets and can transact.
Global Trust Layers — AI decisions recorded immutably for cross-border trust.

💬 Your Turn

What excites you most about AI + Blockchain?

Which industry do you think will adopt it first?

Drop your thoughts below — let’s spark a discussion! 🔥

🙌 Connect with Me

🌐 My Portfolio
🐙 GitHub
💼 LinkedIn
✍️ My Dev.to Blog

If this post helped you see the bigger picture, hit ❤️ and share it so more people understand the future we’re building.
I’d love to connect with others working on Blockchain + AI. Drop your thoughts — what use case excites you the most?

Final Thought:

The future isn’t AI or Blockchain.

It’s AI + Blockchain and it’s closer than you think.
This fusion isn’t about man vs. machine — it’s about man + machine.
And as developers, we have a front-row seat (and a ticket to build it)

🤖 How AI Is Changing Frontend Development (and Why It Won’t Replace You)

Parshuram Singh — Sun, 03 Aug 2025 09:36:06 +0000

“AI won’t replace developers—but developers who use AI will replace those who don’t.”

Let’s be honest — if you're building websites today, you’ve probably thought:

“Will AI write code better than me someday?”

As a frontend developer working with React, Tailwind CSS, and modern UI/UX workflows, I’ve seen AI tools reshape how we work — but not why we work.

In this blog, I’m breaking down:

How AI is already integrated into frontend workflows
Why your creativity and decisions still matter more than ever
How to level up by working with AI, not against it

Let’s dive in. 👇

⚙️ 1. How AI is Already Changing Frontend Dev

Here’s where AI is making a real impact on frontend development:

🧠 AI Code Autocomplete (Copilot, Codeium, Cursor)

AI suggests entire functions, React hooks, and even components reducing boilerplate and decision fatigue.

✅ Speeds up dev

❗ Still needs your logic and sanity checks.

🎨 Design-to-Code (Uizard, Builder.io, Figma AI)

You can now convert wireframes, screenshots, or sketches into Tailwind + React code. It’s scary fast.

✅ Great for prototyping

❗ But lacks finesse — layout bugs, accessibility, and hierarchy still need you.

🧪 Smart Testing & Bug Detection

Some AI tools generate unit tests or catch suspicious behavior automatically (like Vercel AI, Replay.io).

✅ Helps find edge cases early

❗ Still doesn’t understand business context.

🧾 SEO, Copy & Content

AI writes your alt text, meta tags, even page content.

✅ Useful for blogs and marketing

❗ But only you can bring authentic tone and emotion.

🧑‍💻 2. What AI Can’t Replace (Thankfully)

Despite all that power, AI still can’t do your job as a frontend dev. Why?

Because your value lies in:

🤝 Human-Centered Design Decisions
🧠 Contextual Thinking (When to use a modal vs. new route?)
🧩 Component Architecture
🎯 User Empathy & Accessibility
🔄 Feedback Loops with Designers & PMs
💡 Creative Problem Solving

We don’t just build UIs. We build experiences. That’s where AI stops — and where you shine.

🧭 3. How to Stay Ahead (Not Replaced)

Instead of resisting AI, let it amplify your workflow.

✅ Here’s what I’ve started doing:

🧠 Learning prompt engineering for smarter Copilot/ChatGPT usage
⚡ Using AI to convert Figma designs into rough React + Tailwind skeletons
📏 Automating alt text, meta tags, and microcopy with review
🧪 Asking AI to generate unit test templates (then refining them manually)
📚 Staying up-to-date on ethical, privacy, and accessibility concerns with AI tools

📌 TL;DR

AI is here and already changing how we build for the web
But it’s not replacing frontend devs—it’s amplifying them
Your unique edge = creativity, UX sense, and human decisions
Devs who embrace AI will lead the next generation of product-building

💬 Let’s Chat

Have you tried any AI tools in your frontend workflow yet?

Are you more excited or worried about this new wave?

Drop your thoughts in the comments 💬 — I read and reply to every one!

🙌 Stay Connected!

If this article gave you insight, hit the ❤️ and share it with your dev friends or team — let’s grow together as AI-native frontend builders.

Thanks for reading. You’ve got this. 💻⚡

How I Integrated Dev.to Blogs into My Portfolio: From Client-Side CORS to Full GitHub Automation

Parshuram Singh — Thu, 31 Jul 2025 09:33:08 +0000

TL;DR: Learn how I integrated my Dev.to blogs into my React portfolio, tackled CORS errors, fixed API caching bugs, and fully automated the blog fetch using GitHub Actions and Node.

🎯 Goal

I wanted to showcase my Dev.to blog posts on my React-based portfolio, with these goals in mind:

✅ SEO-friendly (Google should index my blogs)
✅ Fast loading
✅ No CORS issues
✅ Fully automated updates
✅ Clean fallback if Dev.to is down

What started as a simple fetch turned into a deep integration journey — here's how I did it 👇

🛠️ Phase 1: The Naive Client-Side Fetch

At first, I simply fetched my blog posts from Dev.to using their public API like this:

js
useEffect(() => {
  fetch('https://dev.to/api/articles?username=parshuram_singh')
    .then(res => res.json())
    .then(data => setBlogs(data));
}, []);

The Problems

CORS errors in some browsers (like Brave)
No SEO: Blogs were loaded after page render
Unreliable: If Dev.to was down, my blog section broke
Caching issue: The API returned different blog counts when logged in vs incognito

Phase 2: Vercel Serverless Function

Next, I moved the logic to a serverless function on Vercel:

// /api/getBlogs.js
export default async (req, res) => {
  const response = await fetch(DEVTO_API_URL);
  const data = await response.json();
  res.status(200).json(data);
};

Pros

Solved CORS issues
Centralized logic

Cons

Still a runtime fetch
Still not SEO indexable
Added function cold start time

Phase 3: Static File with Node Script

To make things fast, SEO-friendly, and bulletproof, I wrote a Node script to fetch blog data and save it as a static file:

// fetch-devto-blogs.js
const fs = require('fs'); // Import the 'fs' module
const fetch = require('node-fetch'); // Assuming node-fetch is installed for Node.js environments

async function fetchBlogs() {
  const response = await fetch('[https://dev.to/api/articles?username=parshuram_singh](https://dev.to/api/articles?username=parshuram_singh)');
  const blogs = await response.json();
  fs.writeFileSync('./public/blogs.json', JSON.stringify(blogs, null, 2));
}

fetchBlogs();

Now, my React app loads from blogs.json during build:

const blogs = await fetch('/blogs.json').then(res => res.json());

Massive Wins:

Static = super fast
SEO-optimized
No CORS
Resilient (even if Dev.to is down)

Phase 4: API Caching Mystery

I hit a weird bug:
In some browsers, the URL with per_page=100 returned only 1 blog!

# Returned 1 blog in Brave (incognito)
curl "[https://dev.to/api/articles?username=parshuram_singh&per_page=100](https://dev.to/api/articles?username=parshuram_singh&per_page=100)"

# Returned 2 blogs in Chrome (logged in)

Turns out, Dev.to's API caches responses differently based on login state — yikes!

Fix: Remove per_page=100
Just drop the param, and Dev.to gives a correct full list:

const DEVTO_API_URL = '[https://dev.to/api/articles?username=parshuram_singh](https://dev.to/api/articles?username=parshuram_singh)';

Phase 5: GitHub Actions Automation

To keep the blog feed updated, I automated the Node script using GitHub Actions:

name: Fetch Dev.to Blogs

on:
  push:
    branches: [main]
  workflow_dispatch: # Allows manual trigger

jobs:
  fetch:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '20'
      - run: npm install node-fetch # Install node-fetch for the script
      - run: node fetch-devto-blogs.js
      - run: |
          git config --global user.name "GitHub Actions"
          git config --global user.email "actions@github.com"
          git add public/blogs.json
          git commit -m "Update blogs.json" || echo "No changes" # Commit only if changes exist
          git push

Final Result:

On every push, blogs are auto-fetched
No manual update needed
Blazing fast blog section
Fully SEO-optimized

Final Setup Recap

Area	Solution
Source	Dev.to API (username=...)
Fetching	Node.js Script
Hosting	Vercel
Output	`public/blogs.json`
Automation	GitHub Actions
CORS Issues	Solved
SEO Support	Static data
API Bug (Dev.to)	Avoided `per_page=100` param

Lessons Learned

Avoid runtime fetch for public data use static where possible
Always test public APIs in multiple browsers (incognito too!)
GitHub Actions are great for automating content workflows
Static files are simple, reliable, and perfect for SEO

Final Thoughts

This blog chronicles a significant part of my journey in building a robust and efficient online portfolio. The insights gained from tackling CORS, optimizing for SEO, and automating content delivery have been invaluable.

If you're integrating Dev.to or any API into your site, I hope this real-world account saves you hours of debugging and helps you build a more resilient application.

Want to see this live? My portfolio is now up and running! Check it out:
My Portfolio

If this helped or you liked the journey feel free to leave a comment below.

Happy coding!

— Parshuram Singh

How I Built a Trade Finance App on Hyperledger Fabric – A Complete Blockchain Project Walkthrough

Parshuram Singh — Sat, 26 Jul 2025 08:02:27 +0000

Hey Dev.to community! I’m Parshuram Singh, a Frontend and Blockchain Developer, and I’m excited to walk you through my journey of building a Blockchain-Powered Trade Finance App using Hyperledger Fabric, Node.js, and React. This project automates a seven-step trade finance process creation, approvals, shipping, receipt, and payment leveraging blockchain for transparency and efficiency. Whether you’re new to blockchain or a seasoned dev, this blog will guide you from setup to a working app.

The Idea: Why Blockchain for Trade Finance?

Trade finance involves a complex workflow with applicants, banks, and beneficiaries coordinating shipments and payments. Traditional systems rely on paper-based processes and intermediaries, leading to delays and errors. Blockchain’s immutability and smart contracts offer a decentralized solution, ensuring a tamper-proof ledger accessible only to trusted parties.

My goal was to create an app where:

An Applicant initiates a trade request.
Banks (Issuing and Beneficiary) approve it.
The Beneficiary ships goods with evidence.
The Applicant confirms receipt.
Payments are finalized all tracked on a blockchain.

I chose Hyperledger Fabric for its permissioned network, Node.js for the backend, and React for the UI. Let’s build it step-by-step!

Step 1: Network Setup

I built a full Hyperledger Fabric network from scratch using a custom script:

Docker Containers: Spun up peers, orderers, and certificate authorities (CAs) with:

./network.sh up createChannel -c mychannel -ca

Crypto Material: Generated MSP and TLS certificates automatically via the script.
Configuration Files: Crafted a custom connection.json for the SDK to interact with the network.
Private Channel: Configured a private channel (mychannel) to isolate data access between trusted parties (banks, applicants, beneficiaries).

Private channels enforce secure, selective data sharing, critical for enterprise use cases.

This setup ran on my Ryzen 5 machine with 16 GB RAM and Ubuntu 22.04, providing a robust foundation.

Step 2: Writing & Deploying Chaincode

The smart contract (TradeFinance.js), written in JavaScript with the fabric-contract-api, automates the trade finance logic.

Code Highlights

const { Contract } = require('fabric-contract-api');

class TradeFinanceContract extends Contract {
    async initLedger(ctx) {
        console.info('Initializing Ledger: TradeFinanceContract');
        const participants = [
            { id: 'b1', name: 'Bank b1', type: 'Bank' },
            { id: 'b2', name: 'Bank b2', type: 'Bank' },
            { id: 'app', name: 'Applicant app', type: 'User' },
            { id: 'ben', name: 'Beneficiary ben', type: 'User' }
        ];
        for (const participant of participants) {
            await ctx.stub.putState(participant.id, Buffer.from(JSON.stringify(participant)));
        }
    }

    async createApplication(ctx, applicationID, productDetails, applicantRules) {
        const application = {
            ID: applicationID,
            applicant: 'app',
            beneficiary: 'ben',
            issuingBank: 'b1',
            exportingBank: 'b2',
            productDetails,
            rules: applicantRules,
            evidence: null,
            approvingEntities: [],
            status: 'PENDING_ISSUING_BANK',
            statusHistory: [{ status: 'PENDING_ISSUING_BANK', timestamp: ctx.stub.getTxTimestamp() }]
        };
        await ctx.stub.putState(applicationID, Buffer.from(JSON.stringify(application)));
        return JSON.stringify(application);
    }

    // Additional methods: approveByIssuingBank, approveByBeneficiaryBank, etc.
}

module.exports = TradeFinanceContract;

Deployment

./network.sh deployCC -ccn tradeFinance -ccp ../asset-transfer-basic/my-chaincode/ -ccl javascript

Verify Deployment

peer lifecycle chaincode querycommitted --channelID mychannel --name tradeFinance

Test an Invocation

peer chaincode invoke -C mychannel -n tradeFinance -c '{"function":"createApplication","Args":["T001","Laptops","COD"]}'

Step 3: App SDK + CLI Interactions

I built a Node.js SDK app (myapp.js) to enable communication with the blockchain.

Key Features

User Management: Registers and enrolls users via the wallet.
Transactions: Submits and evaluates transactions.
Queries: Fetches trade status by ID.

const { Gateway, Wallets } = require("fabric-network");
const express = require("express");
const cors = require("cors");
const app = express();
app.use(express.json());
app.use(cors());

const PORT = 3000;

async function connectToNetwork() {
    const wallet = await Wallets.newFileSystemWallet("wallet");
    const gateway = new Gateway();
    await gateway.connect(JSON.parse(fs.readFileSync("connection.json")), { wallet, identity: "appUser" });
    const network = await gateway.getNetwork("mychannel");
    return network.getContract("tradeFinance");
}

app.post("/create-application", async (req, res) => {
    const { id, productDetails, rules } = req.body;
    const contract = await connectToNetwork();
    const result = await contract.submitTransaction("createApplication", id, productDetails, rules);
    res.json(JSON.parse(result.toString()));
});

CLI Tool:

node myapp.js createApplication T001 "Laptops" "COD"

Step 4: Debugging Like a Pro

Debugging a Fabric network was a learning curve! Here’s how I tackled issues:

Docker Logs: docker logs <container_id> to troubleshoot peers and orderers
Debug Mode: Ran chaincode in debug mode inside containers
Common Fixes: Resolved identity mismatches, endorsement policy failures, and config issues

Debugging Fabric reveals its internals orderers sequencing transactions, peers validating them—making it a deep dive into its architecture!

Step 5: Performance Benchmarking with Caliper

I used Hyperledger Caliper to test the smart contract under load.

Setup

cd asset-transfer-basic/my-application
npx caliper launch manager --caliper-workspace . --caliper-benchconfig benchmarks/trade-finance-benchmark.yaml --caliper-networkconfig networks/trade-finance-network.yaml --caliper-fabric-gateway-enable

Simulated 32000+ transactions

Results

Latency: Measured average transaction time
Throughput: Achieved up to 6000 TPS on my setup
Success Rate: Optimized logic to reduce failures

This identified bottlenecks (e.g., endorsement delays) and guided optimizations.

Key Concepts I Learned

Fabric Internals: Orderers sequence, peers validate, channels isolate
Identity Management: MSPs, TLS, and CAs secure the network
Chaincode Lifecycle: Install, approve, commit process
Business Logic: Secure state transitions and audits
Docker Debugging: Microservice troubleshooting
Benchmarking: Caliper for performance tuning

GitHub Repository

👉 View the full project on GitHub

Final Words

This project immersed me in enterprise blockchain development, from spinning up a Fabric network to benchmarking with Caliper. It’s been a wild ride debugging Docker containers, and optimizing performance all while mastering Fabric’s depths. If you’re exploring Hyperledger Fabric, fork my repo, experiment, and share your insights!

Let’s Connect!

Follow me for more real-world Blockchain + Frontend dev content!

Thanks for reading!
– Parshuram Singh
Frontend + Blockchain Developer | Hyperledger | React | Smart Contracts | Java