A BOLT12 offer is a reusable Lightning payment request: you publish one string, and every payer turns it into a fresh invoice on demand. The project site at bolt12.org pitches the format as the future of Bitcoin payments, and the specification itself was merged into the Lightning spec in September 2024. Two years later the standard is stable, but wallet support is still patchy, which is exactly why a hands-on lab beats reading release notes.
Two Core Lightning nodes on regtest are enough to see the whole flow. One node plays a small shop, the other plays a customer, and a single offer string gets paid three times without the shop ever generating a second payment request by hand. A single-use offer dies after one sale, an offer with a quantity cap refuses oversized orders, and a Python ledger maps every incoming payment back to a product SKU. Budget about 75 minutes if you already have the binaries installed.
Nothing here touches real money. Regtest blocks cost nothing, so you can break channels, restart daemons and replay mistakes freely. Anyone who does not run a node yet should skim a Lightning Network node setup first, then come back and run the lab.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
What BOLT12 Offers Change for Lightning Payments
A classic BOLT11 invoice is a one-shot object. It carries a payment hash, an amount, an expiry and a signature, and the merchant has to generate a new one for every customer. Post it on a website and you either expose a single invoice that expires within hours or you run a server that mints invoices on request. That server is the hidden cost of Lightning commerce, because it needs a domain, TLS certificates and an always-reachable web endpoint.
An offer moves that work into the Lightning protocol itself. The payer scans the offer, sends an invoice request through the network as an onion message, and the merchant node answers with a real invoice. The payer then pays that invoice the usual way. Bitcoin and Lightning developer Rusty Russell described the flow at the 2019 Lightning Conference in a talk on offers, as transcribed on btctranscripts.com: “Then they send through the Lightning Network itself a request to the node that signed the offer. The node replies with the real invoice.”
In the same 2019 talk he framed the payoff in one line: “They give us static invoices. An offer is a static invoice.” That sentence is the whole pitch. A static string can live on a printed menu, a QR sticker, a nostr profile or an email footer, and it keeps working after the first customer pays. Because the talk is seven years old, the early design notes read slightly differently from today’s spec, but the request-and-reply model survived intact.
The practical difference shows up in three places. First, reuse: the same offer yields a distinct invoice, payment hash and preimage for each payment, so you never reuse a hash. Second, metadata: an offer can carry a description, an issuer name, a quantity limit and an expiry, so the wallet can show the buyer what they are about to pay. Third, privacy: offers can use blinded paths, which let a node receive payments without publishing its public key and channel graph position in every payment request.
Offers are not a fit for every job. If you bill an API per request, an L402 paywall ties payment to access tokens in a way a plain offer does not. If your customers use a wallet with no BOLT12 support, an LNURL address or a one-off invoice still wins on reach. The lab below targets the middle ground: shops, donation pages and subscription-style billing where you control at least one side of the payment.
Which Lightning Implementations Support BOLT12 Offers in November 2026
Support differs sharply by implementation, and the differences decide what you can promise customers. Core Lightning treats offers as an implemented, actively developed feature, and that makes it the natural choice for a merchant node. Eclair and LDK were both reported as supporting BOLT12 in production by mid-2026. LND is the laggard. The Bitcoin Optech newsletter, issue 431 from November 13, 2026, still described LND’s BOLT12 work as experimental in development builds, and other coverage points to a handler that sits behind a protocol flag.
Wallet-side support is the part that trips up deployments. BOLT12 should not be treated as universally supported across Lightning wallets as of November 21, 2026, and support in a given implementation does not guarantee that every optional feature interoperates. Strike announced in August 2024 that its backend could pay BOLT12 offers using LNDK, a bridge that lets an LND node pay offers, so large payers do exist. Still, test the exact wallets your customers use before you print a QR code on a banner.
If your production node runs LND today, you can keep it for channels and routing and still learn the offer flow here. The LND node setup covers that stack, and the two implementations can coexist as channel peers. An LND peer matters for onion messages too, because the payer’s invoice request has to cross the graph, and Lightning Labs reportedly added basic onion-message forwarding in its v0.21-beta in June 2026.
The Core Lightning release cadence also deserves a note before you pick a version. The project skipped a v26.09 release because an unusually high number of vulnerability reports forced it to ship fixes as v26.06.x point releases instead. The next feature release, v26.12, carries roughly two release cycles of work and 832 commits since v26.06, according to coverage of the v26.12 release candidate. Its first release candidate is out for testing and should not be called the current stable release. Reportedly, the November 4 security release was v26.06.10, and a summary of four Core Lightning security patches in 68 days shows why running the latest point release matters for a merchant node.
Prerequisites: Versions, Tools and Hardware
The lab runs on any recent 64-bit Linux box or VM. Ubuntu 24.04 LTS is a safe baseline, 4 GB of RAM is plenty for regtest, and the whole lab directory stays under a gigabyte. Regtest needs no blockchain download, so there is no waiting on initial sync. If you plan to move to mainnet later, remember that a full node adds hundreds of gigabytes, which the mainnet section covers.
Download Core Lightning from the Core Lightning project site or build it from source using the project’s build instructions, and confirm the version afterward. Pin the stable v26.06 line for this lab. The v26.12 release candidate was published on November 18, 2026, and it is a pre-release for testing, not a shipped final build.
Check what you have before starting, because a missing tool at step nine wastes more time than a two-minute audit now. Readers who have never run a node can pair this lab with a Bitcoin Lightning node setup that explains the mainnet side in more depth.
The output should show a Bitcoin Core 31.x or 30.x version, a Core Lightning version beginning with v26.06, Python 3.11 or newer and jq 1.6 or newer. If lightningd --version prints a release candidate string, swap it for the stable point release before continuing. On Ubuntu, if pip refuses the install with an “externally managed environment” message, create a virtual environment with python3 -m venv ~/offer-lab/venv and install pyln-client inside it.
Build the Regtest Lab (Steps 1 to 3)
Step 1: Create the lab directory and shell shortcuts. Everything lives under one folder so you can delete it and start over in seconds. The aliases below keep later commands short. Add them to a file called lab.env and source it in every terminal you open for this lab.
Node 1 is the merchant and node 2 is the customer. Keep that mapping in your head, because swapping the two aliases is the most common source of confusion in the later steps.
Step 2: Start bitcoind in regtest mode. The fallback fee setting matters because a fresh regtest chain has no fee estimates, and wallet sends fail without it. The RPC credentials are throwaway values for a local lab only. On mainnet you would use rpcauth or cookie authentication instead.
The last command should print 101. Coinbase rewards need 100 confirmations before they can be spent, which is why the lab mines 101 blocks up front. If createwallet says the wallet already exists, you are rerunning the lab over old data. Delete $LAB/btc and start again.
Step 3: Start both Core Lightning nodes. Each daemon gets its own directory, its own listening port and its own alias. Pointing both at the same bitcoind is fine on regtest. The log files land inside each node’s folder, so tailing them later is trivial.
Expected output, abbreviated, with values that will differ on your machine:
Run the same getinfo on node 2 and confirm the alias reads customer and the block height matches. If either call hangs, wait ten seconds and retry, because lightningd polls bitcoind on startup. A block height that stays at zero means the daemon cannot see the chain, and the troubleshooting section lists the usual cause.
Fund the Wallets and Open a Channel (Steps 4 and 5)
Step 4: Fund the customer node. The customer opens the channel and pays the shop, so the customer needs on-chain coins and the shop needs inbound liquidity. Ask node 2 for a fresh address, send one regtest coin from the bitcoind wallet, and mine a block so the funds confirm. Lightning wallets wait for confirmations before they treat coins as spendable, and regtest only confirms when you tell it to.
You should see one output with status confirmed and an amount of 100,000,000,000 msat, which is exactly one coin. If newaddr returns a differently named field on your build, print the whole object and pick the address field from it. Address type names have shifted across releases as Taproot support matured.
Step 5: Connect the peers and open a channel. Connecting first lets the two nodes exchange feature bits, including the onion-message support that offers depend on. Then the customer funds a one-million-satoshi channel to the shop. Mine six blocks afterward so the channel passes its confirmation depth and goes live.
The final command should print CHANNELD_NORMAL. A state of CHANNELD_AWAITING_LOCKIN means the channel still needs blocks, so mine three more and check again. In this direction all one million satoshis sit on the customer’s side, which is correct. The customer can pay the shop up to roughly that amount, and the shop gains inbound liquidity as payments arrive. Keeping liquidity direction straight is the core skill behind Lightning channel rebalancing on a real node, and the lab lets you see it without any risk.
One detail separates offers from plain invoices at this point. For the invoice request to travel, the customer node needs an onion-message path to the merchant node. Here the two nodes are direct peers, so the path is a single hop. On mainnet the path crosses other nodes, and every hop must forward onion messages. That requirement explains why peers matter so much more for offers than for ordinary payments.
Create Your First BOLT12 Offer (Step 6)
Step 6: Ask the shop node for an offer. The offer command takes an amount, a description and a few optional fields. The label is a local bookkeeping tag that never appears in the offer string, which makes it perfect for a SKU. The -k flag lets you pass named arguments, which is safer than counting positions.
Expected output, abbreviated:
The bolt12 field is the string you publish. It starts with lno1, which marks an offer, and it has no checksum, so a single mistyped character produces a different valid-looking string. Always copy and paste offers or share them as QR codes. The offer_id is a hash of the offer contents, and the shop will use it later to tie incoming payments back to this product.
Store the string in a shell variable and inspect it from the customer’s side. Decoding an offer before paying it is how a wallet builds its confirmation screen, and doing it by hand teaches you what a payer sees.
The decoded fields confirm the amount (25,000,000 msat, which equals 25,000 satoshis), the description and the issuer you set. Field names can vary slightly between releases, so if a key prints as null, drop the jq filter and read the full object. Every offer you create gets a unique offer_id even if you reuse a description, and creating the same offer twice returns a duplicate-offer error instead of a second string.
Fetch an Invoice, Pay It, and Pay the Same Offer Again (Steps 7 and 8)
Step 7: Fetch an invoice from the offer. This is the moment BOLT12 differs from everything before it. The customer node sends an invoice request over onion messages, the shop node builds an invoice on the spot, and the reply comes back as a string starting with lni1. If the shop node were offline, the call would time out, because no static invoice sits waiting on a server.
An empty changes object means the invoice matches the offer exactly. If the shop had changed the amount, description or expiry, the differences would show up there, and a careful wallet shows them to the user before paying. Never pay an invoice whose changes block you have not read. A merchant that swaps the amount between offer and invoice is exactly the kind of drift this field exists to expose.
Now pay. The pay command accepts both BOLT11 and BOLT12 invoice strings, so no special flag is needed.
A status of complete proves the full round trip: invoice request, invoice, route, payment and preimage release. Check the shop’s side to confirm it recorded the sale.
The invoice shows paid status, and its local_offer_id equals the offer ID from step 6. That field is the bridge between an anonymous incoming payment and a product, and the Python ledger in step 9 depends on it.
Step 8: Pay the same offer two more times. The point of an offer is reuse, so prove it. Run the fetch-and-pay pair in a loop and compare payment hashes. Each pass should print a different hash, because each invoice carries its own preimage.
Three payments, three payment hashes, one offer that remains active. The used flag flips to true after the first payment and simply records that the offer has been paid at least once. It does not retire the offer. The shop never touched a single invoice by hand, and that property is what makes offers practical for a printed QR code or a recurring donation page.
Build the Python Offer Desk (Steps 9 and 10)
The shell steps prove the protocol. Real shops need bookkeeping, so the next two steps wrap the RPC calls in a small Python project. It publishes one offer per catalog item, remembers the mapping in SQLite, and runs a watcher that records every sale against its SKU. Create a project folder with the files below and keep pyln-client installed in the interpreter you run them with. When you run this against a node that handles real invoices, keep the daemon patched too, as the roundup of LDK, Core Lightning and Eclair security patches illustrates.
Step 9: The Catalog and Offer Publisher
Start with a catalog file. Each entry becomes one offer, and optional keys switch on single-use behavior, quantity caps and expiry windows that step 11 exercises.
Save it as catalog.json. Now the main script. It uses the merchant node’s Unix socket directly, so no extra daemon or HTTP layer is required. The publish command skips SKUs it already knows, which makes reruns safe.
Two design choices deserve a comment. The helper msat exists because different pyln-client releases hand back millisatoshi amounts as plain integers, as a wrapper object or as strings ending in msat, and a ledger should never depend on that detail. The UNIQUE constraint on offer_id blocks the classic mistake of mapping two SKUs to one offer.
Step 10: The Payment Watcher and Ledger
The watcher blocks on waitanyinvoice, which returns the next paid invoice after a given pay index. Storing the last index means a restart resumes exactly where it stopped and never double-counts. The timeout exception is normal on a quiet shop, so the loop treats it as a heartbeat and carries on. Append this code to the same file.
Save the whole file as offerdesk.py. Run python3 offerdesk.py publish first. The output lists four published SKUs with truncated offer strings. Then start python3 offerdesk.py watch in a second terminal and leave it running. The pay index is the safe cursor here, since it increases monotonically with each paid invoice on the node, so the watcher can crash and restart without losing sales.
Single-Use Offers, Expiry and Quantity Limits (Step 11)
Step 11: Pay each special offer and watch the ledger. Reusable offers suit a coffee shop, but a launch-night ticket should sell exactly once, and a promo pack should stop being valid after a day. The catalog already encodes both rules. Write a tiny payer helper to exercise them from the customer side. Save this as payer.py.
Pull the offer strings out of SQLite and try the launch ticket twice. The first payment succeeds. After that, CLN marks the offer as used and inactive, so the second request should fail or time out. Confirm the state with listoffers, because the exact failure message differs between builds.
Now the quantity-capped sample pack. The offer allows up to three units per order, so a request for two units works and a request for four should be rejected before any invoice exists. Note that an offer with a quantity cap requires the payer to name a quantity, and the invoice amount scales with it. The request for two units should settle at 16,000 satoshis.
The first command prints a completed payment, and the second prints a failure because four exceeds the cap. If your sqlite3 command is missing, install the package or read the values through Python instead. Watch the terminal running the watcher: it should print one sale launch-ticket 50000 sat line and one sale sample-pack 16000 sat line. Anything labeled unmapped means the payment arrived for an invoice with no matching local offer, which is worth investigating on a real shop.
The expiry on the sample pack is a protection you rarely get with a printed BOLT11 invoice. After the 86,400-second window, fetching an invoice fails and the offer stops being payable, so a promotion ends on its own. Combine expiry with a label that names the campaign and the ledger doubles as a record of which promotions actually converted.
Test the Whole Project End to End (Step 12)
Step 12: Automate the checks. Manual poking proves the lab works once. A test script proves it keeps working after you upgrade a node, change a flag or rebuild the machine. The script below creates throwaway offers with timestamped labels, pays them, and asserts the properties this article promised: distinct hashes per payment, matching offer IDs on the merchant side and a dead single-use offer.
Run it with python3 test_offerdesk.py. A healthy lab prints reuse ok, single use ok and all checks passed. Each run moves several payments across the channel: three reuse payments at 5,000 satoshis plus one successful single-use payment at 5,000. That is a small slice of the 1,000,000 satoshi channel, but repeated runs drain the customer’s side, and a failing pay with a no-route message usually means that side ran dry. Reopen a channel or send balance back with a reverse payment when it does.
Rerun the checks after every node upgrade, config change or machine rebuild. Pair that habit with a Lightning Network upgrade audit so a new daemon version never goes live untested.
Move From Regtest to Mainnet Without Losing Funds
Everything the lab proved carries over, but the stakes change on mainnet. Swap the regtest flags for --network=bitcoin, point lightningd at a fully synced Bitcoin Core 31.3 or 30.5 node, and replace the throwaway RPC password with rpcauth or cookie authentication. A pruned bitcoind is possible but limits some recovery paths, so a shop that holds customer-facing funds is better off with an unpruned node. Plan for hundreds of gigabytes of disk and a few days for the initial sync before the first channel opens.
Backups come first, not last. The hot wallet secret, called hsm_secret, controls every key the node derives, and losing it with open channels means losing the channel funds. Copy it offline right after the first start. Channel state is a separate problem, since copying a live database and restoring it later can trigger a penalty close with an outdated state. Use the node’s documented emergency-recovery and static-backup tooling instead of file copies, and rehearse a restore on regtest before trusting it.
Peers deserve the same care as backups. Offers need onion messages to cross the graph, so open channels to well-run nodes that forward them. Core Lightning, Eclair and LDK peers are the safest bets given where production support stands today. Start with one or two channels, publish a single low-priced offer and pay it yourself from a second wallet that supports BOLT12. When the real flow works end to end, add more products. As volume grows, resize channels with Lightning Network splicing instead of closing and reopening, which keeps your published offers payable throughout.
When Core Lightning v26.12 Ships
The first v26.12 release candidate is a testing build, and a merchant node with customer money should wait for the final release. The announcement ties that release to changes in payment routing, HTLC recovery after channel-state loss and splicing, which are areas you want battle-tested before they hold real funds. When the stable build arrives, upgrade a regtest lab first, rerun test_offerdesk.py, and only then touch production. Check the release notes for any change to offer behavior, because your published offer strings must keep working across the upgrade.
Common Pitfalls With BOLT12 Offers
Most failures in the first week come from a handful of mistakes. Each one is easy to avoid once you know it exists.
- Treating the offer as proof of payment. An offer is a request, not a receipt. Only a paid invoice, with its preimage, proves a sale. Always reconcile against
listinvoicesand the ledger, never against the number of QR scans. - Running a release candidate on a funded node. The v26.12rc1 build exists for testing. A stable v26.06.x point release is the right pick for anything that holds money.
- Assuming every wallet can pay offers. Support remains incomplete across wallets, so a customer may scan your QR code and get an error. Publish a BOLT11 or LNURL fallback next to the offer until your audience’s wallets catch up.
- Ignoring liquidity direction. A shop with all its balance on its own side cannot receive. Offers do not fix liquidity, and inbound capacity is still the limit on how much you can sell.
- Breaking offer strings with line wraps. The encoding allows a plus sign to split long strings, and some tools mishandle it. Eclair’s issue tracker reportedly showed a decode failure on invoices split with a plus character in mid-November. Paste offers on a single line and never rely on email clients to preserve them.
- Forgetting the quantity field. An offer with
quantity_maxneeds the payer to state a quantity, and the amount scales with it. Wallets that skip the field fail with a confusing error. - Reusing labels or descriptions carelessly. Duplicate offers return an error, and vague labels make ledgers unreadable. Use one stable label per SKU and keep a mapping table, as the offer desk does.
- Skipping the changes block. The
changesobject in a fetched invoice shows any difference from the offer. Wallet code that ignores it can pay a different amount than the user saw.
Troubleshooting: 10 Fixes for Offer Problems
When something breaks, read the lightningd log before changing anything. The log files sit at $LAB/ln1/lightningd.log and $LAB/ln2/lightningd.log in the lab. The fixes below follow the order in which people usually hit problems.
- Unknown command “offer”. Run
lcli1 help | grep -i offer. If nothing prints, your build predates the v26 line or runs with offers switched off. Upgrade to the stable v26.06.x series, and on older builds addexperimental-offersto the config file before restarting. - fetchinvoice times out. The invoice request never reached the shop. Check that both nodes are connected with
listpeers, that the shop daemon is running, and that no firewall blocks port 9735 or 9736. On mainnet, the usual cause is a path with a peer that does not forward onion messages. - Pay fails with no route. The channel may not be active, or the customer side has no outbound balance. Confirm
CHANNELD_NORMALinlistpeerchannelsand check that the amount fits within the channel balance. - Channel stuck in CHANNELD_AWAITING_LOCKIN. Regtest confirms only when you mine. Run
bcli generatetoaddress 3 $ADDRand check again. - lightningd cannot talk to bitcoind. Look for authentication errors in the log. The user, password and port in the lightningd flags must match what you passed to bitcoind. In the lab that means
rpc,rpcpassand port 18443. - fundchannel says you cannot afford the channel. The wallet balance must cover the channel amount plus fees, and coins need confirmations. Check
listfunds, mine more blocks, and try a smaller amount. - Waiting for bitcoind or block height stuck at zero. The node cannot see the chain. Confirm that bitcoind runs with
-server=1, that the datadir flag points to the right folder and that the wallet mined 101 blocks. - Address already in use. A previous daemon is still running. Use
pgrep -a lightningdto find it and stop it withlcli1 stopbefore restarting. - The Python scripts cannot find the socket. The path must read
~/offer-lab/ln1/regtest/lightning-rpc. If you started the daemon with a different lightning-dir or network, update the constants at the top of the scripts. - UNIQUE constraint failed when rerunning publish. The SQLite ledger already knows that SKU, or an offer with the same fields exists on the node. Delete
offerdesk.dbfor a clean lab, or edit the catalog to publish a genuinely new product.
Two further symptoms are worth knowing. If the watcher prints unmapped for a payment, the invoice came from something other than a local offer, such as a BOLT11 invoice you created by hand, so the behavior is correct. If waitanyinvoice raises an unexpected error code instead of the timeout, print the error object and compare it with the handler, since the code differs across releases and the string check in the loop covers the common case.
Advanced Tips for Production Offer Desks
Use fronting nodes on busy shops. Core Lightning’s v26.04 release reportedly added fronting_nodes support to the offer command, along with a payment-fronting-node configuration option. The idea is to route payers through nodes you pick, which can help hide your own node and steer liquidity. Test it on regtest with three nodes before using it on mainnet.
Collect payment proofs. The v26.06 feature release reportedly introduced a createproof method for successful BOLT12 payments, plus an offer_id field in invoice-creation notifications. Proofs let a payer demonstrate that they paid a specific invoice, which is useful for refunds and disputes. If your build lacks the method, the ledger plus listinvoices data still gives you the merchant side of the story.
Replace polling with notifications. The watcher blocks on waitanyinvoice, which is simple and robust. Larger shops can subscribe to invoice-payment notifications through a plugin and push events into a queue. Keep the pay index cursor either way, because it is your protection against missed or duplicated events after a crash.
Try recurrence carefully. The offer format supports recurring payments with a period, a base time and a limit, and Core Lightning exposes those fields on offer. Wallet support for recurring offers is thinner than for one-off offers, so treat recurrence as a lab project until your customers’ wallets prove they handle it. A subscription that silently fails on the payer side costs you more than a monthly reminder email would.
Back the offer desk with real monitoring. Alert on a daemon that stops responding, a channel that closes, a ledger count that stops growing during business hours and a node whose version falls behind the latest point release. Offers make payments easier to start, but they do nothing to keep your node alive. Operators who run several Lightning tools should compare their stack against the category’s coverage in the cryptocurrency section for adjacent hardening guides.
Plan node migrations early. LND’s BOLT12 receiver work is still maturing, and Eclair and LDK already run offers in production. If you ever migrate nodes, the offer string you published is tied to the signing node, so plan a transition period where both the old and new offers work, and do not retire the old node until traffic on its offers stops.
FAQ: BOLT12 Offers on Core Lightning
What is a BOLT12 offer?
A BOLT12 offer is a reusable request for a Lightning invoice. Payers scan the offer, their node asks yours for an invoice over onion messages, and your node replies with a fresh invoice for that single payment. The offer itself is not a settled payment.
Is BOLT12 ready for production use?
The specification was merged in September 2024, and Core Lightning, Eclair and LDK were reported as supporting it in production by mid-2026. The weak spot is wallet coverage, which remains incomplete, so offer a fallback payment method for customers whose wallets cannot pay offers.
Does LND support BOLT12 offers?
Not as a mature feature yet. The Bitcoin Optech newsletter for November 13, 2026 described LND’s BOLT12 work as experimental in development builds. Strike announced in August 2024 that it could pay offers through LNDK, so an LND-backed payer can exist, but an LND merchant node should not promise offers to customers today.
Can the same offer be paid more than once?
Yes. Each payment uses a new invoice with its own payment hash, which the lab shows with three payments against one offer. Create the offer with the single-use option if you want it to stop after the first sale.
Do I need a public channel or a web server?
You need no web server, domain or TLS certificate, because the invoice request travels over the Lightning network itself. The node must be online and reachable through onion messages when a payer fetches an invoice. Public channels help reachability, though blinded paths can reduce what your node reveals.
Which Core Lightning version should I run?
Run the latest stable v26.06.x point release. The v26.12 release candidate is for testing, and the final v26.12 release has not shipped yet. Do not put customer funds on a release candidate.
How is a BOLT12 offer different from LNURL-pay?
LNURL-pay depends on a web server that answers HTTPS requests with invoices. An offer asks your Lightning node directly over onion messages, so the whole flow stays inside the Lightning protocol. LNURL still has the wider wallet reach today, which is why many shops publish both.
Marcus Bell covers applied security: authentication, TLS, phishing, and the everyday decisions that keep accounts and data safe. He focuses on turning advice people usually ignore into steps they will actually follow.



