Less bookmarking.
More building.

Complete an early lesson and explain one transaction concept in your own words.

Pair a chapter with a small experiment and publish a reproducible notebook.

Use the self-paced seminar materials to organize a reading and discussion session.

Choose a course that matches your experience and turn one exercise into a short technical explanation.

Prepare questions for a study session, then contribute a useful set of notes.

Compare your public code and available study time with the application criteria.

Build a three-node network and document a successful payment and a failed route.

Make a test-wallet balance view and document how the app obtains chain data.

Compare LDK’s integration approach with the simpler LDK Node starting point.

Write a small transaction-inspection utility with tests for malformed input.

Map a test checkout from invoice creation to payment confirmation and order fulfillment.

Inspect a demo in your preferred language and document its network and server assumptions.

Audit one receive-payment flow against its relevant guidance and explain your tradeoffs.

Prototype an invoice that can be pending, paid or expired, with clear recovery actions.

Use a small, consistent icon vocabulary and pair unfamiliar actions with text labels.

Select one component and demonstrate keyboard access, error states and responsive behavior.

Choose one topic relevant to a project and trace its original discussion before proposing a change.

Read a proposal’s motivation, specification and status before implementing a related feature.

Trace one field from a test invoice to its specification and your implementation’s behavior.

Reproduce an archived session’s test and write down what you verified and what remains unclear.

Choose a documented review, inspect the patch and explain one behavior it changes.

Read the current process, reproduce an issue, and submit evidence only when you can explain it.

Review a project’s existing discussion, then offer a focused flow analysis or research question.

Summarize one thread’s assumptions, unresolved questions and proposed experiments for your own notes.

Diagram a swap lifecycle and reproduce one supported example in the documented local regtest environment.

Create an architecture note that identifies the operator, network assumptions and documented exit paths before choosing a demo.

Compare the supported receive flows and prototype their loading, pending and recovery states using fixtures.

Prototype a wallet-connection screen with clear permissions and a disconnect flow; explain what each party can do.

Follow a documented test-payjoin example and write an annotated account of the wallet and networking boundaries.

Storyboard a reusable payment request, then list the compatibility questions your product must answer.

Choose the documentation matching your node and build a small read-only transaction inspector in regtest.

Build a read-only transaction-status panel with a visible last-updated time and a useful unavailable state.

Trace one client operation through the relevant crates and draw the message flow, including a failed response.

Create a local token-lifecycle diagram, then test one documented example with development data.

Build a small plugin in a local development environment and record its behavior when a dependency fails.

Map the permissions, invoice states and recovery steps needed by a small payment integration.

Run a small local scenario, save the topology and versions, and explain one observed network behavior.

Create and confirm a regtest transaction, then document a reproducible reset and rerun.

Follow the project’s Signet trial guide and document how the interface explains a recovery path becoming available.

Diagram the roles of a miner, pool and template provider, then inspect an implementation’s message handling.

Complete one relevant chapter, record the software versions and explain any steps you had to adapt.

Write a short decision note comparing two approaches through decentralization, privacy and reviewability.

Prototype an approval screen with fictional inputs: within policy, above the limit and waiting for another signer.

Read one linked public repository, then outline a system you built: the decision, a failure and what you would change.

Choose a small archived review, reproduce the relevant test and record the commit, commands, result and limits of your check.

Create your own valid, truncated and malformed transaction fixtures. Explain each result and credit any reused course material.

Complete an exercise and add a boundary-case test with your reasoning.

Draw a payment lifecycle and link each stage to the relevant chapter.

Make a short diagram explaining one verification step without copying the book's figures.

Choose one module and write three questions before reading its references.

Compare two channel failure scenarios and record the assumptions behind each.

Annotate the trust assumptions and distinguish the paper from today's implementation.

Map a guide concept to current implementation documentation and note differences.

Study past project ideas and outline the evidence needed for a similar contribution.

Reproduce a technical answer in a test environment and note its version assumptions.

Trace how a test transaction's inputs and outputs are presented before signing.

Run a focused test and explain one wallet-to-server boundary.

Diagram a test multisignature wallet's device, coordinator and node responsibilities.

Review a signing screen and prototype clearer recipient and change labels with fictional data.

Document the steps and failure states in a simulated QR signing exchange.

Trace a test signing request from input parsing to user confirmation.

Read a transaction-review path and explain one safeguard in your own words.

Outline a firmware-build reproduction plan and identify its hardware dependencies.

Use documented emulator tests to investigate a Bitcoin confirmation flow.

Identify a Bitcoin parsing test and add an invalid-input fixture in a local fork.

Review a receive-screen state and propose an accessibility improvement with a mockup.

Map how the interface distinguishes connection failure from payment failure.

Trace a payment-status transition and describe the information the user receives.

Document startup, synchronization and disconnected states as a UX case study.

Draw the permissions boundary between a hub and a connected test app.

Build a mock connection flow covering cancellation, expiry and reconnection.

Write a test adapter that handles a denied payment permission without retrying blindly.

Run a documented local example and diagram node persistence and event handling.

Decode a public test transaction and add assertions for amounts and output scripts.

Compare one RPC response with your application's expected schema using fixtures.

Trace how a wallet distinguishes a received transaction from a confirmed balance.

Inspect a protocol parser test and document how malformed messages are handled.

Run a serialization example and add a round-trip test for one data type.

Parse a test transaction and compare its representation with a reference decoder.

Create a test-only transaction inspection tool with explicit network selection.

Express a small policy and explain the resulting spending conditions with test keys.

Read a verification test and explain which invalid inputs it rejects.

Use a documented binding to inspect a test PSBT and record validation errors.

Use emulator documentation to compare two device responses to a test request.

Parse a synthetic PSBT and write tests for missing required fields.

Compare serialization of a known fixture against its expected transaction bytes.

Exercise a documented test vector and explain the transaction fields being signed.

Compare the same test-wallet operation across two documented language bindings.

Build a test transaction-status view that distinguishes unconfirmed and unavailable results.

Diagram the node, indexer and wallet boundaries before trying a local setup.

Prepare a resource and synchronization checklist for a disposable test deployment.

Explain a wallet subscription response and its implications for client reconnection.

Document which wallet data the bridge tracks and how that differs from a general indexer.

Create a mock dashboard that explains node health without exposing RPC credentials.

Trace one tracked transaction event and document duplicate-event handling.

Compare a documented policy option with consensus rules and explain the difference.

Summarize one experiment's assumptions and distinguish it from deployed mainnet rules.

Illustrate how an inclusion proof changes the data a verifier must retain.

Build a disposable demo and document the trust boundary between its funding backend and users.

Turn one flow into request/response fixtures with clear validation failures.

Diagram address resolution and note where HTTPS and receiver trust enter the flow.

Design an alert from sample channel data and explain when it should remain quiet.

Compare the information shown for a failed payment and an offline peer.

Prototype a readable channel-balance view using fictional data and accessible labels.

Choose a read-only command and convert sample output into a short operations report.

Explain one automation decision from documented inputs and identify its limits.

Use example channel data to explain a routing-management tradeoff.

Read the current feature list and diagram how the companion talks to its node.

Explain one signing-policy rejection using a test scenario from the project.

Draw the client, signer and hosted-node boundaries and list their assumptions.

Trace a documented event through the node components and record its dependencies.

Inspect an integration test and explain the channel behavior it protects.

Annotate the startup sequence and identify which parts a production app would need to own.

Map the interface's dependencies and document which actions change node state.

Use sample reports to define an operational metric with a clear denominator.

Draw the swap lifecycle and mark fees, timeouts and external-service dependencies.

Describe the protocol participants and distinguish market participation from a local simulation.

Explain what Bitcoin verifies and what additional asset validation requires.

Read an existing scenario and propose one additional invalid-message test.

Choose a fuzz target and explain how its saved inputs exercise parsing behavior.

Run one documented test locally and explain a single assertion and its setup.

Write a build-verification plan listing inputs, platform requirements and expected outputs.

Trace how a mining job reaches the device and how a submitted result is reported.

Diagram a miner-to-pool job exchange and explain stale-share handling.

Map one reference component to its protocol role and run a relevant documented test.

Explain the transport handshake and what it does not hide about network participants.

Draw sender and receiver responsibilities and identify the scanning cost.

Annotate a descriptor made from public test keys and explain its checksum and origin fields.

Create a field map showing what a coordinator and signer each need to inspect.

Explain nonce-handling responsibilities from the specification without inventing a signing scheme.

Select a fixture, explain its expected result and reproduce it with a compatible parser.

Explain a documented failure path and distinguish protocol goals from demonstrated guarantees.

Map a token exchange and explicitly describe the trust placed in the mint.

Build a mock wallet response handler and distinguish transport errors from token state.

Diagram mint liabilities and redemption assumptions using a disposable test setup.

Compare a threshold signing workflow with ordinary multisignature and cite the selected suite.

Build a reading trail for one unfamiliar term and record the dates of its source discussions.

Summarize one discussion's unresolved question and distinguish proposals from accepted changes.

Compare a transcript's claim with its linked code or specification and note the talk date.

Turn one workshop example into a small test plan with explicit prerequisites.

Prototype an amount-entry field with keyboard navigation and explicit unit labels.

Audit a fictional payment flow for keyboard, contrast and screen-reader barriers.

Find a narrowly scoped interface issue and prepare annotated before-and-after states.

Review one component's loading and error states and document the project's maturity.

Read one assessment's method and explain what its result proves and leaves untested.

Design a test invoice workflow with webhook retries and duplicate-event handling.

Map invoice creation, payment detection and expiry in a disposable demonstration.

Outline the required receiver hardware and distinguish reception from transaction broadcast.

Explain one documented tracepoint and the permissions needed for a local observation.

Work through a tiny set-difference example and explain the capacity limit.

Compare flooding and reconciliation on a small hypothetical peer network.