App builder

Keep a crypto trading journal
that grades every setup you trade.

Describe how you trade and Netiva’s AI builds a web app for trade plans, synced fills, R multiples and the Sunday review — with a live preview and code you own.

Start building free More app ideas
Starter prompt

Build a crypto trading journal web app for one trader on two exchanges. Keep a playbook per setup with its rules, checklist and risk per trade. Before an entry I write a plan with the pair, direction, entry, stop and first target, and the app sizes the position from my risk percent and the stop distance. Every four hours, pull filled orders and funding charges from each exchange’s REST API with a read-only key, group them into round trips per pair and work out the average entry, the fees and the R multiple against the plan’s stop. Show open positions, a journal of closed trades and a scorecard per playbook.

Build it in Netiva Paste the prompt into a new workspace and adjust it to your business.
Overview

Who this trading journal is for

An active trading week scatters its own records. The fills sit in the exchange’s trade history, the reasoning is in screenshots, and the part that matters — why the setup was worth taking and where the stop went — ends up in a notes app after the session. By Sunday nobody can say which playbook actually paid, how much went to fees and funding or how often a stop got moved. A trading journal built with Netiva ties each plan to the fills it produced, so every closed trade keeps its rules, its risk and its result in one record.

Key features

What your trading journal can do

  • Plans written before the entry

    A plan holds the pair, direction, entry, stop and target while the trade is still an idea, beside the playbook’s checklist. It stays as written once the position opens, so the trade page sets it against the average entry the fills produced.

    • Playbook checklist ticked off before a plan can be saved
    • Size worked out from your risk percent and the stop distance
    • Chart screenshot attached to the plan, not to the result
    • Skipped and invalidated plans kept, so missed setups still count

  • Fills from your exchange, read-only

    A scheduled job calls each exchange’s REST API with a key that can only read, stores that key securely and files every fill under the execution ID the exchange gave it, so a repeated run never counts a fill twice.

    • Keys with order, transfer and withdrawal permissions switched off
    • Fills grouped into one round trip per pair and direction
    • Maker or taker fee kept per fill, in the currency it was charged
    • Funding charges on perpetuals pulled in as their own rows

  • R multiples and expectancy by setup

    Each closed trade is scored against the risk its initial stop implied, so a 2.4R win and a 0.9R loss sit on one scale. The playbook page turns those scores into win rate, average win and average loss in R and expectancy per trade.

    • Win rate, average R and expectancy for every playbook
    • Results split by session, by pair and by day of the week
    • Saved views for A-grade setups and for trades that broke a rule
    • Equity curve in R with the deepest drawdown marked

  • A review desk that closes the loop

    Grade a trade for rule adherence and write the note while it is still fresh. A scheduled email on Sunday lists the week’s unplanned entries, moved stops and positions still open, so the review happens on quiet weeks too.

    • Rule adherence graded yes, partly or no once you review the trade
    • Unplanned entries counted apart from planned ones
    • Weekly email listing the rules you broke that week
    • You sign in, and the journal stays yours alone
Data model

The collections behind it

Netiva keeps your records in built-in collections. Here’s a starting structure — the agent adapts it to your prompt, and you can change it any time.

Playbooks

The setups you actually trade, each with the rules it has to meet.

  • Name (required) Range reclaim, breakout retest, funding squeeze Text
  • Market (required) Spot or perpetual Text
  • Rules (required) Trigger, invalidation and how the position comes off Paragraph
  • Checklist (required) One condition per line, ticked on the plan Paragraph
  • Risk per trade (required) Percent of the account risked on an A-grade entry Number
  • Minimum reward to risk Skip the plan when the first target is closer than this Number
  • Session Asia, London, New York or any Text
  • Status (required) Testing, live or retired Text

Trade plans

What you decided before the entry, written while the trade is still hypothetical.

  • Playbook (required) Relation to Playbooks
  • Pair (required) BTC/USDT, ETH/USD or the venue’s perpetual symbol Text
  • Direction (required) Long or short Text
  • Entry price (required) The trigger level, not the fill you end up with Number
  • Stop price (required) Invalidation level; sets the risk the trade is scored against Number
  • First target Number
  • Chart Screenshot taken at the moment you planned it Image
  • Status (required) Planned, triggered, skipped or invalidated Text

Trades

One round trip per position, from the first fill to flat, with its result worked out from the fills and graded.

  • Plan Blank on an unplanned entry, which the review counts separately Relation to Trade plans
  • Pair (required) Text
  • Venue (required) The exchange account the fills came from Text
  • Opened at (required) Time of the first fill off flat Date & time
  • Closed at Empty while the position is still running Date & time
  • Stop moved Yes or no; set when the stop changes after entry, so the R denominator stays as planned Text
  • Rules followed (required) Not reviewed, yes, partly or no; new trades default to not reviewed Text
  • Review note Written at the review, naming the rule you broke and what you would do again Paragraph

Fills

Every execution the exchange reports, so averages and costs come from what really happened.

  • Trade (required) Relation to Trades
  • Execution ID (required) The exchange’s execution ID; unique, so a re-sync can’t count a fill twice Text
  • Order ID The order this fill came from; one order can fill many times Text
  • Side (required) Buy, sell or a funding charge on a perpetual Text
  • Filled at (required) Date & time
  • Price In the quote currency; empty on a funding row Number
  • Quantity In the base asset; empty on a funding row Number
  • Fee or funding Signed, in the currency charged: a fill’s commission or the funding paid or received Number

Required field. Types are Netiva collection field types.

Screens

Pages and screens to start with

A typical first version. Ask the agent for more, or annotate the preview to change any of them.

  • Trade planner

    A new plan with its playbook checklist, the distance to the stop and the size that risks your set percent, saved before anything goes to the exchange.

    Signed-in users

  • Open positions

    Positions still running, each beside its plan’s stop and target, with the fills so far, the size on and what funding has cost to hold it.

    Signed-in users

  • Trade journal

    Closed trades newest first, filtered by playbook, pair, venue, outcome or rule adherence, with the net result and the R on every row.

    Signed-in users

  • Trade detail

    One round trip: the plan and its chart, every fill and fee the exchange reported, the average entry beside the planned one, the R multiple and your review note.

    Signed-in users

  • Playbook scorecard

    The rules of one setup above its numbers: trades taken, win rate, average win and loss in R, expectancy per trade and the last 20 entries.

    Signed-in users

  • Review desk

    The week in order with each grade, the equity curve in R and anything left unreviewed, ready for the Sunday session.

    Signed-in users
How it works

From prompt to a live trading journal

  1. Describe how you trade

    Tell Netiva which venues you use, whether you trade spot or perpetuals and how you size risk. Netiva sets up collections for playbooks, plans, trades and fills, and builds the planner screen around your checklist.

  2. Connect the exchange, read-only

    Create an API key at your exchange with order and withdrawal permissions off, store it in the app and ask for a sync every few hours. Compare the first batch against your exchange’s own trade history.

  3. Run one known trade through it

    Take a position you already closed and walk it through the planner and the journal in the live preview. If a partial fill throws off the average entry, mark it on the preview and the agent reworks the grouping.

  4. Ship it and start journaling

    One click puts it on your domain behind your sign-in, with the Sunday review email switched on. Checkpoints keep every version, so a change to the scoring rules can be compared with the old one and rolled back.

Why Netiva

Netiva vs a traditional build

Building a trading journal with Netiva compared with a traditional build
Criterion With Netiva Traditional build
Keeping the journal Plans and fills in one record, with fills read from the exchange on a schedule A spreadsheet tab per month, filled in from memory once the session is over
Judging a setup Win rate, average R and expectancy per playbook, counted from every closed trade A feeling about which setup works, backed by the handful of trades you remember
Getting started Describe what you need in chat and watch it take shape in a live preview Hire developers, or stitch together templates, plugins and a hosting plan
Content and data Built-in collections with nine field types, bound straight to your pages Set up and connect a separate database or CMS
Making changes Ask the agent; every change is checkpointed and reversible File a ticket, wait for a sprint, redeploy
Hosting and domain Global hosting and automatic SSL; connect a custom domain from the Starter plan Buy hosting, then install and renew SSL certificates yourself
Code ownership Clean production code you own and can export Locked into a template, plugin or agency setup
Examples

Ways teams use it

  • A full-time trader across two venues

    Spot on one exchange, perpetuals on another, each connected with its own read-only key. Both sets of fills land in the same journal, so the scorecard covers the whole week instead of one account at a time.

  • A part-time trader with a day job

    Limit orders fill during work hours. The scheduled sync has them written up by evening, so the review is 10 minutes of grading trades rather than an hour spent rebuilding what happened from the exchange screen.

  • A small group that reviews together

    Six traders each keep their own journal behind their own sign-in, and the group asks the agent for one more rule: a trade marked as a group example is copied to a shared board the others can open for the weekly call, while every other trade stays private to its owner.

Good to know

Before you build

  • Read-only keys, nothing more

    Create the exchange key with order and withdrawal permissions switched off, and tie it to an IP address if your venue offers that. Exchanges split those permissions deliberately: querying closed orders and trades is a separate right from placing or modifying them.

  • Your exchange sets the pace and the history

    Exchange APIs cap how often you can call them — some count request weight per IP address and answer a burst with a 429 and a Retry-After — and most return only a limited window of past trades. Sync in windows, back off when told to and keep the execution IDs you already have.

  • Perpetuals cost more than the spread

    On a perpetual contract you also pay or receive funding at the interval the venue sets, often every eight hours at 00:00, 08:00 and 16:00 UTC and sometimes more often. Leave it out and a position held for days looks better than it was. Margin products differ by country too.

  • Your old spreadsheet stays where it is

    Netiva has no import tool. Start the journal from this week’s trades, then type the months you care about into the collection grid, or describe them to the collection assistant and have it draft rows for you to check.

Compliance note

The journal records what your exchange already did. Netiva doesn’t hold or move coins, place or cancel orders, mine or give investment advice, so connect the account with a read-only key and leave trading permissions off. If you later want an app of yours to send orders, that has to run through your own licensed venue under its terms, and the rules on margin and derivatives differ by country, so get legal review where you trade.

FAQ

Questions about building a trading journal

Can the app place trades on my exchange for me?

No. Netiva builds the web app, and this journal reads your trade history rather than acting on the account, so create the key with order and withdrawal permissions switched off — the compliance note above covers what sending orders would involve. Revoke that key at the exchange whenever you like and paste a new one in: the fills already stored stay put, and the next sync carries on from the last execution ID it saw.

How does the journal turn fills into one trade?

A round trip opens at the first fill that takes you off flat in a pair and closes when the position is back at zero, so scaling in and out stays inside one trade. Each fill is weighted by quantity for the average entry and exit, fees are totaled in the currency they were charged, and every row keeps the exchange’s own execution ID, so a repeated sync can’t count a fill twice.

How is the R multiple on a trade worked out?

Risk comes from the plan rather than the outcome: the distance between the average entry and the initial stop, multiplied by the quantity that actually filled. The net result after fees and funding is divided by that number, so a 2R win and a 1R loss compare directly. Moving a stop after entry doesn’t rewrite the denominator — the trade is flagged as a moved stop instead.

Does it cover perpetual futures and funding payments?

Yes, where your venue’s API reports them. Funding is exchanged at the interval the venue sets, commonly every eight hours at 00:00, 08:00 and 16:00 UTC, and some venues settle more often when the market is moving fast. Each charge is pulled in as its own row against the open position, so the result you review includes what the position cost to hold.

Can I journal on-chain swaps in a blockchain trading app?

Yes. A swap can be logged by hand with its pair, amounts and the network fee you paid, or the app can call a block explorer or indexer API with the transaction hash and fill in the row. Count gas as part of the cost of the trade, and give decentralized venues their own playbook so their slippage doesn’t distort the scorecard for exchange trades.

Who can see my trading journal once it is published?

Only you, unless you decide otherwise. Publishing puts the app on the web with hosting and SSL handled for you, and a custom domain is available from the Starter plan, but the journal screens sit behind a sign-in and each signed-in user sees their own records. The code stays yours to read, edit or export, and every change is checkpointed so you can roll back.

Keep exploring
All ideas
Compare

How Netiva compares

All comparisons

Drafted with AI assistance from Netiva’s product pages and reviewed by the Netiva team. Example data models, screens and prompts are illustrative starting points, not customer projects.

Build your trading journal today

Describe it in a sentence and watch Netiva’s agent build it. Free to start — no credit card required.

Start building free Browse more ideas