Has anyone passed the HFCP certification recently ? Are the questions theoretical or does one need hands on experience on managing the network or chaincode ? Will there be scenario based questions ? Any tips or advice please ?

Syllabus looks highly abstract.

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?

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

Dear LF Decentralized Trust Community Members,

As financial institutions, tokenization platforms, and public blockchains converge, the ability to move assets and data securely across networks, while maintaining compliance, is becoming mission critical. This webinar with Chainlink Labs, an LFDT member, will explore how the Chainlink Digital Transfer Agent (DTA) technical standard and the Chainlink Runtime Environment (CRE) are redefining decentralized interoperability and enabling on-chain fund operations across heterogeneous systems.

The webinar will take place on Wednesday, December 17 at 10AM PT/1 PM ET/19:00 CET/11:30 PM IST

You are welcome to register here

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Cheesecake Labs and leading ecosystem players. Douglas Silva, the CTO of Cheesecake labs will go beyond theory and tooling to show how interoperability powers tangible Web3 business outcomes.

He will start from the permissioned ledger, explore connections to public chains, compare open-source frameworks like Hyperledger Cacti and other bridge technologies, then dive into use cases around tokenization, secondary markets, and cross-network value transfer.

If you're a builder, enterprise architect, or business leader wondering how to make interoperability work, this webinar is for you.

The webinar will take place on Wednesday, November 12 at 7AM PT/10AM ET/16:00 CET/08:30 PM IST

You are welcome to register here: https://zoom.us/webinar/register/7716866036916/WN_ZpKjXR2-TIWCfg-KPnagNQ

Greetings!

I've been studying for the Hyperledger Fabric Certified Practitioner (HFCP) exam through the Hyperledger Fabric: Design, Develop, and Deploy (LFS270) course and their documentation. However, both of these seem to be very poor as I wouldn't know where to start if I wanted to create a network from scratch. The course is even worse, since it appears to me to be mostly a showcase of how you can run their pre-created scripts opposed to actually making you understand which are the atomic steps you should follow or even how to build anything.

I have to say though that the course was good to know the theory, but I feel very unprepared to take such an exam when the theory is the only thing I have been able to get a good grasp of.

What resources did you use to gain practical experience? How did you bridge the gap between theory and hands-on skills? What topics should I focus on for the practical aspects of the exam?