Profitable trading relies more on position management than entry signals. Veskald lets you build entire trade lifecycles as editable rules instead of code, enabling rapid testing of exits, stops, and risk adjustments.
Being a profitable trader is less about entering well and more about what you do with the position once you are in. A good entry gives you direction. Everything after it - where the stop goes, when to take part off, when to lock in, when to admit the trade is going nowhere - decides what the trade earns and, more importantly, what it costs when it does not work.
That is why in Veskald a strategy is the whole trade, not a signal: every decision from the moment the conditions are met to the moment the position is flat. And it is why a strategy here is a set of rules instead of a program - a trade with this many decisions has to be something you can change and retest in minutes, or you will never test more than one version of it.
Trading tools come in two kinds.
The first is code. Serious engines, honest about costs if you configure them right, and every strategy is a script. To check a variation you edit the code and hope you did not break something. AI made writing fast, but the bugs did not go anywhere - they just stopped looking like bugs. A lookahead in an indicator, a stop checked before the entry on the same bar, a timezone shift in the data: the number comes out, and it is wrong in a way the equity curve will never show you. The cost moved from writing the code to trusting it.
The second is settings. Bot services and rule builders let you assemble a strategy without code. When we started building, none of them went further than an entry rule with a stop and a target. Some have caught up since - trailing, partial exits, indicator-driven closes. What still separates them from a research tool is what sits underneath: a test that does not count funding, sizing or slippage the way the exchange will, no way to see how a trade was counted, and no way to put two versions of the same trade management side by side and see which one survives out of sample.
The space between the two was empty when we started. That is what Veskald was built for: a strategy that is a full configuration - entry, risk, exits, all of it - tested by an engine that counts what the exchange will actually charge, and changed without touching code.
Think of it as the sequence of decisions a position goes through. Each one is a part of the strategy, and each one is a rule you write.
When to enter. Conditions across several timeframes, 15m to 1d - the 4h chart sets the direction, the 1h chart filters, the 15m chart gives the trigger. Indicators and candlestick patterns, combined with AND / OR groups of any depth. One rule of thumb built into the builder: an entry is an event - a cross, a breakout - not a state. A state is a filter.
When not to enter. Skip rules - conditions that block an entry even when the entry conditions are met. Do not enter if there is an RSI divergence against the trade. Do not enter when daily volatility is in its lowest third. Do not enter in the Asian session, or outside sessions at all. Almost every builder gives you IF; almost none gives you IF NOT, so "no entry on divergence" cannot even be written. The trades you do not take are part of the result, and a skip rule often does more for a strategy than any change to the entry.
Initial risk. Three kinds of stop: a percentage from entry, behind the nearest high or low of the last N candles, or on an indicator - ATR, Parabolic SAR, Supertrend, EMA. A safety corridor sets the minimum and maximum distance in percent, so the stop cannot land somewhere absurd. Position size and leverage are set so the liquidation price sits beyond the stop with a margin - the engine follows the exchange's own bracket table for that.
Taking profit in parts. Any number of take-profit levels, each with its share of the position and its own trigger - a multiple of risk or an indicator on a chosen timeframe. As each part closes, the stop volume shrinks with it.
Locking in. Break-even at a chosen R or on an indicator signal, computed with both commissions so that "zero" really is zero after fees.
Following the move. Trailing stop that starts immediately or only once the trade reaches a chosen R. It follows the same three ways as the stop: a percentage of price, the nearest high or low of the last N candles, or an indicator - with its own minimum and maximum distance.
Getting out early. Two independent rules, either or both: by time - the trade has not reached its first R target within N candles, close it - and by indicator on any timeframe. This is what separates a trade going nowhere from a trade going against you. A stop-and-target setup waits for the target and eats three or four full stops along the way; an early exit closes the dead ones at a fraction of a stop. The difference shows in drawdown more than in profit.
Adjusting after a series. Dynamic risk, off by default, per strategy: up to nine rules that raise or cut risk per trade by a chosen percent after a series of N outcomes of the types you pick - stop-loss, take-profit, break-even, trailing profit or loss, early exit profit or loss - or on an indicator, so size can follow volatility or trend strength instead of the last outcomes. Plus a rule for going back to base risk; without one, risk returns to base on the next trade.
Every one of these is readable in plain language when you open a strategy. Nothing is hidden in a script.
You test more versions. Changing a number is fast in a script too. What is slow in code is changing the structure of the trade: turn the trailing stop off and use take-profit levels instead, add an early exit, then remove it and add break-even, then bring the trailing back only after 1R. Each of those is a rewrite of the exit logic - and a new place for a bug. Here each is a switch and a rerun. A dozen structurally different versions of the same trade in an evening is a normal session.
You kill bad ideas faster. Most of finding an edge is killing what does not work. When a test costs a week of coding, you defend the idea because of the time already spent. When it costs minutes, you let it die and move on.
You think about the trade, not the code. Every hour spent on a data loader or a bug in the stop logic is an hour not spent on the actual question: does this way of managing the position capture what the entry gives, or give it back. The journal records every trade's maximum favorable and adverse excursion for exactly that question.
The machine can search too. A configuration is something an optimizer can vary. The genetic optimizer in Veskald goes through thousands of parameter combinations and scores them on the smoothness of the equity curve rather than maximum profit - one lucky trade means nothing.
Test and live cannot drift apart. The same configuration and the same functions run in both. One modelled difference: on history an entry is placed at the open of the next candle. Everything else - stops, sizing, leverage, exits - is identical code. There is no Python file slowly diverging from production.
It is not a strategy generator. Brute-forcing thousands of rule combinations and keeping the best-looking one is a machine for finding luck, and Veskald does not do that. The idea is yours; the platform makes engineering the trade around it cheap.
It is not less rigorous than code. The backtest counts fees, funding, slippage and the exchange's contract sizing. The engine is open per strategy - you can see and change how every trade is counted. "No code" describes how you write the rules, not how carefully they are tested.
It is not a way around thinking. A trade with no reason to work dies in the out-of-sample test no matter how well it is managed. Management decides how much a working idea earns and how much a failing one costs; it does not create an edge from nothing.
It is not a library of ready strategies to run. There is a public template library, filled by our research agent, and every template is open logic - you can read each rule and change it. It is a starting point to test on your own pairs and costs, not a signal to follow.
It is not a place for your own code inside the strategy. Rules have to stay readable and testable, so there is no script slot and no ML model between the conditions and the signal - that is the one honest limit of "rules, not code". What you do after the signal, on your side, is yours: a filter, a model, your own executor.
Say you trade breakouts by hand. First version, written down: entry on 4h close above the 20-day high, trend filter on 1d, stop below the last swing low, fixed target at 3R.
First run: profit factor 1.4, but the drawdown is ugly - long strings of full stops in ranging weeks. The trades were not wrong, they were dead, and the strategy sat in them until the stop.
Add an early exit: close after 12 candles if the trade has not reached 1R. Rerun. Drawdown halves, profit factor moves to 1.7. A couple of minutes.
Replace the fixed target with a third off at 1R, break-even, and a trailing stop on the 4h extreme for the rest. Rerun. Fewer full winners, more medium ones, smoother curve. Try trailing by percent instead. Worse. Back to the extreme.
Four versions, ten minutes, and the strategy is now a different and better thing than the one in your head. Then the out-of-sample check decides whether any of it is real. With code, most people never get past the first run.
Take a trade you already take by hand and write down everything you do with it - not just the entry. Where the stop goes and why. When you take partial profit. When you move to break-even. What makes you close early. If some of those are "depends on how it looks", that is worth knowing: a rule you cannot write is a rule you are not really following.
Veskald is a no-code platform for building, testing and running crypto futures strategies. Strategy building, backtesting, validation and analytics in one interface - and execution the way you want it: signals for trading by hand, a bot on your machine, or your own executor in between.
