Corda for digital assets lifecycle management: Designing issuance-to-settlement workflows

Speeding Up Digital Assets in Regulated Markets

When it comes to digital assets, speed is everything--especially in markets that have a lot of regulations. In this post, we’re going to explore how to make the process of issuing and settling smoother with Corda 5. We’ll discuss some architecture choices, flow designs, plus share some handy configuration snippets and key metrics from actual production deployments. So, let’s jump right in!

Description

A Practical Guide to Digital Assets on Corda 5

Ready to jump into the exciting world of digital assets using Corda 5? This guide is designed to help you navigate through the ins and outs of modeling, issuing, and settling these assets. We’ll explore important topics like application networks, notaries, DvP (Delivery versus Payment) patterns, and different cash integration options. To make everything more relatable, we’ll also share some operational metrics and real-world examples from DTCC, SDX, and HQLAx. Let’s get started!

---

Why Corda for digital assets lifecycle management in 2025

If you're aiming to create high-quality issuance and settlement systems, Corda has proven itself by successfully managing major Financial Market Infrastructures (FMIs) in real-world scenarios:

• DTCC’s Project Ion is a real game-changer, managing more than 100,000 equity transactions daily in a slick parallel production DLT setup. They’ve chosen R3’s Corda as their backbone tech, ready to back netted T+0 transactions along with T+1 and T+2 cycles. You can take a closer look here.
• At SIX Digital Exchange (SDX), they’re really making waves with digital bonds. They've rolled out a seamless system for issuing, holding, and settling on Corda. Looking ahead to 2025, they plan to bring digital bond trading right into the main SIX Swiss Exchange, while still keeping the issuance and settlement on their SDX CSD platform. Want to know more? Check it out here.
• HQLAx has created an impressive live collateral mobility platform that utilizes R3 Corda and Deutsche Börse technology. They've already stirred up the scene by running successful blockchain-based securities lending and cross-chain repo pilots. If you’re curious to dive deeper, check it out here.

Corda 5 is exciting news for developers because it really aligns with the ins and outs of regulated markets. We're looking at features like standard REST APIs, HTTP P2P, role-based membership governance, and adaptable notary/ledger components--all designed with privacy, performance, and operational needs in mind. You can explore more about it here: (r3.com)

---

Architecture foundations you must get right (Corda 5)

Before you jump into modeling bonds or fund shares, it’s super important to get your platform choices sorted out. This will really set you up for success!

1) Application networks and the MGM

• Corda 5 has a cool way of organizing participation through application networks, all overseen by what’s called a Membership Group Manager (MGM). This MGM is like the gatekeeper--handling everything from bringing new members on board to sharing network data and ensuring that everyone sticks to the rules using REST. On top of that, the same cluster can host multiple virtual nodes, which means you get some awesome separation and selective interoperability across different app networks. If you want to learn more about this, check it out here.
• So, let’s chat about membership processing. This is where the "membership worker" really shines. Network operators can choose to have manual approvals in place, set up pre-authentication tokens (you know, with TTL and X.500 binding checks), and even require manual reviews for certain context changes. This is super useful for things like KYC/AML or handling role-based access. If you want to dive deeper, you can check out the docs here.

Here's a useful operational detail for you:

• When you go to register an MGM, the system is set up to ensure that the session key and the ledger key are different. This rule is backed by corda.group.key.session.policy=Distinct. For all the nitty-gritty details, take a look at the docs here.

Example: Registering an MGM (Excerpt)

When you're ready to register an MGM (Minority Growth Management), there are a few essential steps you’ll want to keep in mind to ensure things run without a hitch. Here’s a simple guide to help you out:

1. Gather Your Documents
   • Start by rounding up all the important paperwork you’ll need. Here’s a quick list to get you started:
     • Business licenses
     • Tax identification numbers
     • Personal identification
2. Choose Your Structure
   • Take a moment to consider how you want to organize your MGM. Some popular options include:
     • LLC (Limited Liability Company)
     • Corporation
     • Partnership
3. Complete the Application
   • Go ahead and fill out the registration form. Just take a moment to double-check everything for accuracy--no one wants to deal with a paperwork mistake!
4. Submit Your Application
   • Make sure to send it to the right state or federal agency. And don’t forget to keep a copy for your records--you’ll want that proof of submission just in case!
5. Pay the Fees
   • Just a heads up, there could be some registration fees to consider, depending on where you’re setting up your MGM.
6. Wait for Approval
   • Once you’ve sent everything off, just hang tight for a bit. Keep in mind that getting approved can take a little while, so a little patience goes a long way!

Check out the official guidelines right here: MGM Registration Guidelines.

After you've wrapped up all these steps, you're all set to kickstart your MGM!

REGISTRATION_REQUEST='{"memberRegistrationRequest":{"context": '$REGISTRATION_CONTEXT'}}'
curl -k -u $REST_API_USER:$REST_API_PASSWORD -d "$REGISTRATION_REQUEST" \
  $REST_API_URL/membership/$MGM_HOLDING_ID
# REGISTRATION_CONTEXT includes "corda.group.key.session.policy":"Distinct"

(docs.r3.com)

2) Virtual nodes, packaging, and REST

• With Corda 5, there's this awesome feature called “virtual nodes.” Think of them as your execution contexts that are neatly separated from the cluster workers. You can access everything through a consistent REST interface, which makes it easy to write clients in almost any language and manage everything with the tools you already use. You can dive deeper into it here: (r3.com).
• On the packaging front, we're working with CPB/CPI. The MGM generates a GroupPolicy.json, allowing you to bundle your CPB with the GroupPolicy into a CPI. After that, it's a breeze to upload or upgrade via REST endpoints. This setup really shines when you're rolling out updates in a controlled way during those hectic issuance seasons. Want to know more? Check it out here: (docs.r3.com).

Quick Reference:

Here’s a helpful guide to make your navigation a breeze!

Key Sections:

• Getting Started: Here’s a quick rundown on how to jump right in.
• Features: Check out all the awesome things you can do with this.
• Troubleshooting: A list of common hiccups and how to sort them out.
• FAQs: Got questions? We’ve got answers!

Important Links:

• Check out the Official Documentation
• Join the conversation over at the Support Forum
• Explore the User Guide for more details

Tips:

1. If you need a hand, don’t be shy--everyone’s here to help each other out!
2. Make sure to keep your software up to date for the smoothest experience.
3. Go ahead and bookmark those key pages so you can find them easily down the road.

Contact Us:

Got questions or feedback? Don’t hesitate to reach out to us at support@example.com. We really enjoy hearing from you!

# Access REST locally via kubectl
kubectl port-forward -n <NAMESPACE> deploy/corda-rest-worker 8888
# Base path typically:
https://localhost:8888/api/v5_2

(docs.r3.com)

3) Notary design (uniqueness and time)

• Notaries are super important for stopping double spending and they act like time-stamping authorities. Corda versions 5.1 and 5.2 come with a cool non-validating notary protocol that only takes what it needs--think inputs by reference, output counts, and time windows--all while keeping things private. If you're curious about the specifics, you can find them here.
• Notaries operate in groups (you can think of them as service identities), and you can swap them in and out based on different protocols. Each state gets to choose its own notary, and it's pretty simple to rotate them through specific flows. If you want to dive deeper, check out the details here.

Check out these Protocol IDs you’ll need for the setup:

• "corda.notary.service.flow.protocol.name": "com.r3.corda.notary.plugin.nonvalidating"
• "corda.notary.service.flow.protocol.version.0": "1" (docs.r3.com)

---

Modeling the asset lifecycle: from term sheet to redemption

Design Your States, Contracts, and Flows to Naturally Encode the Lifecycle

Creating states, contracts, and flows that mirror the lifecycle isn't just smart--it's a game changer for making development a breeze. Check out these handy tips to help you get it right:

Understand the Lifecycle

First things first, get comfy with the lifecycle of what you're creating. Doesn’t matter if it’s an app, a project, or a whole system--understanding how it should flow from beginning to end is super important.

States Matter

Consider all the different stages your project can go through. For instance:

• Draft: It's still in the works.
• Review: Time to gather feedback and make some adjustments.
• Published: Now it’s out there for everyone to check out.
• Archived: Not active anymore, but we’ve kept it for reference.

These states should connect naturally, helping you make transitions feel seamless.

Contracts for Clarity

Contracts are basically the playbook for your states and flows. They should lay out how all the different pieces of your system work together. Here are a few key points to remember:

• List out what each state needs.
• Clarify what we expect to happen when states change.
• Make sure everyone involved understands and agrees on these points.

Flows Should Be Intuitive

When you're dealing with flows, keep it simple. You want your users (or team members) to move through the lifecycle without feeling confused. Make sure to think about these points:

• Let’s make things a bit clearer with some visual representations to map out the flows. Diagrams are a great way for everyone to see the process at a glance.
• Ensure that transitions are super easy to follow. Consider how one state flows into the next, and set up clear paths for guidance.
• Don’t forget to include feedback loops! They’re really important for keeping the process on a path of continuous improvement.

Keep it Flexible

Lastly, remember that staying flexible is super important. As your project grows and changes, your states, contracts, and workflows might need a little tweaking too. So, don't hesitate to go back and update these parts to make sure they align with the project's lifecycle.

By thoughtfully crafting states, contracts, and flows that reflect the lifecycle, you'll boost clarity and efficiency while laying a solid groundwork for your project's success. Happy designing!

• When dealing with asset line items, make sure to choose a primary state, like BondState. This should cover details like ISIN, series, currency, nominal, and coupon schedule.
• To keep things organized, manage the system using participants and signers. For any static data--think issuer KYC proof, eligibility rules, and term sheet hashes--it's a good idea to use reference states. This helps us steer clear of unnecessary state changes. If you need more info on this, check out the docs.r3.com.
• Use encumbrances and time windows to make sure everything runs smoothly, like enforcing DvP conditions and lockups. Corda 5 makes this super easy with built-in support for encumbrance groups in the UTXO builder. For all the details, head over to the docs.r3.com.

Minimal Issuance State Skeleton (Kotlin-like)

Here’s a really straightforward layout for a minimal issuance state that you can kick off with. If you’re already into Kotlin syntax, you’ll find this pretty easy to get the hang of.

data class IssuanceState(
    val id: String,
    val amount: Amount,
    val issuer: Party,
    val recipient: Party,
    val status: IssuanceStatus
)

enum class IssuanceStatus {
    PENDING,
    COMPLETED,
    REJECTED
}

data class Amount(
    val quantity: Double,
    val currency: String
)

data class Party(
    val name: String,
    val address: String
)

Breakdown of Components

• IssuanceState: This is our primary data class where all the issuance details hang out.
  • id: A unique ID for each issuance.
  • amount: This shows how much of the asset is being issued.
  • issuer: The party that's behind the issuance of the asset.
  • recipient: The one who's actually getting it.
  • status: It reflects the current state of the issuance, which can be pending, completed, or rejected.
• IssuanceStatus: This is an enum that conveniently categorizes the possible statuses of an issuance.
• Amount: This is a straightforward data class designed to manage both the quantity and the currency for the issuance.
• Party: This refers to anyone involved in the transaction, whether it's the issuer or the recipient. Each party has a name and address associated with them.

Absolutely, don't hesitate to adjust this layout to suit your project's vibe!

@BelongsToContract(BondContract::class)
data class BondState(
  val isin: String,
  val series: String,
  val currency: String,
  val denomination: Long,
  val outstanding: Long,
  val issuer: MemberX500Name,
  val registrar: MemberX500Name,
  val owners: List<MemberX500Name>, // or a fungible records model
  val termsRef: StateRef,           // reference state to a TermsState
  override val participants: List<MemberX500Name>
) : ContractState

Contract checks should include the following:

• On issuance: Double-check that the total allocated matches what’s been authorized. Don’t forget, the registrar’s signature is crucial here. Also, make sure to stick to the time frame linked to the offer period.
• On transfer: The encumbrance group needs to ensure everything lines up perfectly with the cash leg at the same time.
• On coupon/redemption: Be sure to check in with the state for the schedule. A registrar’s signature is a must-have, and make sure those amounts match up with what’s outstanding.

---

Primary issuance workflow you can actually run

1. Set up the issuer, registrar, and dealer according to MGM's policies (just a heads up, dealer roles need to get manual approval).
2. Create a TermsState that acts as a handy reference (make sure to include a hash of the legal term sheet, relevant dates, day count, and any events).
3. Dealers will enter their allocations, and then the registrar will go ahead and mint BondState outputs for each investor.
4. Investors will give their thumbs up on the allocation acceptance; all transactions will get wrapped up and notarized during the issuance window.

Hardening Tips:

• To control who can suggest new issuances, implement RBAC in the REST layer. It’s important to verify member roles programmatically using MemberLookup in your workflows. For all the specifics, take a look here.
• Don’t forget to version your TermsState and pin its StateRef in every issuance transaction. This approach helps keep your audits consistent and trustworthy.

---

Settlement design patterns on Corda: three viable DvP options

Design the Cash Leg Early

When it comes to setting up the cash leg, institutions usually go for one of three popular patterns:

Pattern A: Same-network on-ledger cash (fully atomic)

• Think of cash as interchangeable pieces within the same app network. When you’re working with Corda 5, you'll want to kick things off by creating a CashState that utilizes a Token Selection observer to choose which cash to spend. Once that’s sorted out, you can set up an encumbrance group that brings together both the asset transfer and the cash payment outputs. This approach makes sure everything is neatly tied together in one transaction notarization, which guarantees atomicity. For more insights, take a look at the Corda documentation.

Token Selection You’ll Use:

• The Token Selection API lets you lock in a specific group of fungible states until everything’s set in stone. This way, you can avoid those pesky double-selection issues that might pop up when multiple actions are happening all at once. If you’re looking to adjust how the database handles paging, take a look at the corda.ledger.utxo.tokens.cachedTokenPageSize setting. For more info, check out the R3 documentation.

Pattern B: Cross-network DvP with enterprise digital cash rails

• Connect with wholesale payment systems like the Fnality Payment System or check out those neat wCBDC prototypes. Also, let’s make those trust-minimized atomic swaps happen between Corda and EVM networks using the latest interop patterns from Hyperledger Lab Harmonia. This approach ensures we have regulated interoperability and keeps everything above board with proof-of-action verification across various ledgers. (r3.com)

What to Keep in Mind:

• Over on the Corda side, they're holding onto the asset state until they receive a “cash paid” confirmation from the cash network.
• Harmonia is diving into this ongoing debate about whether to use cryptographically verifiable messages or go with “local informant” patterns for cross-ledger proofs. It’s all about picking the option that fits your risk model and meets your regulators' expectations. If you want to explore this topic further, check it out here.

Pattern C: Delivery-versus-Payment with external fiat rails (bank RTGS, ACH, SWIFT)

• Go with a “cash claim” state paired with an off-ledger payment reference, and then finalize it through reference-state updates once you receive that confirmation (either from custody or the CSD). It might not be perfectly atomic across all systems, but you can definitely handle it by using time windows and encumbrances to keep the risk under control.

When to Use Each Pattern

Let’s break it down:

• Pattern A is your best bet for private markets and platforms where you've got control over both sides of the deal.
• Pattern B shines when you're after institutional-grade, real-time DvP across various DLTs.
• Pattern C is perfect for phased migrations, especially if you want to temporarily keep fiat transactions off the ledger.

---

A concrete DvP flow blueprint (encumbrance-based atomic swap)

Goal: Finalize a Secondary Trade Between Dealer and Investor in One Notarized Transaction

1. First up, the dealer starts things off by running SelectCash with the Token Selection API for a specific amount, X, in currency C. In return, they receive some lock claims along with token references. You can dive deeper into that here.
2. Alright, let’s move on to building a transaction:
   • Inputs: We’ll be using the cash tokens from the investor--totaling up to X--and the dealer’s BondState lot.
   • Outputs:
     • The Dealer gets the cash tokens.
     • The Investor receives the BondState.
   • We’ll group both outputs under an encumbrance tag called “dvp-123.” For more info on that, check this out here.
   • And hey, don’t forget to set a time window of 60 to 120 seconds. This helps keep everything running smoothly while we’re waiting for timely notarization. You can find more details about that here.
3. Next up, you’ll need to gather signatures from everyone who's part of this deal--both parties and the registrar if that’s what the contract requires.
4. After you’ve got all the signatures, go ahead and submit the transaction to your selected notary. If everything goes smoothly, both vaults will get a heads-up that the deal is officially sealed.
5. And hey, make sure to let go of any unused token claims (if you've got any) and finish things up with some post-trade events.

Operational Guardrails

• Let’s ensure that flows automatically retry when there’s a bit of temporary notary backpressure.
• If a settlement doesn’t come through within the allotted time, we shouldn’t hold back--let’s fail loudly and go ahead and unlock those token claims.

---

Case-style example: corporate bond issuance to settlement on an SDX-like network

Context: A new CHF digital bond has hit the market! The whole issuance and settlement process is running on a Corda-based Central Securities Depository (CSD), which is pretty similar to what SDX offers. Starting June 1, 2025, you’ll be able to trade it on the main exchange order book, but don’t worry--delivery and asset servicing will still be handled on the Corda network.

• Network setup
  • So, the MGM is managed by the CSD, which pulls together all the important players like the issuer, lead manager, paying agent, and settlement banks. If you want to dive deeper into this, check out sdx.com.
  • We also have a notary cluster set up with a non-validating protocol v1. The group parameters ensure that the notary set is just for the CSD-operated cluster. For more info, swing by docs.r3.com.
• Issuance day
  • This is the day when the TermsState v1.0 officially gets registered as a reference state.
  • The lead manager inputs the allocations, and then the registrar steps in to issue BondState outputs to the settlement accounts.
• Secondary market
  • When orders get matched on the exchange, it sets off a trade feed that starts the DvP flows on Corda between the settlement accounts of the members.
• Corporate actions
  • When it comes to coupon flows, the system takes a look at the schedule from the TermsState. After that, the paying agent gives their approval, and then the notary ties up all the loose ends. Finally, investors’ positions get updated in their vaults.
• Operational Alignment
  • Observability really leverages UTXO ledger metrics to keep track of verification latency and flow suspension times. Our SREs are closely watching corda_ledger_flow_verification_time_seconds along with all those other related timers. If you want to dive deeper, check out the details in the documentation over at docs.r3.com.

---

Observability and SLOs: concrete metrics and configs

Make sure to watch these to keep issuance and settlement steady, even when the volume changes:

• Ledger Verification Timers
  • Make sure to monitor corda_ledger_flow_verification_time_seconds and corda_ledger_verification_time_seconds. You’ll want to set off an alert if the p95 drift skyrockets to over double the baseline during those hectic issuance spikes. For more details, take a look here.
• Token Selection Performance
  • Don’t forget to adjust corda.ledger.utxo.tokens.cachedTokenPageSize (it’s set to 1500 by default) to better suit your DB IO profile. If you're working with large fungible sets, you might want to kick things off in the 2000 to 5000 range and check how that impacts your p95 claim latency. You can find more details here.
• Messaging and REST Workers
  • When things start to get hectic, you can use the dynamic config API to increase the maxAllowedMessageSize and subscription timeouts. Just remember to keep track of your config versions with schemaVersion major/minor. You can take a look at the details here.
• Flow-Level Health
  • Make sure to keep an eye on those “suspended flows” and check their end states (COMPLETED/FAILED/KILLED) as you’re gearing up for CPI upgrades. It’s best to hold off on the upgrade until there aren’t any active issuance or settlement flows still running. For more details, you can check it out here.

---

Governance, risk, and compliance patterns that work

• Role-based admission
  • Implement manual approvals for roles such as "Registrar," "Dealer," and "PayingAgent." Don’t forget to utilize pre-auth tokens that have expiration dates and X.500 binding for better management of onboarding waves. For more info, take a look here.
• Key Management and Session Policies
  • When you're setting up MGM, make sure to enforce unique session and ledger keys by using corda.group.key.session.policy=Distinct. It’s also a good idea to think about using Hardware Security Modules (HSMs) for keeping your keys safe. This is pretty much the same technique that SDX employs to secure identity keys in HSMs. For more details, check it out here.
• Notary and time windows
  • It’s a good idea to keep those time windows tight when it comes to DvP and managing settlement risk. The notary is your go-to for setting those official time limits and making sure everything’s unique. If you want to learn more, check it out here.
• Privacy
  • Non-validating notaries will only have access to the essential transaction components. Make sure this aligns with legal opinions on confidentiality and data minimization. If you want to dive deeper, take a look at this link.

---

Interoperability and digital cash: what’s ready now

• In-production collateral mobility
  • HQLAx is really shaking things up with its live mobility features and has nailed cross-chain repo swaps in testing. This is a game changer for same-day collateral upgrades and settling across multiple venues. Take a look at it here: (hqla-x.com).
• Exchange integration
  • The SDX consolidation is a great example of mixing the best of both worlds: you get to trade on a traditional exchange order book while managing issuance and settlement via a Corda CSD. If you're curious to dive deeper, check it out here (sdx.com).
• Cross-ledger atomicity
  • The Hyperledger Lab Harmonia, which is being powered by R3 and Adhara, along with input from HQLAx and Fnality, is making strides in creating atomic DvP/PvP solutions between Corda and EVM stacks. If you're diving into wCBDC or looking at tokenized deposits for your cash legs, it’s a good idea to start your designs with this in mind. Want to learn more? Check it out here: (r3.com).

---

Practical build checklist (issuance-to-settlement)

Kick off your team's bill of materials with this template:

• Network and Membership
  • First things first, set up the MGM, export the GroupPolicy, and figure out the admission rules along with the pre-auth token flows. For a deeper dive, check out the docs.
  • Next up, create those RBAC roles for the Issuer, Registrar, and Dealer. Don’t forget to limit the REST startFlow permissions to just these roles. You can find all the details here.
• Ledger and Notary
  • Start by figuring out the name and version of the notary service protocol. Also, restrict the acceptable notaries in the group parameters, and jot down the notary rotation procedure. If you need more details, check it out here.
• Asset Model
  • Implement the BondState by using the TermsState as a guide. Also, make sure to set up the Coupon and Redemption flows, as well as the registrar signing rules.
• Cash Leg
  • Pattern A: Set up CashState and throw in some token observers. Don’t forget to tweak your token selection and put together a DvP flow using an encumbrance group.
  • Pattern B: Build a proof-of-action interface for an outside cash network. You’ll want to set up hold/release semantics on Corda until we nail down that external finality. Looking for more info? Check out this link for all the details.
• CI/CD and Upgrades
  • First off, make sure you package the CPB/CPI. When it comes to automating CPI upgrades, do it via REST, but only after the flows are all drained. And don’t skip the crucial step of bumping up the --cpi-version and keeping the signer summary hash consistent. You can dive deeper into this here.
• Observability
  • Make sure to export those ledger timers to Prometheus, set up your p95 SLOs, and whip up some on-call playbooks for those crazy moments. You can dive into more details here.
• Security
  • It's really important to use separate session and ledger keys. Don't forget to incorporate HSM for your identity keys, and be sure to rotate those keys regularly to keep everything compliant. For more specifics, take a look at the docs.

---

Example: flow contract for atomic DvP using encumbrance groups

Key idea: The asset transfer and the cash payment are part of the same encumbrance group. So, they either get utilized together or not at all.

class DvpContract : Contract {
  override fun verify(tx: UtxoLedgerTransaction) {
    // 1) Exactly one BondState in inputs and outputs; ownership switch validated
    require(tx.inputContractStatesOfType<BondState>().size == 1)
    require(tx.outputContractStatesOfType<BondState>().size == 1)

    // 2) Cash outputs exist and meet price
    val cashOut = tx.outputContractStatesOfType<CashState>().sumOf { it.amount }
    val price   = tx.commandsOfType<Commands.Settle>().single().price
    require(cashOut >= price) { "Insufficient cash" }

    // 3) All encumbered outputs belong to the same group tag
    val encGroup = tx.getEncumbranceGroup("dvp")
    require(encGroup.size >= 2) { "Bond and Cash must be in same encumbrance group" }

    // 4) Required signers (seller, buyer, registrar if needed)
    val signers = tx.signatories
    require(signers.containsAll(requiredParties(tx))) { "Missing signatures" }

    // 5) Time window present and current
    requireNotNull(tx.timeWindow) { "Settlement must be time-bounded" }
  }
  interface Commands { data class Settle(val price: Long): Command }
}

Builder Usage:

Alright, let’s jump right in and see how you can get the best out of your builder!

What is a Builder?

A builder is like your best friend in crafting and personalizing your projects without getting bogged down by complex code. It’s designed to simplify things for you and put you in the driver’s seat of your creative journey.

How to Use a Builder

1. Pick Your Platform: To kick things off, figure out where you want to use your builder. Are you creating a website, an app, or maybe something totally different? Each platform comes with its own unique builder.
2. Kick Things Off with a Template: Most website builders have a bunch of templates ready for you. Choose one that fits your vision. It’s a great way to get a solid foundation!
3. Customize Your Design: Switch up the colors, fonts, and layouts to make it truly yours. Let your personality shine through and ensure it captures your brand's vibe!
4. Add Functionality: Looking to add some awesome features? Most builders make it super easy to drag and drop elements like buttons, forms, or galleries with just a few clicks.
5. Preview Your Project: Make sure to take a moment and see how everything looks! Use the preview feature to check out your work in action before you hit that go-live button.
6. Publish Your Work: When you’re satisfied with everything, go ahead and smash that publish button to share your masterpiece with everyone!

Tips for Success

• Experiment: Go ahead and experiment! It’s totally fine to try out new things. If something doesn’t pan out, you can always revert back.
• Keep It Simple: Remember, sometimes less really is more. Focus on the essentials to ensure your project stays user-friendly.
• Check for Updates: Keep an eye out for updates! Builders frequently introduce new features and templates, so staying up-to-date will help you make the most of your experience.

Resources

If you're curious to dive deeper, take a look at these links:

• Builder Documentation
• Tutorials and Guides
• Community Forums

With these handy tips and resources, you’re ready to dive into some amazing projects with your builder! Have fun building!

builder.addEncumberedOutputStates("dvp", listOf(newBondForBuyer, cashToSeller))

(docs.r3.com)

---

Operating at scale: lessons from live networks

• Parallel production is happening: Check out how DTCC’s Ion is giving us a glimpse into running a DLT settlement system alongside the traditional legacy books. This method makes it pretty smooth to transition gradually and gear up for T+0. It might be worth thinking about how you can model your rollout in a similar way. (dtcc.com)
• Exchange-CSD split: SDX is blazing a trail by prioritizing the move to issuance and settlement first (CSD) while still leveraging the current trading venues. This approach can really speed up adoption without disrupting liquidity. (sdx.com)
• Collateral mobility: HQLAx is leading the way by showing how integrating with triparty/custody systems and Corda allows for on-ledger location transfers--meaning we can minimize those pesky intraday liquidity needs instead of having to deal with physical moves. Let’s look at carrying this model into collateralized settlement. (hqla-x.com)

---

Emerging best practices for 2025

• When you kick things off, keep interoperability in mind from the get-go. Whether you’re looking at wCBDC, tokenized deposits, or Fnality rails, it’s super important to keep your cash abstraction separate. Opt for message schemas that can manage proofs from EVM or any other permissioned chains--think along the lines of Harmonia patterns. For a deeper dive into this, check this out: (r3.com)
• Think of membership as an integral part of your product. Surprisingly, a big chunk of your “go-live risk” can be hiding in your admission policies instead of the code itself. It’s a smart move to use manual approvals and pre-auth tokens for those key roles. And hey, don’t overlook the importance of automating the evidence capture you’ll need for audits. You can dig deeper into this topic here: (docs.r3.com)
• Don’t just focus on TPS; keep an eye on verification latency too. Your customer Service Level Objective (SLO) really depends on the “trade-to-finality” tail latency, which includes verification, notary, and any flow suspensions. Be sure to tweak your message timeouts with the dynamic config API, but hold off on that until you’ve dealt with any code-level suspensions. If you want more details, check out this link: (docs.r3.com)
• Don’t forget to set up separate session and ledger keys, and for sure, use Hardware Security Modules (HSMs). This isn't just a nice-to-have; it's crucial in regulated settings and it fits perfectly with how SDX keeps identity keys safe. If you want to dive deeper, check this out: (docs.r3.com)

---

A 90-day plan to stand up a pilot

Weeks 1-2

• Spin up a Corda 5 cluster on Kubernetes, get that MGM up and running, and establish the membership rules along with the notary. And hey, don’t skip on setting up the basic REST RBAC and user roles. For more info, take a look here.

Weeks 3-4

• Let’s dive into some coding! First up, you’ll want to implement the BondState and TermsState (check out this reference for help). Also, don’t forget to whip up a minimal CashState. Next, go ahead and write the issuance flows, and make sure to include that encumbrance-based DvP flow while you’re at it.

Weeks 5-6

• Next up, let’s dive into token selection! We’ll throw in some time windows, set up metrics export, and make sure those p95 latency SLOs are in place for good measure. You can check out the details here.

Weeks 7-8

• We’re getting ready for a test run of primary issuance; let’s kick off 1,000 to 10,000 synthetic secondary trades. Make sure to tweak cachedTokenPageSize and adjust the message timeouts too. You can find more details here.

Weeks 9-10

• Alright, let’s dive into adding those corporate action flows for coupon and redemption. Don’t forget to set up registrar approvals and implement dual control within RBAC. If you need more info, check it out here.

Weeks 11-12

• Alright, it's time to get ready for a CPI upgrade drill! Start by draining the flows and then carry out a controlled upgrade. Don't forget to jot down those recovery runbooks. You can find more info about it here.

---

Where this is headed

The Future of Digital Asset Lifecycle Management in 2025

By 2025, we're in for a big change in how we manage the lifecycle of digital assets--goodbye to that frustrating POC treadmill! Real-world Financial Market Infrastructures (FMIs) are proving that Corda can smoothly take care of issuance, settlement, and servicing while respecting real governance and scaling up effectively. On top of that, it's getting easier to work with digital cash systems.

If you nail down your app networks--keeping in mind things like membership, notaries, and encumbrance-based Delivery versus Payment (DvP)--you could actually provide T+0 optionality without causing a stir in the current trading venues. And here’s the kicker: you’ll be in a prime spot to incorporate wholesale digital cash as it makes its debut. (dtcc.com)

---

Talk to 7Block Labs

We’re excited to help exchanges, CSDs, and asset managers launch Corda-based digital asset platforms--fast! If you're ready to start a production-ready pilot that covers issuance, DvP, and corporate actions, complete with clear SLOs and governance for audits, let’s team up and plan out your 90-day build!