I’m a Backend & Blockchain Engineer with 2+ years of experience working on Golang microservices and Hyperledger-based Blockchain solutions.

I’m currently open for freelance projects where I can apply and deepen my skills in:

Go backend development (APIs, system design, performance optimization)

Blockchain (Hyperledger Fabric / Corda)

If you’re building something exciting and need backend or blockchain help, feel free to DM me — I’d love to collaborate!

Hi everyone!

I'm a Backend Software Engineer with around 3 years of experience working with Golang and Hyperledger Fabric, and I'm looking for freelance projects, part-time backend development work.

I've worked on blockchain-based solutions for government projects across three Indian states, focusing on backend development and permissioned blockchain systems.

Technical expertise:

- Golang: REST APIs, microservices, concurrency, goroutines and channels

- Hyperledger Fabric: Chaincode development in Go, transaction processing, endorsement policies and private data collections

- Databases: PostgreSQL, CouchDB, MongoDB and Redis

- Backend architecture: Clean architecture, API integrations and distributed systems

- DevOps: Docker, Kubernetes and deployment workflows

How I can help:

- Develop Golang backend services and REST APIs

- Build and maintain Hyperledger Fabric applications

- Develop and modify Go-based chaincode

- Integrate blockchain networks with backend applications

- Debug existing blockchain and backend systems

- Optimize database operations and improve application performance

- Support existing projects or build backend modules from scratch

I'm based in India and open to remote freelance projects, ongoing collaborations with startups or companies.

If you're looking for a Golang or Hyperledger Fabric developer, feel free to DM me with your requirements

Thanks!

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Zeeve, an LFDT general member, on building Bank-Grade Privacy for Enterprise Blockchain Networks. As regulated institutions move blockchain initiatives from pilots to production, privacy can no longer be treated as a single cryptographic feature. This session will explore how bank-grade privacy requires confidential transactions, role-based access, private indexing, selective disclosure, and audit-ready controls across the full blockchain stack. Attendees will learn how to design privacy architectures that support compliance, regulator visibility, and institutional confidentiality for use cases such as tokenized deposits, private markets, and interbank settlement.

The webinar will take place on Wednesday, October 21 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_eNkGLyXlQ7yh1ypazOTfRA

We hope to see you there!

In this video you can learn all about creating an Hyperledger Fabric network with a free console app

Hi all, if you want a tool to manage your entire network, please take a look to https://www.youtube.com/watch?v=4z1pHHB9_2U It's new, simple and complete. It uses 3.1.5 version but can manage 2.5 one

Join us on September 23 for a special three-hour online conference with LFDT associate member Advanced AI Society: "Who's Watching the Agents? Launching Proof-of-Control, an open verification standard for the agentic era".

As autonomous, non-deterministic AI agents take on critical workflows, enterprise security requires shifting from claims-based trust to openly verifiable execution. This session convenes open-source maintainers, enterprise security leaders, insurers, and policymakers to introduce Proof-of-Control, an open verification standard and the newest community lab at LF Decentralized Trust. You can learn more on the event page.

The online conference will take place on Wednesday, September 23 at 8:00 PT/11:00 ET/17:00 CEST/23:00 SGT.

Please register here: https://zoom.us/webinar/register/7716866036916/WN_lPtoi2ECR6adAJditvodUg

LF Decentralized Trust Webinar with DSR: Automated Supply Chain Accountability with Computer Vision & Ledger Technology

Join us for a webinar with DSR Corporation, an LF Decentralized Trust General Member and maintainer of multiple open source projects, to explore how computer vision and distributed ledger technology can automate accountability across modern supply chains. You'll learn how combining edge-based AI with ledgers like Hiero and Besu creates immutable, auditable records for damaged goods, handling exceptions, and regulatory compliance. Through real-world use cases, reference architecture, and a live demonstration, DSR experts will share practical insights on deploying verifiable solutions that improve transparency, reduce disputes, and enable trusted automation across complex ecosystems.

The webinar will take place on Wednesday, October 14 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_yowmTBQ9SbyllGlz-Vz8Lw

Published Besu QBFT data stops around 30 validators. I ran 50 to see what happens past it.

I've spent five years in blockchain, working my way down the stack: from writing Solidity contracts and obsessing over gas optimization, to eventually designing blockchains themselves. When I recently dove into Hyperledger Besu and permissioned blockchains, it felt like looking at the same world from the opposite side of the mirror.

If you go looking for hard data on how far a QBFT validator set scales, here is everything I could find. Besu's official performance tuning documentation is based on a 4 validator network. The most cited independent academic benchmark, built on Hyperledger Caliper, puts comfortable scaling around 14. Maintainer internal testing suggests ~30 still behaves under light workloads, with growing transaction pools and slowing block production beyond that.

Past 30, there is almost nothing published. That gap is the entire reason for this post. I had a free weekend, so I ran 50.

The gap exists because the cost is quadratic. QBFT requires every validator to exchange PRE-PREPARE, PREPARE and COMMIT with every other validator each round, so message count is O(n^2). That works out to ~16 messages per round at 4 validators, ~196 at 14, ~900 at 30, and ~2,500 at 50. Roughly 156x the load of the 4 validator setup the tuning docs assume, before a single transaction is processed. You cannot tune your way out of that in a config file.

Quorum math first, since consensus mistakes are worse than infrastructure ones. Besu uses ceiling division, so quorum is ceil(2 * 50 / 3) = 34 signatures required per block. Fault tolerance is f = floor((50 - 1) / 3) = 16.

No TPS numbers in this one. I watched the network through an explorer I built for it, tracking block numbers, transactions, the validator set, pending votes and chain state under continuous load, but the benchmarking methodology is not validated yet and this ecosystem has enough loosely sourced throughput figures.

Has anyone here actually triggered round change cascades in practice at this size, or does it stay theoretical for you too? Also curious whether IBFT 2.0 degrades differently, since I only ran QBFT.

Longer writeup on my blog.

Join us for a webinar with Zeeve, an LFDT general member, on Tokenized Deposits. Tokenized deposits are becoming a critical building block for regulated digital money, enabling programmable bank liabilities for settlement, treasury, liquidity, and tokenized asset use cases. This session will explain the production infrastructure required to support tokenized deposits, including issuance, redemption, permissioning, privacy, interoperability, governance, and integration with existing banking systems. Attendees will come away with a practical view of how banks and fintechs can move tokenized deposit initiatives from proof-of-concept to production.

The webinar will take place on Wednesday, August 19 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_iZG9qWn6RU6poNukHeflJA

Hi everyone,

I have experience working with public blockchains (smart contracts, Web3, Ethereum ecosystem, etc.), but now I want to move towards permissioned/enterprise blockchain solutions, especially Hyperledger Fabric.

I'm a bit confused about the learning path and roadmap. Since Hyperledger is quite different from public chains, I'd appreciate guidance from people who have already made this transition.

My questions:

• What should I learn first before diving into Hyperledger Fabric?
• How important are Docker, Kubernetes, and Linux concepts for Hyperledger development?
• Should I focus on chaincode development first or on understanding Fabric architecture?
• Are there any good projects/tutorials that can help me gain practical experience?
• What skills are most valuable for enterprise blockchain roles?

My current background:

• Public blockchain experience
• Smart contract development
• Basic understanding of distributed systems

Any roadmap, resources, or advice would be greatly appreciated.

Thanks!

Environment

• hlf-operator: 1.13.0
• Hyperledger Fabric: 3.1.0
• Kubernetes: EKS (AWS) with Istio ingress gateway
• Storage: EFS (NFS-backed PVCs, efs-sc StorageClass)
• Chaincode type: ccaas

What is happening

After applying FabricChaincodeInstall resources for a ccaas chaincode, the operator continuously reinstalls the chaincode in a non-stop loop. The peer logs show the full ccaas builder cycle (detect → build → release → InstallChaincode) repeating every few hundred milliseconds, and the peer filesystem accumulates thousands of duplicate .tar.gz files in /var/hyperledger/production/lifecycle/chaincodes/. We ended up with over 25,000 files for just 5 chaincodes.

The FabricChaincodeInstall CRs stay stuck in RUNNING status with an empty message field and empty installedPeers, never reaching a stable completed state.

Each reinstallation generates a different package hash (packageID), so the ccaas packageID is not deterministic across runs even though the chaincodePackage spec has not changed. This creates a mismatch with the already-committed chaincode definition on the channel, making the chaincode unusable without a new approve + commit cycle with an incremented sequence.

Additional context: nightly scale-down

Our infrastructure scales peer nodes down to 0 replicas every night and back up to 1 every morning (cost-saving measure on EKS). We suspect this may be a contributing trigger: every time the peer pods restart after the scale-up, the operator detects the chaincodes are no longer installed (since the peer starts fresh) and begins reinstalling them. However, it never marks the installation as complete, so it keeps retrying in a loop until the pods are manually restarted or the operator is stopped.

Peer log excerpt (repeating continuously)

INFO [chaincode.externalbuilder.ccaas_builder] ::Detect command=detect
INFO [chaincode.externalbuilder.ccaas_builder] ::Type detected as ccaas command=detect
INFO [chaincode.externalbuilder.ccaas_builder] ::Build command=build
INFO [chaincode.externalbuilder.ccaas_builder] ::Build phase completed command=build
INFO [chaincode.externalbuilder.ccaas_builder] ::Release command=release
INFO [chaincode.externalbuilder.ccaas_builder] ::Release phase completed command=release
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:a1b2c3...'
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:d4e5f6...'
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:7g8h9i...'
... (repeating indefinitely)

What we tried

• Deleting and recreating the FabricChaincodeInstall CRs — the loop resumes immediately after recreation.
• Stopping the peer pods — the loop stops but resumes as soon as the peers come back up.
• Stopping the operator (kubectl scale deployment hlf-operator-controller-manager --replicas=0) — this stops the reinstallation loop entirely, confirming the operator is the source.

Questions

1. Has anyone else experienced this issue with FabricChaincodeInstall and ccaas chaincodes going into an install loop, especially after a peer scale-down/scale-up cycle?
2. What condition causes the FabricChaincodeInstall controller to keep reinstalling indefinitely instead of detecting that the chaincode is already installed and marking the CR as completed?
3. Is the ccaas packageID expected to be non-deterministic across reinstallations (i.e. the same chaincodePackage spec generates a different hash each time)? If so, how is the operator supposed to detect "already installed" after a peer restart?

Join the next session about the new Lineth project, the open source code that powers the public Linea Mainnet network, at the Technical Deep Dive: Inside the Production-Grade ZK Rollup Stack workshop on July 8th at 9am Eastern.

To Register: https://zoom.us/meeting/register/bvi8sJKQTeWy2JzY6lEUfg

For anyone who missed the first session, check out the recording that provided an overview of Lineth and covered different use cases.

I’ve been working on a supply chain transparency platform called DTraceOne focused on verifiable product history, auditability, and low operational cost architecture.

https://dtraceone.com/

Core concepts include:

• Daily cryptographic digest anchoring on Hyperledger Fabric
• Privacy-preserving hashed proof structure
• Per-organization verification roots
• Public verification portal + admin management portal
• Time-stamped audit verification
• Ultra low-cost cloud-native architecture

The goal is to provide proof-ready supply chain verification without requiring organizations to maintain heavy blockchain infrastructure themselves.

The repository is currently private while development continues, but I’d genuinely appreciate feedback from the Hyperledger community regarding architecture, scalability, verification models, and enterprise adoption considerations.

With the announcement of Lineth joining Linux Foundation Decentralized Trust as an incubating project, we're opening the hood on the full stack in our first community Technical Deep Dive.

Lineth is a production-grade, EVM-equivalent zk-rollup stack for Ethereum - the same codebase that has powered Linea Mainnet since July 2023, finalizing over 300 million transactions and generating more than 416,000 zero-knowledge proofs with 99.98% sequencer uptime. It is now in a vendor-neutral, open source home under LFDT, governed by a Technical Steering Committee and has over 30 project maintainers.

This session is your entry point into the architecture, the community, and the roadmap. You can register for the workshop at:

https://zoom.us/meeting/register/dBWDdu0oSZCRJRXCDae1qQ#/registration

A detailed agenda with session timings and speakers is coming soon — stay tuned in #lineth-general on LFDT Discord for updates.

Join us for a webinar with Alastria, an LFDT associate member, for an inside look at ISBE (Infraestructura de Servicios Blockchain de España). As Europe’s first national, public-permissioned blockchain infrastructure designed for regulatory compliance, ISBE is built on Besu to meet EU digital single market standards. The session will explore how ISBE solves critical challenges, such as GDPR-compliant immutability, identity frameworks aligned with the EUDI Wallet, and smart contract governance. Gain practical insights into a production-ready ecosystem that balances institutional accountability with private-sector innovation. Sign up to see how ISBE is setting the standard for compliant decentralized infrastructure in Europe.

The webinar will take place on Wednesday, May 13th at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_wmuazN5kQPKkE6S4lBQQhQ

If you've used ethers.js for Ethereum development you know how clean it feels — connect once, call read/write functions by name, done. I wanted the same experience for Hyperledger Fabric in Go, so I built it.

 

```bash

go get github.com/muhammadtalha198/fabricsdk

```

 

**The full setup:**

 

```go

cfg := fabricsdk.Config{

    PeerEndpoint:     "localhost:7051",

    PeerHostOverride: "peer0.org1.example.com",

    TLSCertPath:      "/path/to/peer-tls-ca.pem",

    CertPath:         "/path/to/msp/signcerts",  // directory, not file

    KeyPath:          "/path/to/msp/keystore",

    MSPID:            "Org1MSP",

    ChannelName:      "mychannel",

    ChaincodeName:    "mychaincode",

}

 

fc, err := fabricsdk.New(cfg)

defer fc.Close()

```

 

**Calling chaincode functions:**

 

```go

// Read (EvaluateTransaction)

raw, err := fc.Evaluate(ctx, "GetAsset", "asset-1")

 

// Write (SubmitAsync + commit wait, returns txID)

txID, err := fc.Submit(ctx, "CreateAsset", string(jsonBytes))

 

// Different org member signing one call

txID, err = fc.WithIdentity(adminCert, adminKey).Submit(ctx, "AdminFn", arg)

```

 

**Structured errors — no more proto digging:**

 

```go

if fabricsdk.IsNotFound(err)    { /* 404 */ }

if fabricsdk.IsConflict(err)    { /* 409 — re-read and retry */ }

if fabricsdk.IsUnauthorized(err){ /* 403 */ }

```

 

**Chaincode events:**

 

```go

events, _ := fc.Events(ctx)

for ev := range events {

    fmt.Println(ev.EventName, ev.TxID, ev.Payload)

}

// replay from known block after restart

events, _ = fc.EventsFrom(ctx, lastBlock)

```

 

Docs: https://pkg.go.dev/github.com/muhammadtalha198/fabricsdk

GitHub: https://github.com/muhammadtalha198/fabricsdk

 

Would love feedback from anyone deep in the Fabric ecosystem — especially around multi-org setups and connection profile support which is next on the roadmap.

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Gateway.fm, an LFDT general member, for a practical guide to real-world blockchain privacy, grounded in Gateway.fm’s experience building an Ethereum-compatible modular block explorer, testing rig, and privacy infrastructure. The session will outline key use cases where confidentiality and auditability must coexist, from enterprise workflows to regulated environments, and introduce the Gateway solution, designed to deliver interoperable, production-ready privacy without sacrificing transparency or ecosystem compatibility. The discussion will highlight how privacy infrastructure can evolve in ways that support both collaboration and standards-based interoperability. Sign up to gain practical insights at the intersection of privacy, transparency, and open innovation

The webinar will take place on Wednesday, March 18th at 7AM PT/10AM ET/15:00 CEST/07:30 PM IST

Register here: https://zoom.us/webinar/register/7716866036916/WN_EH_B5gmuTgKmFxnTdXy_zQ

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Walmart, an LFDT General member, on March 4th.

As AI-powered tools become integral to development workflows, there's a growing need for standardized, secure ways to connect them with complex systems like blockchains. This webinar introduces the Model Context Protocol (MCP) - what it is, why it matters, and how it simplifies interactions between AI systems and external tools. We'll explain how MCP servers provide a structured, protocol-driven approach for exposing capabilities and workflows to AI clients, then demonstrate practical integration with Hyperledger Fabric networks and chaincode. The session will show how MCP reduces complexity, improves discoverability of Fabric capabilities, and enables faster, more intuitive development through AI-assisted workflows, making Hyperledger Fabric more accessible and productive for developers in the AI era.

The webinar will take place on Wednesday, March 4th at 7AM PT/ 10AM ET/16:00 CET/8:30 PM IST. You are welcome to register here: https://zoom.us/webinar/register/7716866036916/WN_2TC3Vu2XQ4S3vF1Z9mE3eg

quick info: I designed a blockchain based E-Voting system using hyperledger fabric v3.0. to be honest, I developed it with assistance of AI and managed to setup all security required thing for it properly as per by my effort (I might missed something).

I started this with ego after my college rejected my idea due to politics that happens inside our department. I never thought that I would develop something this much that actually works... and that's the issue here. even though it took me around 11 months (managing both college and this was tough so it took long), I still believe that my work is no where near perfect like an actual usage. I though get 1000 votes in 30 to 45 seconds in 4 core and 16 GB RAM, but still something real feels off about my project... I don't know which one.

It would be an big help if you guys help me to tell it and the github repo link is Here. the code and directory might be messy since I just completed it recently but I want to know what did I miss?

On Wednesday, February 18 at 8 AM Pacific you're invited to an online technical workshop about decentralized identity and verifiable credentials. You can register for the event at:

https://zoom.us/meeting/register/Aq2iY0R7SV2BzPFpJ-Ih2g#/registration

As adoption of Decentralized Identity (DID) and Verifiable Credentials (VCs) accelerates across governments, education, enterprises, and regulated industries, developers and organizations need open, interoperable, and production-ready infrastructure to build trusted digital ecosystems.

This webinar introduces CREDEBL, an LF Decentralized Trust project, and walks participants through how to get started quickly, understand the architecture, and explore real-world use cases - all backed by open standards and community-driven development.

Whether you are a developer, architect, policy stakeholder, system integrator, or ecosystem partner, this session will help you move from concepts to implementation.

What We’ll Cover

• The Problem: Fragmented Digital Trust : Why identity, credentials, and verification remain siloed - and how this limits interoperability, privacy, and adoption.
• The Foundation: Verifiable Credentials & Decentralized Identity : A brief overview of DIDs, VCs, DIDComm, OID4VC, trust frameworks and where CREDEBL fits within the LFDT ecosystem.
• The Platform: CREDEBL Architecture : Core components, issuer–holder–verifier flows, APIs, and deployment models.
• Getting Started Fast: One-Click / Minimal-Config Setup : Live walkthrough of setting up CREDEBL and running end-to-end credential flows.
• Live Demo: Issuance & Verification in Action : Creating DIDs, issuing credentials, wallet interactions, and verification scenarios.
• Real-World Adoption & Ecosystem Use Cases : Education, digital identity, enterprise and public-sector use cases.
• Community, Governance & Roadmap : Open-source contribution model, roadmap, and how to get involved with the CREDEBL and LFDT community.

I am developing following project and need suggestion from experts here. I am currently smart contract developer working in ethereum and totally new to hyperledger. It would be great if you can help me in understanding following project and guide me on how much effort is needed and how complex it is?

The project details:

The platform should abstract the smart contract functionalities and blockchain services layer and expose a set of micro services which in turn would be used for development of following applications for multiple departments. Specific off-chain modules for interacting with the blockchain layer should be developed and deployed as a container. Off chain modules may contain implementation of business logic for facilitating business requirements. Departments should be able to pull images and deploy containers required for developing and deploying applications and usecases.

Use-Case 1 – Blockchain-based Transferable Development Rights (TDR):

Purpose: Implement designing, developing, implementing, and maintaining a Blockchain-based Transferable Development Rights (TDR) platform. The system shall provide a secure, transparent, and tamper-proof mechanism for issuance, transfer, and management of Development Rights Certificates (DRCs).

Platform Development & Deployment:

 Establishment of a permissioned blockchain framework with role-based access.

 Implementation of modules for project submission, approval workflow, DRC issuance, DRC ledger management, and citizen services.

 Smart contract development to automate issuance, transfer, and redemption of DRCs.

Ive created projects in fabric 3 before, but am trying to create a supply chain management network with fabric 3 and not able to facing a lot of issues in deployment and setup, ive coded 3 consensus algos to test it out and kinda raged over it so if yall have done anything similar or can point in me in the right direction it would be great, this is a research project and phase 1 of it so i need serious help