How an LLM used FRAGMENT to delete code I thought I had to write

Building a wallet is harder than it looks — especially if you want it to be safe and reliable. FRAGMENT gives you a fully configurable database for money, so you can model and power virtually any type of fintech app, from wallets to marketplaces to neobanks, without having to build all the tricky logic yourself. You can use its wallet template to get started fast, or design your own funds flows from scratch. Under the hood, it uses a double-entry accounting ledger, but you don't need to know accounting to use it. While FRAGMENT offers a wallet template for common use cases, you can configure it to back virtually any fintech app: wallets, marketplaces, neobanks, rewards, and more.

A production wallet has to do seven distinct chores:

1. Keep a running balance for every user
2. Accept deposits / top-ups
3. Move money between users (transfers & payouts)
4. Stop two simultaneous actions from corrupting a balance (race conditions)
5. Guarantee idempotency so network retries don't double-post
6. Reconcile internal ledger lines with the payment processor
7. Serve yesterday's balance instantly, while new transfers fly in

You are still using a database. FRAGMENT is the database for money—it's just designed to handle all those financial headaches like double-counting, race conditions, and missing transactions. Think of it as your regular database's financially savvy cousin who actually remembers to balance the checkbook, so you don't have to write (or debug) all that tricky logic yourself.

LLM: "Most of that is built in to FRAGMENT.dev—a hosted double-entry ledger. Want to see how much code we can delete?"

+---------------------+      +----------------------+
|  Hand-Rolled Wallet |      |   Fragment Wallet    |
+---------------------+      +----------------------+
| - Manual SQL        |      | - Declarative Schema |
| - Race Guards       |      | - API Call           |
| - Idempotency Table |      | - Built-in Safety    |
| - Reconciliation    |      | - 6 lines of code    |
+---------------------+      +----------------------+

# wallet_before_fragment.py
class WalletService:
    """
    Bare-bones wallet. Every TODO is a job the LLM will soon erase with <InlineLogo />.
    """
    def __init__(self, db):
        self.db = db  # balances & ledger tables

    #1 Add money (deposit)
    def deposit(self, user_id: str, cents: int, tx_id: str):
        """Add money, idempotently."""
        # TODO idempotency guard
        # TODO write ledger line
        # TODO update balance with concurrency safety
        ...

    #2 Move money (transfer)
    def transfer(self, from_id: str, to_id: str, cents: int, tx_id: str):
        """Move money between two users."""
        # TODO overdraft guard
        # TODO two ledger lines (debit + credit)
        ...

    #3 Reconcile with payment processor
    def reconcile_charge(self, charge_id: str):
        """Match Stripe charge to ledger line and mark reconciled."""
        # TODO locate internal line
        # TODO mark reconciled
        ...

Keep the TODOs in mind—each upcoming section shows the LLM flagging one chore and FRAGMENT deleting the helper code. When we reach the end this class is six lines long.

You interact with FRAGMENT through its API—just like you'd call Stripe or Twilio. Instead of writing all the logic for deposits, transfers, and balance checks yourself, you describe what should happen in a simple schema (a bit like a config file). FRAGMENT then enforces all the rules for you:

• Atomicity: No partial updates—transactions either fully succeed or fail.
• Idempotency: Safe to retry API calls; no double-posting.
• Balance Safety: Prevents negative balances and race conditions.

FRAGMENT is not just for wallets: you can model any kind of funds flow, from peer-to-peer payments to complex marketplace settlements. You don't need to know accounting—just describe your business logic, and FRAGMENT handles the rest.

{
  "type": "DepositEntry",
  "description": "Adds cash to a user's wallet",
  "lines": [
    {
      "key": "credit_wallet",
      "account": { "path": "liability/wallets/wallet:{{user_id}}", "consistencyConfig": { "ownBalanceUpdates": "strong" } },
      "amount": "{{cents}}"
    },
    {
      "key": "debit_cash",
      "account": { "path": "asset/cash" },
      "amount": "{{cents}}"
    }
  ]
}

Code after FRAGMENT

# Note: All SDK calls are async and must be awaited. See the Appendix for setup details.
async def deposit(self, user_id: str, cents: int, tx_id: str):
    await fragment.post_entries(
        "DepositEntry",
        idemp_key=tx_id,
        user_id=user_id,
        cents=cents,
    )

You just watched an LLM talk me out of writing 120 (97%) lines of fragile wallet code by leaning on FRAGMENT.dev's built-in primitives.

LLM: "Ready to try it yourself?"
You: Get your free FRAGMENT workspace →

Glossary- API: A way for your code to talk to another service.

• Double-entry ledger: An accounting system that always keeps your books balanced by recording every transaction in two places.
• Idempotency: Making sure repeating the same API call doesn't double-post a transaction.
• Atomicity: Guaranteeing that a transaction either fully happens or doesn't happen at all.

Schema update: Add an external account link (e.g., Stripe)

Python SDK call to reconcile (with codegen):

await client.reconcile_tx(
    external_ref=charge_id
)

Example: Add a new entry type for a loan disbursement or a marketplace escrow in your schema

• Use the generated method for that entry type

Python SDK call (with codegen):

# If you use the codegen client, you get type-safe methods for each entry type.
# See the Appendix for setup details.
await client.loan_disbursement_entry(
    idemp_key=tx_id,
    borrower_id=borrower_id,
    amount=amount,
    currency="USD",
)

FRAGMENT isn't just for wallets. It's a toolkit for any app that moves money, tracks balances, or needs bulletproof financial logic. Ready to delete your first hundred lines of wallet code?

1. Book a demo
2. Copy the Wallet Schema from this post
3. Run the Python SDK example (with codegen) Done! You've got a production-grade wallet.
4. Explore the docs

To use the FRAGMENT Python SDK, you must initialize the client with your credentials and use async/await for all SDK calls. Here's how to get started:

from fragment.sdk.client import Client
import asyncio

client = Client(
    client_id="<Client ID>",
    client_secret="<Client Secret>",
    api_url="<API URL>",
    auth_url="<OAuth URL>",
    auth_scope="<OAuth Scope>",
)

async def main():
    # Example: get workspace
    response = await client.get_workspace()
    print(response.workspace.name)

    # Example: post a deposit entry (generic client)
    await client.post_entries(
        "DepositEntry",
        idemp_key="tx123",
        user_id="user_1",
        cents=1000,
    )

    # Example: with codegen client (after running codegen)
    # await client.deposit_entry(idemp_key="tx123", user_id="user_1", cents=1000)

if __name__ == "__main__":
    asyncio.run(main())