---

description: Hyperledger isn't just one single product; think of it as a handy toolbox. In this guide, we'll dive into when it's best to use Hyperledger Fabric, Besu, FireFly, Cacti, Bevel, and Indy/AnonCreds. We’ll explore what each of these tools does best in 2025, how they're changing over time, and how you can leverage them for real-world production value with some clear next steps.

Hyperledger Blockchain Development Services: When Are They the Right Fit?

Decision-makers often reach out for a “quick take” on Hyperledger. Here’s the deal: Hyperledger isn’t just one platform or a single bet. It’s actually a well-established, modular collection of open-source projects that you can mix and match. Think of Fabric for sharing data securely, Besu for EVM networks, FireFly for orchestrating apps, Bevel for DevOps, Cacti for cross-chain solutions, and Indy/AnonCreds when you need to keep identities private. When you use these in the right combos, you can cut down the time it takes to add value from months to just weeks, all while keeping those important enterprise guardrails in place.

Check out our handy field guide from 7Block Labs below. It’ll help you figure out which project to use when, especially in late 2025, along with specific features, some up-and-coming practices, and practical implementation details you can put to work.

---

TL;DR: When Hyperledger makes sense

Choose Hyperledger if you need:

• Enterprise Solutions: If you’re looking to build blockchain applications for businesses, Hyperledger’s got your back. It’s designed specifically for enterprise needs.
• Privacy and Confidentiality: Hyperledger allows you to keep things under wraps. You can control who gets to see what, which is a big deal for companies handling sensitive info.
• Performance and Scalability: Need something that can handle a lot of transactions? Hyperledger is built to scale, so it can manage high volumes without breaking a sweat.
• Modular Architecture: Want the freedom to choose components? Hyperledger’s modular design lets you mix and match features according to your project’s requirements.
• Blockchain Flexibility: Whether you're into permissioned networks or want to explore different consensus mechanisms, Hyperledger offers the flexibility to tailor blockchain solutions to fit your specific needs.
• Strong Community Support: With an active and engaged community, you’ll find plenty of resources and support to help you navigate your Hyperledger journey.
• Interoperability: If you need to connect with multiple blockchain networks, Hyperledger aims for seamless integration, helping different systems work together smoothly.
• Open Source: It’s free to use and you can customize it as needed. Plus, being open-source means you're tapping into a wealth of community-driven innovation.

For more information, check out the official Hyperledger website.

• Teaming up with multiple parties while keeping privacy and governance in check (think Fabric PDCs, organization-specific data, and channel-level controls). Check it out here.
• Enjoying EVM compatibility without the risks of a public chain, plus you can always bridge to public Ethereum later on (we're talking Besu with QBFT/IBFT2, permissioning, and privacy). More info here.
• Get to your business features faster (like tokens, off-chain data, and eventing) with a nifty “supernode” middleware instead of starting from square one (FireFly). Dive deeper here.
• Enjoy cross-ledger workflows (like swapping assets or sharing data between Fabric and Besu) without needing a third-party settlement chain (thanks, Cacti!). Learn more here.
• Embrace K8s-first DevOps/IaC for your ongoing operations across different vendors and clouds (hello, Bevel!). Find out more here.
• Validate digital identities while safeguarding user privacy (thanks to Indy/AnonCreds, with exciting work happening on v2, including BBS signatures). Check it out here.

If you're all about open DeFi composability, enjoying fully permissionless participation, or diving into some speculation-driven liquidity, it's best to kick things off on public chains and EVM L2s. Don't worry if you want to anchor or interoperate down the line - you can always use Besu and Cacti for that.

---

What’s new and why it matters (2025 snapshot)

• Hyperledger Fabric 3.1 is now stable, and it's rocking SmartBFT for BFT ordering along with some cool performance enhancements like batched chaincode writes. Meanwhile, v2.5 is still holding down the fort as the LTS version with regular updates. Notable changes in governance and operations include support for Ed25519 and some deprecations in the gossip protocol. Check it out here.
• Besu is keeping up with Ethereum’s roadmap and is enhancing its private-network features--QBFT is now the go-to for enterprise use. It also received updates for permissioning and syncing, plus some performance tweaks. They’ve been running history-expiry work on Sepolia that should roll out in 2025. Dive deeper here.
• FireFly 1.4.0 just dropped a Cardano connector and is really tightening up its token, data, and event abstractions across EVM and Fabric. Want more details? Head over here.
• Bevel has released v1.3.0 as of April 2025, which brought some neat improvements in logging and diagnostics. They’re also working hard to standardize the deployment paths for Fabric 3.0 with charts and playbooks. For all the updates, check this link here.
• Cacti is making strides with advanced connectors and SATP workstreams, with alpha releases expected between 2024 and 2025. They’re streamlining the Cactus and Weaver projects into a cleaner, security-focused codebase. Get the latest info here.
• The Aries projects have transitioned over to the OpenWallet Foundation, while Indy is still stable. AnonCreds v2, including BBS, is in active development--this is especially handy for privacy-preserving credentials in regulated industries. Check out the details here.

---

Choosing the right Hyperledger building blocks

1) Hyperledger Fabric: Permissioned data sharing at enterprise scale

Use Fabric when you’ve got several organizations needing to write to a shared ledger but still want to keep some data under wraps. By 2025, certain features will really make you lean towards choosing Fabric:

• Private Data Collections (PDCs) allow groups of organizations to share encrypted data that gets validated across the entire network using on-chain hashes--so no need for separate channels! You can easily query using ranges, partial composite keys, and even rich JSON queries with CouchDB. Plus, if you need to clean things up, you can purge by blockToLive. (hyperledger-fabric.readthedocs.io)
• With SmartBFT ordering (v3), you can handle Byzantine behavior smoothly, needing just 3f+1 orderers to brave through f faults. It’s a good idea to plan for at least 4 nodes, but for solid production resilience, aim for 7 or more. Just know that you might face higher bandwidth and latency compared to Raft. (lfdecentralizedtrust.org)
• Performance is getting a nice boost: v3.1 introduces batched writes and batched reads (GetMultipleKeys) for chaincode that processes multiple keys--this is a game changer for those high-fanout updates. (github.com)
• On the governance and crypto front, Ed25519 support and updates around gossip block dissemination are here to make operations smoother and keep your crypto choices future-ready. (github.com)
• HSM integration is now available through PKCS#11 for peers/orderers and CA flows (use SoftHSM for testing; stick with vendor HSMs for FIPS compliance). (hyperledger-fabric.readthedocs.io)
• As for long-term support (LTS), 2.5 is the current version you want to stick with; keep in mind that 2.2 has been retired by major vendors--so plan your upgrades accordingly. (lf-decentralized-trust.github.io)

When Not to Choose Fabric

If you’re looking for EVM bytecode, Solidity tooling, or need public-chain composability right from the start, Fabric might not be your best bet. Instead, consider using Besu (see below) and you can always incorporate Fabric later on if your projects require highly private workflows.

Walmart's food traceability is powered by Fabric through IBM Food Trust, allowing them to perform tracebacks in just seconds and expand to various product lines--solid proof of how complex retail supply chains can be. (lfdecentralizedtrust.org)

Implementation notes we apply in projects:

• Clear Objectives: It's super important to set clear goals from the get-go. Knowing what we want to achieve helps keep everyone on the same page.
• Agile Methodology: We like to work in short sprints so we can adapt to changes quickly. It keeps the project fresh and on track!
• Regular Check-ins: Team meetings happen frequently to ensure everyone is aligned and any roadblocks can be tackled together.
• Feedback Loops: We actively seek feedback from both the team and stakeholders, helping us to refine our approach and improve continuously.
• Documentation: Keeping everything documented is key! It makes onboarding new team members and revisiting projects down the line a lot easier.
• Testing: We put a strong emphasis on testing throughout the development process. Catching bugs early saves time and headaches later.
• Collaboration Tools: Tools like Trello and Slack help us stay organized and communicate effectively, no matter where we're working from.
• Post-Mortem Reviews: After project completion, we do a quick review of what went well and what could be improved. This helps us learn and grow for future projects!
• Celebrate Wins: Don’t forget to take a moment to celebrate successes, big or small! It boosts team morale and keeps the vibe positive.
• Topology: When it comes to SmartBFT orderers, aim for a setup with 7 nodes spread across 3 or more organizations. For a Raft configuration, 5 nodes across 3 organizations is usually a solid starting point. Don’t forget to tweak block size and batch timeout based on your peak TPS and latency service level objectives (SLOs). Check out more details here.
• Chaincode: If you’re handling high-write workloads, make sure to use the v3.1 batch write APIs and stick to composite keys. Don’t skimp on adding CouchDB indexes (META-INF) for those heavy query paths. You can find more info here.
• Privacy: It’s a good idea to go for explicit Private Data Collections (PDCs) when you have clearly defined data sharing needs. For simpler per-organization state, using implicit organization collections works well. Also, set blockToLive for right-to-be-forgotten patterns and keep your archives off-chain. Dive into the details here.

Emerging Research Worth Watching

There’s some exciting new research on DAG-aware execution and cross-shard concurrency that's turning heads. It shows some impressive gains in throughput and introduces new fairness mitigations. This info could really help with your roadmap planning, even if it hasn't made its way upstream just yet. Check it out here: (arxiv.org)

---

2) Hyperledger Besu: Enterprise EVM for private and public touchpoints

Pick Besu When You Want:

If you're diving into the world of Ethereum clients, Besu is a solid choice for various reasons. Here’s a quick rundown of when and why you might want to go with Besu:

Reasons to Choose Besu

• Permissioned and Permissionless Networks: Besu supports both types of networks, giving you flexibility in your blockchain projects.
• Enterprise-Centric Features: If you're working in a big organization, Besu has features tailored for enterprise needs, like privacy and permissioning.
• Integration with Web3: It works seamlessly with Web3 technologies, making it easy to build decentralized applications.
• Java-Based: Built on Java, it’s a great fit if you're already into the Java ecosystem or have a team skilled in it.
• Robust Performance: Besu is designed to handle high transaction throughput, which is crucial for business applications.

When to Consider Besu

• Enterprise Solutions: If you’re part of a company that needs a reliable Ethereum client, Besu’s enterprise features make it a standout option.
• Private Networks: For projects needing a private network, Besu offers excellent support, allowing for easy configuration and management.
• Developer Support: If you or your team are more comfortable with Java, you’ll likely find Besu easier to work with compared to clients based on other languages.
• Community and Documentation: With a helpful community and solid documentation, getting started with Besu is straightforward.

So, if any of this resonates with your project goals, give Besu a shot!

• Enjoy EVM compatibility on private networks using enterprise-grade PoA, with QBFT as a solid recommendation and quick finality. Check it out here.
• Get into production permissioning with easy node and account allowlists (and yes, there's DNS support for K8s!) plus live updates via JSON-RPC. More details are available here.
• Experience seamless forks alongside evolving Ethereum standards, plus ongoing enhancements in performance and syncing (like the pre-merge history expiry testing planned for 2025). Dive into the updates here.

Implementation Notes We Apply:

• Keep It Simple: Always aim for simplicity in your code. It not only makes life easier for you now but also for anyone who might work on it later.
• Documentation is Key: Make sure to document your processes clearly. Whether it's in-line comments or a separate README, good documentation saves everyone time and headache down the road.
• Consistent Naming Conventions: Stick to a naming style across your project. This helps maintain clarity and makes it easier to navigate through the code.
• Test Thoroughly: Don’t skip the testing phase! Regularly run unit tests and integration tests. It's better to catch issues early rather than later.
• Version Control: Use version control actively. Not only does it help in tracking changes, but it also simplifies collaboration.
• Stay Up-to-Date: Keep an eye on the latest updates and best practices in your tech stack. Staying current helps you leverage new features and optimizations.
• Code Reviews: Make code reviews a habit. They are a great way to learn and ensure quality in your codebase.
• Manage Dependencies: Be cautious with third-party libraries. Regularly review and update them to minimize security vulnerabilities.
• Performance Matters: Always consider the performance of your code. Optimize where necessary but don’t sacrifice readability for minor gains.
• Backup Regularly: Ensure you have regular backups of your data and code. This will save you from potential disasters.

Remember, these tips aren’t just about getting the job done; they’re about making your coding journey easier and more enjoyable!

• Consensus: Stick with QBFT as the default. Set your requestTimeoutseconds to about 2 times the blockperiodseconds. Make sure to keep an eye on any round changes and track those signer metrics. (besu.hyperledger.org)
• Bootstrap: Grab the Quorum Genesis Tool to lay out your genesis settings, validator keys, gas limits, and epoch lengths. Don't forget to version it along with your infrastructure code. (github.com)
• Governance: It's a good idea to standardize the permissions_config.toml file across all members. Make sure to safely expose the PERM APIs for onboarding and offboarding organizations. (besu.hyperledger.org)

When Not to Pick Besu

If you’re looking for sub-ledger privacy that’s specifically linked to certain counterparties and auditors for each transaction--without having to duplicate networks--then you might want to steer clear of Besu. In that case, Fabric’s PDC model offers a bit more muscle.

If you do find yourself needing a mix of both, consider pairing Besu (great for EVM/token flows) with Fabric (perfect for private state). That combo can give you the best of both worlds!

---

3) Hyperledger FireFly: Ship features faster (tokens, events, data)

FireFly is a cool “supernode” that takes care of multiparty app patterns like message pinning, tokenization (ERC-20/721/1155), file exchange, and syncing between off-chain and on-chain. It also handles contract listeners, wrapping up Fabric and EVM backends into a smooth, consistent API. Recently, they rolled out some updates that introduced a Cardano connector and enhanced their token and connector frameworks. You can check out all the details here.

Why This Matters:

This is important because it impacts a lot of people. Understanding the reasons behind it helps us see the bigger picture and make informed decisions. Whether it’s about health, technology, or social issues, staying in the loop is crucial. Ignorance can lead to misunderstandings, missed opportunities, and even adverse effects on our lives.

• Awareness: Knowing the facts can help us navigate conversations and debates more effectively.
• Impact: The outcomes can directly affect our communities and future generations.
• Action: Recognizing its significance empowers us to take steps that can lead to positive change.

So, let’s dive in and explore why this really matters!

• Cuts down on build time for apps that blend data, assets, and events from different organizations.
• Offers you ERC‑1155 multi‑asset flows or ERC‑20/721 with very little extra code needed. (hyperledger.github.io)
• Plays nice with Besu/Quorum through ethconnect and with Fabric using fabconnect--so you can easily switch chains without having to rewrite your business logic. (github.com)

When FireFly is a Good Match

FireFly really shines in situations like these:

• When you need MVPs that can breeze through security reviews in no time.
• For projects that require smooth token flows.
• When you want dependable eventing and features like “private messages + on-chain proofs” right off the bat.

---

4) Hyperledger Cacti: Interoperate without a third‑party chain

Use Cacti when you need cross‑network operations:

Cacti is your go-to tool for handling cross-network tasks. Here’s why you might want to consider it:

• Data Visualization: Cacti lets you create stunning graphs to visualize data over time. This makes it super easy to spot trends and anomalies in your network traffic.
• Multiple Data Sources: Connect to different data sources, whether it’s SNMP, scripts, or even databases. Cacti's flexibility allows you to gather data from various points across your network.
• User-Friendly Interface: The interface is pretty intuitive, which means you can get started without feeling overwhelmed. You can quickly navigate through options and set up your monitoring in no time.
• Active Community: Since Cacti is widely used, there’s a vibrant community. This means you can find tons of resources, plugins, and help whenever you need it.

So, if you’re managing multiple networks and need a reliable way to monitor them all, give Cacti a shot!

• We're talking about asset exchanges and transfers using HTLCs for ETH/ERC-20, sharing ledger data, and decoupling identities--all without having to mess with the underlying DLTs. Right now, we've got connectors for Fabric and Besu, and there's some active cleanup going on along with the SATP/Hermes initiatives. Check it out here: (hyperledger-cacti.github.io)

Our Favorite Pattern:

• Make sure to keep your assets on their original chains (like invoices or SKUs as mentioned by Fabric; and settlement tokens on the Besu network).
• Coordinate atomic swaps or verified reads through Cacti relays/connectors, with audit trails recorded on both sides. Check out more at (hyperledger-cacti.github.io).

---

5) Hyperledger Bevel: GitOps/K8s for day‑2 reliability

Bevel offers some pretty handy Helm charts and Ansible playbooks that can help you deploy and manage Fabric, Besu, Quorum, and a bunch of other tools across different cloud environments. The latest version, v1.3.0 (released in April 2025), has made some cool upgrades to logging and diagnostics, and they're also gearing up for the rollout of Fabric 3.0. This is a solid choice if you're looking for a way to automate your infrastructure in a repeatable, vendor-neutral way. Check it out here: (lf-decentralized-trust.github.io)

---

6) Indy/AnonCreds (and the Aries transition): Privacy‑preserving identity

• Indy is a solid choice for a reliable verifiable data registry with some nifty security upgrades happening all the time. It’s perfect for those long-lasting DID networks. Check it out here.
• The work on AnonCreds v2 is pretty exciting! It brings in pluggable signature schemes (PS/BBS), which means you can have unlinkable proofs and scalable revocation--so it’s right in line with today’s VC ecosystems. For more info, click this link.
• Some Aries subprojects, like ACA-Py and Credo, have found a new home at the OpenWallet Foundation in 2025. But don’t worry, you can still integrate with them using SDKs and plugins (like the Hedera plugin for ACA-Py). Just make sure to factor this into your roadmaps! More details can be found here.

Go for this stack when you need KYC or credentials while keeping privacy in check (like ensuring someone’s age or managing role-based access) and you’re looking for wallet/app interoperability.

---

A practical decision framework (no fluff)

• Go for Fabric if:
  • Your data is the main product, like in supply chain, compliance, or multiparty operations.
  • You’re looking for privacy and audit trails that are selective to counterparty (think PDCs with blockToLive).
  • Governance feels like a tough nut to crack (we’re talking multi-org endorsements and channel ACLs).
• Choose Besu if:
  • You’re wanting to leverage Solidity tooling and EVM compatibility within a permissioned environment.
  • There's a chance you might want to anchor or bridge to public Ethereum down the line.
  • You need some token logic and smart contract ecosystems straight out of the box.
• Think about FireFly if:
  • You want to quickly deliver tokens, data, or events, with solid APIs and webhooks to back you up.
• Check out Cacti if:
  • You need to cross ledgers (like Fabric↔Besu) without having to build a custom bridge from scratch.
• Opt for Bevel if:
  • You’re after repeatable, auditable, multi-cloud infrastructure as code for those day-2 operations.
• Consider Indy/AnonCreds if:
  • You’re in need of privacy-preserving credentials that allow for verifiable presentations.

---

Two concrete solution patterns with 2025 specifics

1) Regulated Supply Chain (Retail/Food, Pharma Cold-Chain)

• Ledger: We're using Fabric 3.1 paired with SmartBFT, which includes 7 orderers and 3 organizations. For state management, CouchDB is in the mix, and we're incorporating HSM via PKCS#11 for both our peers and orderers. You can check out more details here.
• App Layer: We're leveraging FireFly for messaging, like Certificates of Analysis (COAs) and shipping documents. Plus, we’re implementing tokenized batch IDs (think ERC-1155) for when we start bridging to EVM. Event listeners will help us stay on top of recalls. More about that can be found here.
• Privacy: To keep things secure, we’ve got Private Data Collections (PDCs) that help us separate supplier pricing from retailer operations. We also have a system to purge outdated sensitive data using blockToLive. Learn more about it here.
• Reference Impact: Walmart’s production deployment demonstrates tracebacks in just seconds and showcases scalability across different product lines, which really aligns with the architecture we’ve set up. For more insights, check out this case study.

2) Financial Ops and Settlement (Consortium Treasury, Loyalty, Trade Assets)

• Ledgers: We’re using Fabric for our private reference data and approvals, while Besu (QBFT) handles on-chain settlement tokens and programmable payouts. You can check out more about it here.
• Interop: Cacti is our go-to for atomic swaps and verified reads, making it easy to confirm things like payment versus delivery. More details can be found here.
• App Layer: We’re using the FireFly tokens API to mint and transfer tokens, packed with data-rich events. Plus, we’ve set up contract listeners for ERP triggers. Dive into the details here.

---

2025 emerging best practices we implement at 7Block Labs

• Fabric SmartBFT sizing: Start off with 7 orderers to hit that f=2 tolerance and give yourself some room for maintenance. It’s a smart move to isolate orderers on separate subnets and throttle gRPC at the edge. Keep in mind, you might see higher latencies compared to Raft; aim for “seconds, not sub-second” finality. (lfdecentralizedtrust.org)
• Chaincode performance: Go with the v3.1 batching (think StartWriteBatch/FinishWriteBatch) and make the most of the new GetMultipleKeys read batching to cut down on the endorsement chatter for key-dense transactions. (github.com)
• Data modeling: Keep your composite keys (type~id) consistent and make sure to index those hotspots. It’s a good idea to keep large payloads off-chain using FireFly’s data exchange, while pinning hashes on-chain. (hyperledger-fabric.readthedocs.io)
• Privacy posture: When it comes to multi-org sharing, it’s best to stick with explicit PDCs; use implicit org collections for secrets specific to each org. Also, don’t forget to codify blockToLive to make sure you’re enforcing data minimization. (hyperledger-fabric.readthedocs.io)
• Besu governance: Make sure to enforce your node/account allowlists; use DNS-aware enode URLs for K8s, and keep an eye on qbft_getSignerMetrics to catch any validator issues before they become a problem. (besu.hyperledger.org)
• Interop “don’t roll your own”: Stick with Cacti’s well-tested connectors for atomic swaps and data sharing rather than creating your own bridges; also, stay updated on SATP changes. (hyperledger-cacti.github.io)
• Delivery velocity with FireFly: View token pools as essential infrastructure; standardize on ERC-1155 for your multi-asset portfolios, and wire up contract listeners to webhook relays for smooth handoffs to downstream systems. (hyperledger.github.io)
• Security toolchain: Make it a point to integrate HSMs through PKCS#11; at both the app layer and connectors, enable CodeQL and SAST--FireFly projects are making the switch to CodeQL and ongoing CVE triage in 2025. (hyperledger-fabric.readthedocs.io)

---

Build/operate plan we typically propose

• Discovery (2-3 weeks)
  • Let's kick things off by assessing the fit between Fabric, Besu, and a hybrid approach. We’ll also need to create a privacy map for PDC candidates, check out the interop scope with Cacti, and understand the app needs through FireFly.
  • We should tie our throughput and latency service-level objectives (SLOs) to key business events like recalls, payouts, and onboarding.
• Architecture and Landing Zone (2-4 weeks)
  • Time to set up our Kubernetes (K8s) baseline, package Bevel, and establish our Infrastructure as Code (IaC) repositories. We'll figure out the orderer/peer topology, whether we go with SmartBFT or Raft, and set up a Besu QBFT cluster if it's necessary. Check out more details here.
• MVP (6-10 weeks)
  • Now, let’s focus on developing our chaincode and contracts with batch APIs in Fabric 3.1. If it makes sense, we’ll also look into ERC‑1155 pools, set up FireFly, and design Cacti flows for cross-ledger operations.
• Hardening & Scale (4-6 weeks)
  • It’s time to integrate HSM, create our permissioning and rotation runbooks, and run performance tests to simulate peak loads. Plus, we’ll set up dashboards to keep an eye on signer metrics and the gossip/delivery queues. For more info on HSM integration, check out the documentation here.

Deliverables

• Threat Model
• Governance Policy Templates
• Ops Runbooks
• Infrastructure as Code (IaC)
• SLO Dashboards
• Go/Node/Java Client SDKs (Fabric Gateway) featuring zero-trust patterns. Check it out on GitHub!

---

Managed services: when to consider them

If you're looking to lower your infrastructure overhead, managed Fabric options are a great choice--like AMB for Hyperledger Fabric, which comes with clear pricing and GovCloud support. Just keep in mind, there’s a bit of a trade-off between how quickly you can roll out new features versus the flexibility of your deployment options (like moving up to Fabric 3.x). We usually start by prototyping on AMB for speed and then transition to Bevel-driven K8s when we need full control. (aws.amazon.com)

---

Anti‑patterns (hard‑earned)

• If you decide to use Besu just to mimic Fabric-style private data, be ready to reinvent those PDC-like policies in Solidity. It’s not going to be a walk in the park!
• When you’re setting up Fabric 2.2 fresh in 2025, keep in mind that upgrade budgets can spiral out of control later on. It might be smarter to kick things off with 2.5 LTS or 3.x, especially if SmartBFT is in your plans. Check out more about it here.
• Thinking about rolling your own cross-chain relays? Just a heads up: security reviews and maintenance are going to take a big chunk out of your total cost of ownership. Consider using Cacti to help with that. More info can be found here.

---

RFP checklist (reuse these)

• What data objects need to be kept private for certain members, and for how long should we keep them (blockToLive)?
• Are we looking for BFT fault tolerance (3f+1), or can we get by with just Raft (2f+1)?
• Do we need EVM compatibility right now, or are we just thinking about future anchoring and bridging?
• How will interoperability work across ledgers (think asset swaps versus reading data with proof)?
• What are our HSM requirements and how do we feel about our FIPS posture (PKCS#11)?
• What's our automation target (Bevel/K8s), and what's the plan for upgrading to Fabric 3.x?
• For app-level features like tokens, events, and off-chain file exchange--can FireFly really cover 80% of what we need?

---

Final word

Hyperledger is definitely a solid choice for 2025. With Fabric, you get privacy, governance, and Byzantine Fault Tolerance (BFT) options all in one place. Besu throws in EVM compatibility along with permissioned control, which is super handy. Then there’s FireFly and Cacti, which really help you stitch everything together so you can move quickly and keep things interoperable. Bevel makes sure your systems stay runnable, while Indy and AnonCreds focus on protecting user privacy. If you take these capabilities and align them with your specific collaboration model and control setup, you can significantly reduce risks and start seeing real value in production in no time.

Looking to dive into a 2-hour fit workshop with the awesome architects at 7Block Labs? We've got you covered! We’ll come prepared with a draft topology, a governance model, and a milestone plan specifically designed for your use case.

---

Sources

• Check out the latest on Fabric 3.1! It includes features like SmartBFT and batched reads/writes, plus some important LTS info and deprecations. Dive into the details here.
• If you’re looking for guidance on SmartBFT production sizing, you’ll want to know that 3f+1 is the way to go -- minimum of 4, with 7 being the sweet spot. Get all the specifics right here.
• For those interested in PDC design, queries, reconciliation, and tutorials, you can find a bunch of helpful resources over at Hyperledger's documentation.
• Besu enterprise enthusiasts will love the guidance on QBFT (totally recommended!), along with tips on permissioning APIs and consensus options. Check out the release updates here.
• FireFly keeps improving! The latest version, v1.4.0, brings connectors, tokens APIs, and even a new Cardano connector. See what’s new on GitHub.
• Bevel v1.3.0 is making strides, and there are already plans in the works for Fabric 3.0. Get the scoop on what’s happening here.
• For those following Cacti, check out the latest docs and releases, including HTLCs, Fabric/Besu connectors, and SATP pre-releases. Find more info here.
• Indy/AnonCreds are gearing up for a smoother ride with some stability improvements and the transition of Aries to OpenWallet. Plus, watch for updates on AnonCreds v2 and BBS work - all the details are available here.
• Curious about the Walmart Food Trust case study? It’s a great example of Fabric in action! Check it out here.
• Lastly, for anyone interested in HSM integration via PKCS#11, SoftHSM is available for testing. You can explore that further in the documentation.

---