Consensus on 1K Scanner — Official Blog

Review template: stop saying ‘the signal was wrong,’ log assumption/constraint/trigger instead

Mon, 02 Mar 2026 22:00:00 +0900

1k_scanner is not a document scanner. It is a Rust+egui based multi-market, multi-timeframe trading scanning app.

In post-trade reviews, people often write:

“The signal was wrong.”
“Indicators did not work today.”

The problem is simple: these lines explain the outcome, but they do not preserve a reusable decision process. So today’s template is:

“The signal was wrong” → Assumption / Constraint / Trigger

The focus is not prediction pride. It is preserving how you read the scene and why you acted.

1) Why “the signal was wrong” is weak review language

That sentence is result-oriented, not process-oriented.

The same loss can come from very different causes:

assumption was overstretched,
constraint (invalidation boundary) was too loose,
trigger (execution condition) was accepted too early.

If those are not separated, the same mistake returns under a new label.

2) The 3-line frame: Assumption / Constraint / Trigger

Keep every review note in three lines:

Assumption: how you read the market state
Constraint: where this interpretation becomes invalid
Trigger: what scene must appear before action

Example (long candidate):

Assumption: “Higher-timeframe persistence is still active; pullback may re-accelerate.”
Constraint: “If structure settles below NRZ, this idea is invalid.”
Trigger: “Keep candidate only after reaction above NRZ is re-confirmed; otherwise drop.”

You do not need perfect wording. You need statements that can be re-tested next session.

3) Fix the observation order: run → scan → focus → record

Review quality improves when live observation order is consistent:

Run: open app, load template (Cmd/Ctrl + L)
Scan: broad market pass in dense mode (Cmd/Ctrl + 7)
Focus: inspect candidates in expanded/single modes (Cmd/Ctrl + 8, Space)
Record: store evidence in Check Note (V, N)

When this order is stable, your review can clearly reconstruct why each decision happened.

4) Anchor your review to the grid model

In 1k_scanner, the visual model is:

Rows = timeframes
Columns = symbols

Use the same model in review:

read one column as one symbol’s MTF story,
compare columns to reprioritize candidates.

This prevents overreacting to one pretty candle and preserves context continuity.

5) Write EMA/NRZ as state sentences, not right/wrong verdicts

At user level, EMA/NRZ should stay observational:

EMA: is persistence still alive?
NRZ: holding or breaking?

Reusable review lines:

“EMA persistence remains, but waiting for cleaner NRZ re-validation.”
“Reaction near NRZ appeared, but holding quality was weak; lowered priority.”

These lines accelerate decision speed in the next session.

6) Treat consensus as candidate compression, not execution

In 1k_scanner, when multiple signals align, charts show green/red frame emphasis.

In review terms, this means:

not “execute now,”
but “review this candidate first.”

Operationally:

stronger emphasis → inspect sooner,
weak/neutral emphasis → defer or exclude faster.

Consensus is best used as attention allocation, not prediction certainty.

7) Combine Check Note + templates for repeatable review

In live markets, speed and repeatability matter most.

V: instantly add/toggle current chart in Check Note
N: open list and batch-edit notes

Then lock layout repeatability:

choose Grid Size, Timeframes per row, Exchange, run Generate Grid Template
save with F12 before session end
reload with Cmd/Ctrl + L next session

When this loop is fixed, your Assumption/Constraint/Trigger notes start matching real observed scenes.

8) Copy-paste 3-line review template

You can paste this directly into Check Note:

1
2
3
4
5
6
7
8


[Assumption]
- Why this symbol mattered today / market context:

[Constraint]
- Boundary that invalidates this interpretation:

[Trigger]
- Condition that decides keep vs drop next session:

The goal is not to grade the past. It is to maximize reusability of your decision process.

One final line:

“The signal was wrong” explains yesterday. “Assumption / Constraint / Trigger” prepares tomorrow.

Review is not a win/loss diary. It is design work for better next execution.

Screenshot + manifest: turning blurry chart captures into structured evidence

Mon, 02 Mar 2026 22:00:00 +0900

1k_scanner is not a document scanner. It is a Rust+egui based multi-market, multi-timeframe trading scanning app.

Most review failures look similar:

You kept screenshots, but forgot why they mattered.
The decision felt clear in real time, then looked vague later.
The same mistake repeated in the next session.

So this post defines screenshot + manifest as a visual style choice and, more importantly, as a decision-evidence routine.

1) Why screenshots alone become blurry evidence

Screenshots preserve scenes, not interpretation.

When the market moves fast, people often lose:

why a symbol was kept as a candidate,
how EMA/NRZ was interpreted at that moment,
what the next action was supposed to be.

That is why a manifest should stay simple: a short interpretation card attached to each screenshot.

2) Lock the visual model first: row=timeframe, column=symbol

In 1k_scanner, keep this model fixed:

Rows = timeframes
Columns = symbols

Following one column keeps one symbol’s MTF context intact. Moving across columns makes candidate comparison faster.

Then switch view modes quickly:

Cmd/Ctrl + 7: dense grid (broad scan)
Cmd/Ctrl + 8: expanded grid (focused review)
Space: single-chart focus toggle

The point is not “see more.” It is to repeat scan wide → validate deep.

3) Use EMA/NRZ as observation sentences, not formulas

At user level, EMA/NRZ can be reduced to two checks:

Is persistence still visible on EMA?
Around NRZ, does structure hold or break?

Do not force certainty. Record what you observed in one sentence.

Example notes:

“EMA persistence is intact, but waiting for cleaner NRZ re-entry.”
“Reaction above NRZ is alive, keep this candidate.”

Those short lines keep continuity in the next session.

4) Read consensus as a priority cue only

In 1k_scanner, when multiple signals align, you see green/red frame emphasis around charts.

For users, this means:

not an execution button,
but a fast way to narrow which candidates deserve immediate review.

Practical use:

stronger frame emphasis → review sooner,
weak/neutral emphasis → defer or drop faster.

So consensus should be treated as an attention-allocation tool, not a prediction shortcut.

5) Make screenshot + manifest one set with `V` and `N`

Speed matters in live sessions.

V: add/toggle current chart in Check Note
N: open Check Note list for batch review

A compact 3-line manifest is enough:

Why this became a candidate (context)
One-line EMA/NRZ interpretation
Next action (continue watching / validate on condition / exclude)

This turns screenshots from “images” into “evidence.”

6) Use templates to preserve repeatability

If you want consistency, lock the routine with templates:

Set Grid Size, Timeframes per row, Exchange, then run Generate Grid Template
Save session layout with F12
Reload next session with Cmd/Ctrl + L

A simple two-template setup works well:

scan template: broad candidate collection,
focus template: deep validation on a short list.

This removes setup drift between sessions.

7) Practical 12-minute loop

0:00–2:00 Load template (Cmd/Ctrl+L), scan in dense mode (Cmd/Ctrl+7)
2:00–4:00 Narrow candidates using consensus frame emphasis
4:00–7:00 Validate candidates in expanded/single modes (Cmd/Ctrl+8, Space)
7:00–10:00 Mark with V, review/edit manifest notes with N
10:00–12:00 Save next-session state with F12 and finalize keep/drop list

The goal is simple:

not more captures, but faster repeatable decisions under the same criteria.

One line to keep:

Screenshots preserve scenes. Manifests preserve decisions.

Use both together, and your next-session judgment gets faster.

Filters and sorting are not search engines: they are candidate-narrowing tools

Mon, 23 Feb 2026 22:00:00 +0900

1k_scanner is not a document scanner. It is a Rust+egui based multi-market, multi-timeframe trading scanning app.

The core idea is simple:

Instead of searching for the right entry, use scanning to narrow your attention to a small set of candidates that are worth a deeper review.

So this guide is about using filter/sorting signals (including consensus cues) as a candidate narrowing routine.

1) Why narrowing comes first

When you first open 1k_scanner, it looks like a lot of charts at once. That is not noise; it is the starting point for narrowing down.

If you open charts one by one, the question becomes: “Which chart should I check next?”

With a scanning workflow, the better question is: “Which symbols should I review thoroughly for the next 2–3 minutes?”

In practice, the consensus hotlist/cues and your routine act as the “filters/sorting” that answer that question.

2) One-minute reset: lock the grid mental model

The grid is built as:

Rows = timeframes
Columns = symbols

That means one column gives a multi-timeframe chain for the same symbol.

Now set the two core view modes:

Ctrl/Cmd + 7: dense grid
Ctrl/Cmd + 8: expanded grid

A practical loop:

Use dense grid (Ctrl/Cmd+7) for a broad scan.
Use expanded grid (Ctrl/Cmd+8) to reduce candidates for deeper checks.
Switch back if you need broader context again.

That is the essence of filtering: not seeing more, but deciding what to stop seeing.

3) 5-minute interpretation of EMA/NRZ: user-level use only

When many users first see EMA and NRZ, they may think these are “what to buy” signals. Use them as context checks instead.

EMA (persistence): quick read of how durable the larger directional context looks.
NRZ: quick read of whether pullback handling still feels structurally supported.

In practice, ask only two questions:

Is this candidate aligned with the larger flow?
Does the post-pullback structure look like it can hold, or is it already fracturing?

This keeps you from overfitting those two panes into instant actions.

4) Consensus signal: what the directional frame cue actually means

Consensus is not an execution signal.

Interpret it this way in daily use:

If multiple signs line up, you get a directional frame cue (long/short emphasis).
If signals are mixed, neutral, or weak, you get low-emphasis behavior.

Even with a strong directional cue:

It does not mean “enter now.”
It means “this is the next set to validate.”

Even with neutral/mixed cues:

It does not mean “take the opposite trade immediately.”
It may simply mean “watch less aggressively or pause.”

Consensus is, in short, a way to allocate attention and review time.

5) Focus happens through Space

After you narrow to a few candidates, move from scan to focused validation.

Space: toggle single chart mode.
Keep moving within row/column so one symbol’s timeframes stay grouped.

Prefer this sequence over immediate action:

Narrow in filter stage
Validate in single-chart stage
Return to list and repeat

This loop is where consistency comes from.

6) Check-note routine: `V` to save, `N` to review

Most misses are not because the right symbol was absent. They happen because the observation rhythm was not captured.

Use this compact loop:

V: add/toggle the current chart in check-note.
N: open the CheckNote section and review.

A simple 3-line format is enough:

Why this symbol became a candidate.
What was seen at the EMA/NRZ level.
Next action (observe more / execute setup / defer).

This removes the “I forgot the reason” problem next session.

7) Template is your operation repeatability layer

If you skip this, your routine collapses after the first good session.

Create template
- Set Grid Size, Timeframes per row, Exchange, then run Generate Template (by size).
Save layout
- F12 stores the current workspace layout.
Load layout
- Ctrl/Cmd + L opens the load dialog next time.

At first, use two templates:

Scan template: wide coverage for candidate collection.
Focus template: fewer charts for in-depth checking.

That is your filtering pipeline in practice.

8) Practical 10-minute routine

0:00–1:30 Verify tab and grid state after launch.
1:30–3:30 Scan broadly in dense mode (Ctrl/Cmd+7).
3:30–5:30 Use EMA/NRZ as context checks to prioritize candidates.
5:30–7:00 Narrow candidates using the directional consensus cue.
7:00–9:00 Focus with Space on 2–3 candidates and mark V.
9:00–10:00 Review with N, then save/load layout (F12, Ctrl/Cmd+L).

When you treat filtering this way, 1k_scanner becomes less about finding the perfect chart and more about protecting your decision rhythm.

Use it not to chase signals, but to keep your observation consistent.

Why the Same Pattern Can End Differently: A 3-Step Context Routine

Sun, 22 Feb 2026 22:11:39 +0900

You can see the same shape many times and still read it differently. The result changes because context changes: where the chart sits, how the larger flow is behaving, and whether the pullback is holding structure.

This post does not present a new entry method. It focuses on what to review first and how to decide candidate priority from a workflow perspective.

1) Scan wide first: why dense mode should come first

1-1) What to do right after launch

After opening the app, check the loaded workspace first. A stable routine starts with this order:

Ctrl/Cmd + 7: switch to dense grid and scan a wider candidate field.
Ctrl/Cmd + 8: switch to expanded grid to narrow focus.
Space: expand the current chart for deeper verification.

1-2) Column and row logic

A common confusion is to read rows and columns in the wrong orientation. In practice, the layout works as column = symbol, row = timeframe. So one column lets you read one symbol’s flow across multiple horizons from top to bottom.

When the same pattern is judged differently, it is often because the column-level comparison is inconsistent. Start by comparing candidates column by column.

2) For the same pattern, the useful lens is context, not a truth label

Use the same two references only as lenses:

EMA/NRZ are not entry switches.
EMA (persistence view): a first pass to estimate whether momentum can be sustained.
NRZ: a context check on whether pullback behavior still keeps structure.

The practical point is this: they help you rank observation candidates, not replace your decision.

2-1) A context checklist when outcome differs

Even if a chart shape is similar, reading changes when one of these differs:

Does the candidate match the broader context in that same column?
Is structure still being held after pullback?
Is this candidate “watch now” or “defer” in your own sequence?

This prevents emotional selection and keeps the workflow objective.

3) The practical meaning of consensus cues (border color)

Many users treat consensus as a direct action trigger. In this context, it is better understood as an attention allocation cue.

When several signals point in the same direction, the border tends to show a clear directional frame (long/short emphasis) and becomes a stronger focus candidate.
If signals are mixed, neutral, or noisy, the cue is often low-emphasis, so you usually move it to “wait” or “hold-off.”

When consensus appears, the right action is still not immediate entry. It is candidate filtering plus next-step verification.

4) Routine for same-pattern cases: scan → focus → record

4-1) Scan phase (about 2 minutes)

Start with Ctrl/Cmd + 7 to widen the candidate view.
Confirm the same symbol is aligned by column.
Before deep zoom, compare timeframe continuity in that column first.

4-2) Focus phase (1~2 minutes)

Read top-to-bottom within the candidate column.
Keep only likely candidates.
Use Ctrl/Cmd + 8 to narrow the board and preserve attention.

4-3) Record phase (30 seconds)

Do not overfit a decision in one glance. Record it.

V: toggle check-note on the current chart.
N: open the CheckNote section and review recent candidate logic.

A short one-line note for why you skipped or kept a candidate is enough to preserve continuity into the next session.

5) Fix your workflow with templates

If you recreate the setup manually every time, workflow drift increases. Keep it stable through templates.

Set Grid Size, Timeframes per row, and Exchange, then run Generate Template (by size)
Save with F12
Load later with Ctrl/Cmd + L

Having separate templates for scan mode and focus mode reduces startup noise before markets move.

Closing

The same pattern is not the same outcome. For stable execution, use the 3-step loop: scan wide, focus deep, and record decisions.

Remember: 1k_scanner is not a document scanner. It is a Rust+egui-based multi-market, multi-timeframe trading scanning app.

Drop the mouse: keyboard workflow is how you actually scan 1,080 charts

Fri, 20 Feb 2026 21:50:00 +0900

In trading, the first question is rarely “which chart to open next.” It is usually: what should I evaluate first?

In 1k_scanner, keyboard-first workflows reduce context switching and keep your observation order stable. This post is a practical 10-minute routine you can use immediately in a 1,080-chart environment.

1) Start routine: first 30 seconds after launch

Use this order whenever you launch the app.

Confirm current tab and grid state
- Check whether the loaded workspace is the one you want to work with.
- If not, return to your scanning view first.
Begin with a wide view for candidate selection
- Ctrl/Cmd + 7: dense grid (many symbols at once)
- Ctrl/Cmd + 8: expanded grid (focus on fewer symbols)
Lock the grid mental model
- The grid is built as rows = timeframes, columns = symbols.
- A single column gives a multi-timeframe sequence for one symbol, so comparison is faster and less fragmented.

Completing this pre-check keeps the process from turning into random clicking and turns it into a structured sequence of questions.

2) First pass scanning: treat EMA/NRZ as context checks

How to read EMA/NRZ without overfitting

Use EMA (persistence view) as a clue for how durable the current flow looks.
Use NRZ as a clue for whether pullback handling is coherent enough to stay in the setup.

At this stage, use only two operational questions:

Is this candidate aligned with the larger directional context?
Is the pullback showing structure that can hold, or is it already losing coherence?

Read consensus signals as filter signals, not entry signals

For many users, this is the most important shift.

When multiple observations point in the same direction, the symbol receives a directional frame cue (long/short color and stronger emphasis).
When directional input is mixed, neutral, or weak, the symbol is less emphasized (often no strong frame cue).

The key is not “consensus = guaranteed entry.” The key is “consensus helps me narrow which names deserve close review.”

So do not lock entry decisions there. Use consensus as a candidate filtering step first.

3) Focus routine: scan → expand → decode

After candidates are narrowed:

Move the focus with arrow keys or W/A/S/D.
Use Space to toggle single-chart expansion.
Refine checks within that symbol across nearby time windows.
Switch between Ctrl/Cmd + 7 and Ctrl/Cmd + 8 to balance breadth and focus.

In expanded mode, do not jump to action immediately. First lock the larger context in the same column, then confirm pullback/structure behavior in lower frames.

4) Check-note routine: V to add, N to review

A 1,080-chart workflow helps you see more, but memory can still fragment. Use this note loop to prevent that.

V: add or toggle current chart in Check Note.
N: open the CheckNote section and review.

A simple note template:

Why this symbol became a candidate (one line)
Why it is rejected or delayed (one line)
Next check plan (one line)

This is lightweight, but it preserves your decision history and avoids losing rationale between sessions.

5) Template workflow: keep scanning reproducible

Even the cleanest keyboard rhythm is unstable without repeatable templates.

Generate template: set Grid Size, Timeframes per row, Exchange, then run Generate Template (by size)
Save layout: persist the current workspace view with F12
Load layout: reopen a saved layout with Ctrl/Cmd + L

Two templates are enough to start:

Scanning template: broad symbol coverage for fast narrowing
Focus template: fewer symbols with larger spacing for detailed review

6) 10-minute repeatable checklist

First 2 minutes

Launch app and confirm workspace
Open dense grid with Ctrl/Cmd+7
Trim to ~8–12 candidates from consensus frame cues

Next 4 minutes

Read each candidate by symbol column (row-by-timeframe, column-by-symbol)
Check EMA/NRZ for persistence + pullback coherence
Keep consensus cues at “priority” level only, not entry-level yet

Next 3 minutes

Expand each candidate with Space
Add notes with V
Exclude weak candidates and log the reason

Final 1 minute

Open N and close the loop on notes
Save/load your routine layout for next session

1k_scanner is not a document scanner. It is a Rust+egui based multi-market, multi-timeframe trading scanning app. It is designed so you can reduce how much you have to search manually and focus your attention on the candidates that are worth your next decision cycle.

Avoid Countertrend Traps with Multi-Timeframe Consensus — a 3-minute routine with 1k_scanner

Tue, 10 Feb 2026 10:25:27 +0900

Sometimes the setup looks perfect on 1m/5m… and then you get slammed instantly.

That’s usually not “bad execution”. It’s timeframe mismatch.

Lower TF (1m/5m): creates an entry trigger
Higher TF (1h/4h): decides the direction, levels, and available space

If only the lower TF is flashing, it’s often a trap. If higher TFs open the path, execution becomes much simpler.

What I mean by “consensus” (one-line definition)

Consensus = multiple timeframes telling the same story.

A practical trio:

15m: a trigger appears (structure shift / breakout / channel break)
1h: the bias is aligned (trend holds, or a clean pullback context)
4h: you’re near a meaningful level and there’s room to move

When these agree, it stops being “vibes”. It becomes a probability game.

The 3-minute routine (Observe → Checklist → Execute/Manage)

1) Observe (1 min): reduce the candidate set first

Most losses don’t come from “too many charts”. They come from seeing just enough to keep clicking.

1k_scanner is not an entry system. It’s a target selector: it helps you find where your entry system is worth applying.

2) Checklist (1 min): pass 3 checks, then you’re allowed to trade

Copy/paste this:

Checklist (copy/paste)

4h: Are we near a major level (prev high/low, VWAP/pivots, supply/demand zone)?
1h: Is the trend/bias intact (or is the pullback context clean)?
15m: Do we have a real trigger (structure shift, breakout, channel/line break)?

Decision rule:

Lower TF only → pass
Higher TF opens the path → keep as a candidate

3) Execute (30 sec): write invalidation first

The fastest way to trade cleaner is to define exits before entries.

Examples:

15m invalidation: the swing structure breaks → OUT
1h invalidation: pullback thesis fails / flips → OUT
4h invalidation: rejection at key level fails → OUT

Your stop isn’t a feeling. It’s a rule.

4) Manage (30 sec): consensus breaks → you leave

That’s it. If consensus breaks, you’re done.

Closing

The goal isn’t to stare at charts longer. It’s to decide faster with fewer regrets.

Multi-timeframe consensus is a simple filter. And 1k_scanner turns that filter from “manual scanning” into a system.

Consensus on 1K Scanner — Official Blog

Review template: stop saying ‘the signal was wrong,’ log assumption/constraint/trigger instead

1) Why “the signal was wrong” is weak review language

2) The 3-line frame: Assumption / Constraint / Trigger

3) Fix the observation order: run → scan → focus → record

4) Anchor your review to the grid model

5) Write EMA/NRZ as state sentences, not right/wrong verdicts

6) Treat consensus as candidate compression, not execution

7) Combine Check Note + templates for repeatable review

8) Copy-paste 3-line review template

Screenshot + manifest: turning blurry chart captures into structured evidence

1) Why screenshots alone become blurry evidence

2) Lock the visual model first: row=timeframe, column=symbol

3) Use EMA/NRZ as observation sentences, not formulas

4) Read consensus as a priority cue only

5) Make screenshot + manifest one set with V and N

6) Use templates to preserve repeatability

7) Practical 12-minute loop

Filters and sorting are not search engines: they are candidate-narrowing tools

1) Why narrowing comes first

2) One-minute reset: lock the grid mental model

3) 5-minute interpretation of EMA/NRZ: user-level use only

4) Consensus signal: what the directional frame cue actually means

5) Focus happens through Space

6) Check-note routine: V to save, N to review

7) Template is your operation repeatability layer

8) Practical 10-minute routine

Why the Same Pattern Can End Differently: A 3-Step Context Routine

1) Scan wide first: why dense mode should come first

1-1) What to do right after launch

1-2) Column and row logic

2) For the same pattern, the useful lens is context, not a truth label

2-1) A context checklist when outcome differs

3) The practical meaning of consensus cues (border color)

4) Routine for same-pattern cases: scan → focus → record

4-1) Scan phase (about 2 minutes)

4-2) Focus phase (1~2 minutes)

4-3) Record phase (30 seconds)

5) Fix your workflow with templates

Closing

Drop the mouse: keyboard workflow is how you actually scan 1,080 charts

1) Start routine: first 30 seconds after launch

2) First pass scanning: treat EMA/NRZ as context checks

How to read EMA/NRZ without overfitting

Read consensus signals as filter signals, not entry signals

3) Focus routine: scan → expand → decode

4) Check-note routine: V to add, N to review

5) Template workflow: keep scanning reproducible

6) 10-minute repeatable checklist

First 2 minutes

Next 4 minutes

Next 3 minutes

Final 1 minute

Avoid Countertrend Traps with Multi-Timeframe Consensus — a 3-minute routine with 1k_scanner

What I mean by “consensus” (one-line definition)

The 3-minute routine (Observe → Checklist → Execute/Manage)

1) Observe (1 min): reduce the candidate set first

2) Checklist (1 min): pass 3 checks, then you’re allowed to trade

3) Execute (30 sec): write invalidation first

4) Manage (30 sec): consensus breaks → you leave

Closing

5) Make screenshot + manifest one set with `V` and `N`

6) Check-note routine: `V` to save, `N` to review