Workflow synchronization just got a whole lot easier with our new Wait for Workers worker! This powerful addition to the ApudFlow platform allows you to coordinate parallel workflow branches and ensure operations run in the correct order.

What is Wait for Workers?​

The Wait for Workers worker monitors the execution status of other workers in your workflow and waits until all specified workers have completed their tasks. It's perfect for scenarios where you need to:

• Synchronize parallel data processing branches
• Wait for multiple API calls to complete
• Coordinate dependent operations
• Ensure data availability before proceeding

How It Works​

Auto-Detection Mode (Recommended)​

Simply connect workers to your Wait for Workers node, and it will automatically detect and monitor all connected workers. No manual configuration needed!

Manual Mode​

For advanced use cases, you can manually specify worker IDs to wait for specific workers that may not be directly connected.

Key Features​

• Automatic Detection: Intelligently detects connected workers from workflow topology
• Real-time Monitoring: Periodically checks worker status in the database
• Timeout Protection: Configurable timeout to prevent infinite waiting
• Error Handling: Optional failure on any worker error
• Parallel Coordination: Perfect for synchronizing multiple parallel branches

Configuration Parameters​

Return Values​

The worker returns a comprehensive status report:

{
  "completed": ["worker_id_1", "worker_id_2"],
  "failed": [],
  "timeout": false,
  "total_waited": 2.5,
  "auto_detected": true
}

Example Use Case​

Imagine you have a workflow that:

1. Fetches stock data from Yahoo Finance
2. Simultaneously processes the data with an LLM for analysis
3. Needs both results before generating a final report

With Wait for Workers, you can ensure the final report generation waits for both the data fetch AND the LLM analysis to complete.

Getting Started​

1. Add a "Wait for Workers" node to your workflow
2. Connect your parallel workers to the wait node
3. Configure timeout and error handling preferences
4. Connect the wait node to your downstream processing

The worker will automatically detect and wait for all connected workers to complete!

Watch the Tutorial​

For a visual guide on how to use the Wait for Workers worker, check out our tutorial video:

How to Use Wait for Workers

This new worker significantly simplifies workflow coordination and makes building complex, parallel processing pipelines much more intuitive. Try it out in your next workflow!

ApudFlow now supports MongoDB for document storage with built-in user isolation. Whether you're building user profiles, storing analytics data, or managing content, MongoDB workers provide flexible document storage with automatic security.

What is MongoDB?​

MongoDB is a document database that stores data in flexible, JSON-like documents. Unlike traditional relational databases, MongoDB allows you to store complex, nested data structures without predefined schemas.

Key Features​

Automatic User Isolation​

Every document is automatically tagged with your user ID, ensuring complete data separation between users. No cross-tenant data leaks or security concerns.

Two Connection Modes​

• Internal Mode: Managed connection with a single built-in collection. No setup required - start storing data instantly.
• External Mode: Connect to your own MongoDB database and collections for full control.

Rich Query Capabilities​

Perform complex queries using MongoDB's powerful query language. Filter by any field, use regex patterns, and aggregate data across documents.

What Can You Use It For?​

User Data Management​

Store user profiles, preferences, and settings. Perfect for applications that need to maintain user-specific data across sessions.

Example: Store user trading preferences
- operation: insert
- document: {"theme": "dark", "defaultTimeframe": "1H", "alertsEnabled": true}

Example: User notification settings
- operation: insert
- document: {
  "emailNotifications": true,
  "smsAlerts": false,
  "notificationTypes": ["price_alerts", "news", "portfolio_updates"],
  "quietHours": {"start": "22:00", "end": "08:00"}
}

Analytics and Metrics​

Collect and analyze usage data, performance metrics, or business intelligence data. MongoDB's flexible schema makes it easy to evolve your data structure as needs change.

Example: Track user interactions
- operation: insert
- document: {"action": "chart_view", "symbol": "AAPL", "timestamp": "2025-10-21T10:00:00Z"}

Example: Performance analytics
- operation: insert
- document: {
  "workflowId": "market_scanner",
  "executionTime": 2.3,
  "dataPoints": 15420,
  "success": true,
  "timestamp": "2025-10-21T10:00:00Z"
}

Example: A/B test results
- operation: insert
- document: {
  "testId": "new_ui_layout",
  "variant": "A",
  "userId": "user123",
  "conversion": true,
  "timeSpent": 45
}

Content Management​

Store articles, blog posts, comments, or any structured content. The document model is perfect for content with varying fields and nested data.

Example: Save analysis reports
- operation: insert
- document: {
  "title": "Q4 Earnings Analysis",
  "content": "...",
  "tags": ["earnings", "analysis"],
  "metadata": {"wordCount": 1250, "readTime": 6}
}

Example: Product catalog
- operation: insert
- document: {
  "name": "Premium Analytics Package",
  "description": "Advanced market analysis tools",
  "pricing": {"monthly": 49.99, "yearly": 499.99},
  "features": ["real-time data", "custom indicators", "alerts"],
  "category": "analytics"
}

Workflow State Persistence​

Save intermediate workflow results, cache expensive computations, or maintain state between workflow runs.

Example: Cache API responses
- operation: insert
- document: {"endpoint": "/api/market-data", "response": {...}, "cachedAt": "2025-10-21T10:00:00Z"}

Example: Workflow checkpoints
- operation: insert
- document: {
  "workflowId": "data_import_001",
  "step": "data_validation",
  "progress": 75,
  "lastProcessedId": 15420,
  "errors": []
}

E-commerce Applications​

Manage product inventories, customer orders, and shopping cart data with complex nested structures.

Example: Order management
- operation: insert
- document: {
  "orderId": "ORD-2025-001",
  "customerId": "user123",
  "items": [
    {"productId": "AAPL", "quantity": 100, "price": 150.25},
    {"productId": "GOOGL", "quantity": 50, "price": 2800.00}
  ],
  "total": 140125.00,
  "status": "pending"
}

IoT and Sensor Data​

Store time-series data from sensors, devices, or monitoring systems with flexible schemas.

Example: Sensor readings
- operation: insert
- document: {
  "deviceId": "sensor_001",
  "timestamp": "2025-10-21T10:00:00Z",
  "readings": {
    "temperature": 23.5,
    "humidity": 65.2,
    "pressure": 1013.25
  },
  "location": {"lat": 40.7128, "lng": -74.0060}
}

Gaming and User Progress​

Track player statistics, achievements, inventory, and game state with nested data structures.

Example: Player profile
- operation: insert
- document: {
  "playerId": "player123",
  "level": 25,
  "experience": 15420,
  "inventory": [
    {"item": "golden_pickaxe", "quantity": 1},
    {"item": "diamond_ore", "quantity": 50}
  ],
  "achievements": ["first_trade", "profit_master", "speed_trader"]
}

Financial Markets & Trading​

Store complex financial data, trading strategies, market analysis, and portfolio management information with flexible document structures.

Example: Trading strategy configuration
- operation: insert
- document: {
  "strategyName": "Momentum Crossover",
  "parameters": {
    "fastPeriod": 9,
    "slowPeriod": 21,
    "stopLoss": 0.02,
    "takeProfit": 0.05
  },
  "symbols": ["AAPL", "MSFT", "GOOGL"],
  "active": true,
  "performance": {"winRate": 0.68, "avgReturn": 0.034}
}

Example: Portfolio holdings
- operation: insert
- document: {
  "portfolioId": "growth_portfolio",
  "holdings": [
    {"symbol": "AAPL", "shares": 150, "avgPrice": 145.20, "currentValue": 22530.00},
    {"symbol": "MSFT", "shares": 75, "avgPrice": 280.50, "currentValue": 21037.50}
  ],
  "totalValue": 43567.50,
  "lastUpdated": "2025-10-21T10:00:00Z"
}

Example: Market analysis reports
- operation: insert
- document: {
  "symbol": "AAPL",
  "analysisType": "technical",
  "indicators": {
    "rsi": 65.4,
    "macd": {"signal": 2.15, "histogram": 0.85},
    "movingAverages": {"sma20": 152.30, "sma50": 148.75}
  },
  "recommendation": "BUY",
  "confidence": 0.82,
  "generatedAt": "2025-10-21T10:00:00Z"
}

Example: Trade execution log
- operation: insert
- document: {
  "tradeId": "T20251021001",
  "symbol": "AAPL",
  "side": "BUY",
  "quantity": 100,
  "price": 150.25,
  "timestamp": "2025-10-21T10:00:00Z",
  "strategy": "momentum_crossover",
  "fees": 1.50,
  "executionDetails": {
    "venue": "NASDAQ",
    "orderType": "MARKET",
    "slippage": 0.05
  }
}

Example: Risk management data
- operation: insert
- document: {
  "riskProfile": "moderate",
  "positionLimits": {
    "maxSinglePosition": 0.1,
    "maxSectorExposure": 0.25,
    "maxDrawdown": 0.15
  },
  "varCalculation": {
    "confidence": 0.95,
    "timeHorizon": 1,
    "value": 12500.00
  },
  "lastAssessment": "2025-10-21T10:00:00Z"
}

Example: Economic indicators database
- operation: insert
- document: {
  "indicator": "GDP_Growth",
  "country": "US",
  "frequency": "quarterly",
  "values": [
    {"date": "2025-Q2", "value": 2.1, "forecast": 2.3},
    {"date": "2025-Q3", "value": null, "forecast": 2.0}
  ],
  "source": "Bureau of Economic Analysis",
  "lastUpdated": "2025-10-21T10:00:00Z"
}

Getting Started​

1. Add a "MongoDB" worker to your flow
2. Choose connection mode (internal for quick start, external for custom setup)
3. Select operation (insert, find, update, delete, count)
4. Configure your document or query parameters

Example Workflow: User Portfolio Tracker​

Create a workflow that:

1. Fetches user portfolio data from an API
2. Stores it in MongoDB with user isolation
3. Updates analytics counters
4. Sends notifications based on stored preferences

This combination of document storage with workflow automation opens up endless possibilities for data-driven applications.

Performance & Scalability​

MongoDB excels at handling large volumes of data with fast read/write operations. The document model scales naturally as your data structure evolves, making it perfect for growing applications.

Start building with MongoDB today and unlock the power of flexible document storage in your workflows!

ApudFlow now includes Redis support for high-performance key-value storage. Perfect for caching, session management, and real-time data operations that require speed and reliability.

What is Redis?​

Redis is an in-memory data structure store used as a database, cache, and message broker. It provides sub-millisecond response times and supports various data structures like strings, hashes, lists, sets, and more.

Key Features​

Lightning Fast Performance​

Redis stores data in memory, delivering microsecond response times. Perfect for applications requiring instant data access.

Rich Data Structures​

Beyond simple key-value pairs, Redis supports:

• Strings (text, numbers, binary data)
• Hashes (field-value objects)
• Lists (ordered collections)
• Sets (unique value collections)
• Sorted sets (ranked collections)

Automatic Expiration​

Set TTL (time-to-live) on keys for automatic cleanup. Perfect for temporary data like sessions, cache entries, and rate limiting.

User Isolation​

All keys are automatically prefixed with your user ID, ensuring complete data separation and security.

What Can You Use It For?​

Caching API Responses​

Speed up your workflows by caching expensive API calls, database queries, or computational results.

Example: Cache market data
- operation: set
- key: "market_data_AAPL"
- value: {"price": 150.25, "volume": 4523000}
- ttl: 300 (5 minutes)

Session Management​

Store user session data, preferences, and temporary state with automatic expiration.

Example: User session storage
- operation: set
- key: "session_12345"
- value: {"userId": 12345, "lastActivity": "2025-10-21T10:00:00Z"}
- ttl: 3600 (1 hour)

Rate Limiting​

Implement rate limiting for API calls, user actions, or workflow executions.

Example: API rate limiting
- operation: incr
- key: "api_calls_user_12345"
- value: 1
- Then check if value exceeds your limit

Real-Time Analytics​

Track counters, metrics, and statistics with atomic operations.

Example: Page view tracking
- operation: incr
- key: "page_views_dashboard"
- value: 1

Leaderboards and Rankings​

Use sorted sets for gaming leaderboards, popularity rankings, or priority queues.

Example: Trading volume leaderboard
- operation: set (with sorted set operations)
- key: "trading_volume"
- Add scores for different symbols

Message Queues​

Implement simple message queues for background processing or event handling.

Example: Notification queue
- operation: set (using lists)
- key: "notification_queue"
- Push messages for later processing

Getting Started​

1. Add a "Redis" worker to your flow
2. Choose operation (set, get, delete, list, exists, incr, expire)
3. Configure key, value, and optional parameters like TTL

Example Workflow: Smart Caching System​

Create a workflow that:

1. Checks Redis cache for data
2. If cache miss, fetches from external API
3. Stores result in Redis with TTL
4. Returns cached or fresh data

This pattern dramatically improves performance and reduces API costs.

Performance Benefits​

Redis typically delivers:

• 100x faster than traditional databases for simple operations
• Sub-millisecond latency for most operations
• High throughput (100k+ operations per second)
• Atomic operations ensuring data consistency

Use Cases by Industry​

Finance & Trading​

• Real-time price caching
• Portfolio position storage
• Rate limiting for trading APIs
• Session management for trading platforms
• Order book management
• Trade execution tracking
• Risk limit monitoring
• Market data snapshots
• Alert system state
• Trading strategy parameters
• Historical price buffers
• Account balance caching
• Margin requirement tracking
• Stop-loss order management
• Arbitrage opportunity detection

Algorithmic Trading Excellence
Redis excels in algorithmic trading due to its lightning-fast access speeds and atomic operations. High-frequency trading strategies require microsecond response times for market data, order execution, and risk management. Redis enables real-time strategy execution, instant position updates, and rapid arbitrage detection across multiple exchanges. Its pub/sub capabilities allow for real-time signal broadcasting to multiple trading algorithms, while sorted sets efficiently manage order books and priority queues for trade execution.

In algorithmic trading, every millisecond counts. Redis's in-memory storage eliminates disk I/O bottlenecks, ensuring strategies can react instantly to market movements. Complex algorithms can maintain state across multiple timeframes, track position sizes with atomic increments, and implement sophisticated risk controls. The ability to expire keys automatically handles time-sensitive data like quotes and orders, while Redis clustering provides the scalability needed for high-volume trading operations. Whether you're running statistical arbitrage, market making, or momentum strategies, Redis provides the performance foundation that separates profitable algorithms from those that lag behind.

E-commerce​

• Shopping cart storage
• Product catalog caching
• User session management
• Inventory counters

Gaming​

• Player statistics
• Leaderboards
• Session storage
• Achievement tracking

Analytics​

• Event counting
• User behavior tracking
• A/B test results
• Real-time dashboards

Redis brings enterprise-grade performance to your workflows. Start using it today for faster, more reliable data operations!

Finding your Telegram Chat ID takes less than 2 minutes. Here's how to do it end-to-end inside Apudflow.

Prerequisites​

• Telegram app installed (mobile or desktop)
• Our bot available in Telegram: apudflow_bot
• Apudflow account (to paste the ID into the form)

Step-by-step​

1. Open Telegram, search for “apudflow_bot”.
2. Open the chat and tap Start (/start).
   • The bot immediately replies with your Chat ID.
3. Copy the Chat ID the bot returned.
4. In Apudflow, open the flow step with the “Telegram Notify” worker and paste the number into the “Chat ID” field.
5. Click run/test — you should receive a message in Telegram.

• Group chat IDs

  • Add the bot to the group. If you have the webhook enabled, send /id in the group. The bot will reply with the group chat_id (usually a negative number).

• Channel IDs

  • Make the bot an Administrator of the channel first (required).
  • Public channel: you can use the @channel_username as Chat ID.
  • Private channel: use the numeric id starting with -100… (get it by sending /id after the webhook is active, or with a utility bot like @getidsbot).

That's it! Your Chat ID is now saved in your flow, and you can receive alerts from your automations.

You can send messages and images to Telegram directly from your flows. This guide covers setup, formatting, and common pitfalls.

What you can send​

• Text messages
• Image by URL (photoUrl): text becomes the photo caption
• Markdown formatting (always on)

Configure the worker​

In your flow, add the step “Telegram Notify” and fill these fields:

• Chat ID: The numeric ID you got from the bot (see the Get Chat ID post) or @channel_username for public channels
• Text: Message content (or caption when photoUrl is provided)
• Photo URL (optional): A direct URL to an image
• Disable link preview: Turn off webpage previews in text messages

Quick example​

• Chat ID: 123456789
• Text: "Alert: price crossed 200-day MA"
• Photo URL: https://example.com/chart.png

Result: You’ll receive a photo with the text as its caption.

Financial market use cases and templates​

Here are practical ways to use Telegram alerts for trading and portfolio workflows, plus ready-to-copy message ideas.

• Moving average crossovers

  • Template: ALERT: {TICKER} crossed above 200D MA at ${price} (RVOL {rvol}x)
  • Example: "ALERT: NVDA crossed above 200D MA at $142.50 (RVOL 1.8x)"

• Breakout signals

  • Template: Breakout: {TICKER} closed above {level} on {tf} with {rvol}x RVOL
  • Example: "Breakout: AAPL closed above $225 on 4H with 2.1x RVOL"

• RSI divergence signals

  • Template: Signal: {TICKER} RSI {rsi} ({side}) on {tf}; MACD {macd_state}
  • Example: "Signal: NVDA RSI 72 (overbought) on 1H; MACD bullish"

• Bollinger Band squeeze/expansion

  • Template: BB Squeeze: {TICKER} bandwidth {bw}% — watch for expansion
  • Example: "BB Squeeze: ETH bandwidth 4.2% — watch for expansion"

• Volume spikes / Relative Volume

  • Template: RVOL spike: {TICKER} {rvol}x vs 20D avg; {volume} shares traded
  • Example: "RVOL spike: AMD 2.7x vs 20D avg; 38M shares traded"

• Earnings and macro calendar

  • Template: Today: {TICKER} earnings {time} — Cons: Rev {rev_c}, EPS {eps_c}
  • Example: "Today: MSFT earnings 21:30 CET — Cons: Rev $64.5B, EPS $2.71"

• Portfolio and risk alerts

  • Template: PnL: D {pnl_d}% | MTD {pnl_mtd}% | DD {dd}% | VaR {var}%
  • Example: "PnL: D -1.2% | MTD +3.4% | DD 5.4% | VaR 1.1%"

• Stop-loss / Take-profit hits

  • Template: Exit: {TICKER} {side} at ${price} — {reason} (SL/TP)
  • Example: "Exit: TSLA long at $239.50 — SL hit"

• Unusual options activity / IV changes

  • Template: UOA: {TICKER} {flow} — IVR {ivr}, IV {iv}%
  • Example: "UOA: SPY call flow — IVR 78, IV 23%"

• FX levels and macro indicators

  • Template: FX: {PAIR} tap {level} | {indicator} {value}
  • Example: "FX: EURUSD tap 1.1000 | PMI 52.3"

• Crypto funding/liquidations/on-chain

  • Template: Crypto: {COIN} funding {funding}% | Liq {liq_usd} | NVT {nvt}
  • Example: "Crypto: BTC funding 0.03% | Liq $120M | NVT 48"

• Spread/arb setups

  • Template: Spread: {A}/{B} z-score {z} | {tf}
  • Example: "Spread: GLD/GDX z-score 2.1 | D1"

• End-of-day summary

  • Template: EoD: Top± {top_plus}/{top_minus} | PnL {pnl_d}% | Positions {n}
  • Example: "EoD: Top± NVDA +4.1% / T -3.7% | PnL +0.9% | Positions 12"- Breakouts and S/R touches
  • Template: Breakout: {TICKER} closed above {level} on {tf} with {rvol}x RVOL
  • Example: "Breakout: BTC closed above 65,000 on 4H with 3.1x RVOL"

• RSI/MACD signals and divergences

  • Template: Signal: {TICKER} RSI {rsi} ({side}) on {tf}; MACD {macd_state}
  • Example: "Signal: NVDA RSI 72 (overbought) on 1H; MACD bullish"

• Bollinger Band squeeze/expansion

  • Template: BB Squeeze: {TICKER} bandwidth {bw}% — watch for expansion
  • Example: "BB Squeeze: ETH bandwidth 4.2% — watch for expansion"

• Volume spikes / Relative Volume

  • Template: RVOL spike: {TICKER} {rvol}x vs 20D avg; {volume} shares traded
  • Example: "RVOL spike: AMD 2.7x vs 20D avg; 38M shares traded"

• Earnings and macro calendar

  • Template: Today: {TICKER} earnings {time} — Cons: Rev {rev_c}, EPS {eps_c}
  • Example: "Today: MSFT earnings 21:30 CET — Cons: Rev $64.5B, EPS $2.71"

• Portfolio and risk alerts

  • Template: PnL: D {pnl_d}% | MTD {pnl_mtd}% | DD {dd}% | VaR {var}%
  • Example: "PnL: D -1.2% | MTD +3.4% | DD 5.4% | VaR 1.1%"

• Stop-loss / Take-profit hits

  • Template: Exit: {TICKER} {side} at ${price} — {reason} (SL/TP)
  • Example: "Exit: TSLA long at $239.50 — SL hit"

• Unusual options activity / IV changes

  • Template: UOA: {TICKER} {flow} — IVR {ivr}, IV {iv}%
  • Example: "UOA: SPY call flow — IVR 78, IV 23%"

• FX levels and macro indicators

  • Template: FX: {PAIR} tap {level} | {indicator} {value}
  • Example: "FX: EURUSD tap 1.1000 | PMI 52.3"

• Crypto funding/liquidations/on-chain

  • Template: Crypto: {COIN} funding {funding}% | Liq {liq_usd} | NVT {nvt}
  • Example: "Crypto: BTC funding 0.03% | Liq $120M | NVT 48"

• Spread/arb setups

  • Template: Spread: {A}/{B} z-score {z} | {tf}
  • Example: "Spread: GLD/GDX z-score 2.1 | D1"

• End-of-day summary

  • Template: EoD: Top± {top_plus}/{top_minus} | PnL {pnl_d}% | Positions {n}
  • Example: "EoD: Top± NVDA +4.1% / T -3.7% | PnL +0.9% | Positions 12"Tip: Attach a chart image with photoUrl for context (e.g., a MultiChart snapshot). Your text becomes the caption.

Pro tips​

• Store your Chat ID once and reuse it across flows.
• For groups: Chat ID is negative. If you migrate the group or channel, the ID can change — run /id again.
• You can send a quick heartbeat by wiring a scheduled flow that posts "ping" to your own DM.

Happy notifying!

slug: multichart-dropdown-descriptions title: MultiChart — Descriptions in Type Selector authors: system date: 2025-10-17 tags: [charts, ux]​

We revamped how you add layers in MultiChart:

• A single custom dropdown where each option includes a title and a short description (what it draws and how it’s used).
• Descriptions help you pick the right layer faster without hopping to the docs.

Together with the new top legend and tooltip, configuration and analysis are smoother.

This guide shows how to use MultiChart to analyze financial markets faster and with more confidence. It covers what MultiChart can render, proven layer recipes, practical workflows, and why a single, layered view is a real edge.

What is MultiChart?​

MultiChart combines multiple visualization layers on a single time axis. You can stack price, indicators, alternative chart types, volume, heatmaps, and order‑flow insights in one view with interactive legend, tooltip, and last‑value chips.

Supported layers (at a glance)​

• Price: Candle, Heikin Ashi, Bar, Equivolume
• Lines & areas: Line, Tick, Area, Mountain (gradient)
• Brick‑based: Renko, Range Bar, Point & Figure, Kagi
• Indicators: Bollinger Bands, Ichimoku (Tenkan/Kijun/Span A/B cloud/Chikou)
• Volume & order flow: Volume (bottom band), Footprint (candle + buy/sell levels)
• Events/metrics: Bubble (size/color encodings), Heatmap (time × Y‑category in bottom band)

Tooltip shows context‑aware values (e.g., OHLC, Bollinger M/U/L, Ichimoku T/K/A/B/Ch, Volume). Legend above the chart lets you toggle layers instantly; last‑value chips on the right give a quick read of the latest levels.

Why this is a real advantage​

• Single timeline context: No more tab hopping across tools; compare signals at the exact same moment.
• Faster synthesis: Tooltip consolidates values across all visible layers under your cursor.
• Fewer blind spots: Mix complementary views (trend + volatility + volume + structure) to reduce false positives.
• Multi‑timeframe ready: Layer slow trend context with faster execution signals on the same canvas.
• Lower cognitive load: Top legend toggles, descriptive layer picker, and last‑value chips keep focus on the price action.
• Robust data path: Backend normalizes inputs (safe parsing, append mode, rowsExpr), so display stays resilient.

Quick start (3–5 minutes)​

1. Add a MultiChart widget.
2. Click “Add layer” and select a type (each option has a short description).
3. Provide layer data (see formats below) and hit Apply.
4. Repeat for 2–4 layers; keep it lean for clarity.
5. Use the legend to toggle layers; hover for the tooltip; glance right for last values.

Tip: For large inputs, set a Global limit for smooth performance.

Proven recipes for markets​

• Trend following (clean + context)

  • Candle + Ichimoku (Tenkan/Kijun + cloud) + Volume
  • Read cloud bias and Tenkan/Kijun crosses; confirm with volume expansions.

• Mean reversion / volatility bands

  • Candle + Bollinger Bands (+ Line for mid)
  • Fade extremes back to middle in ranges; avoid when trend/cloud bias is strong.

• Noise reduction for structure

  • Renko or Range Bar + Kagi
  • Reveal swing structure and reversals; helpful for stop placement and breakouts.

• Order flow confidence

  • Candle + Footprint + Volume
  • Watch footprint imbalance near prior highs/lows; confirm with volume spikes on breaks or rejections.

• Event overlays

  • Candle + Heatmap (categories: events/signals/flows)
  • Correlate price response to discrete events without leaving the chart.

• Momentum with confirmation

  • Heikin Ashi + Mountain (momentum line) + Bollinger mid
  • Smooth candles, slope + pullback to mid as continuation entries.

Multi‑timeframe layering​

• Use slower layer(s) for bias (e.g., Ichimoku, Mountain/Area of higher timeframe feed).
• Add a faster execution layer (Tick/Line) to refine entries around key levels.
• Toggle slow layers off temporarily when managing precise execution.

Interactions that speed you up​

• Top legend: toggle layers instantly, no menus.
• Tooltip: vertical guide + consolidated lines per layer under your cursor.
• Last‑value chips: right‑side labels with connectors; see the latest level per layer at a glance.

Data formats (summary)​

• Candle/Heikin/Bar/Equivolume: { ts, o, h, l, c, (volume) }
• Line/Tick/Area/Mountain: { ts, value }
• Renko/Range Bar/Point & Figure: { ts, o, c, up }
• Bollinger: { ts, middle, upper, lower }
• Kagi: { ts, value, thick, up }
• Volume: { ts, volume }
• Footprint: { ts, o, h, l, c, (volume), (levels:[{ price, buy, sell }]) }
• Bubble: { ts, value, size, (colorValue) }
• Ichimoku: { ts, value } for each of: tenkan/kijun/spanA/spanB/chikou
• Heatmap: { ts, y, value } (Y = category label)

Notes:

• ts in seconds (Unix). Heatmap/Volume draw in bottom bands and don’t affect price scale.
• Ichimoku lines are considered in price range calculation; Heatmap is excluded.

Performance tips​

• Keep 3–6 layers visible; hide diagnostic layers via legend as needed.
• Use Global limit or pre‑downsample on the backend for very large histories.
• Prefer Area/Mountain/Line over highly granular Tick when you only need trend context.

Risk & usage notes​

• This is an analysis tool, not investment advice.
• Validate strategies out‑of‑sample; combine price, volume, and structure for robustness.
• Be mindful of liquidity and execution costs when translating signals to orders.

Next steps​

• Add Y‑axis labels for Heatmap categories (coming).
• Per‑component toggles for Ichimoku in the configurator.
• Persist layer visibility state across sessions.

With MultiChart, you can compress the analysis loop: one chart, multiple truths. Less context switching, more time spent on decisions that matter.

Examples: market playbooks​

Below are practical, step‑by‑step setups you can reproduce quickly.

1) Intraday breakout with volume confirmation​

• Layers: Candle + Volume + Footprint + Heatmap (events/news/sessions)
• Read:
  • Mark prior session high/low or pre‑market extremes (Heatmap category = level).
  • Watch for price consolidation under the level; then break with a volume spike (Volume) and buy‑side imbalance on Footprint.
  • Tooltip confirms the candle OHLC and footprint context exactly at break.
• Execution:
  • Entry on break/close above level with footprint buy > sell.
  • Invalidation if price re‑enters range and footprint flips (sell imbalance) on pullback.
  • Take partials into the next HTF level; trail using prior 1–2 candle lows.

2) Swing trend following with Ichimoku​

• Layers: Heikin Ashi (or Candle) + Ichimoku + Volume
• Read:
  • Cloud color/position for bias; Tenkan crossing above Kijun for momentum.
  • Chikou above price confirms trend maturity; Volume upticks on legs.
• Execution:
  • Enter on pullback to Kijun with Tenkan rising and cloud supportive.
  • Exit/trail when Tenkan crosses down or price closes inside/opposite the cloud.

3) Range mean reversion with Bollinger​

• Layers: Candle + Bollinger Bands (±2σ) + Volume (filter)
• Read:
  • In sideways regimes, tests of Upper/Lower bands tend to revert to the Middle.
  • Avoid when Volume expands in the direction of the move (possible regime shift).
• Execution:
  • Fade near band extremes back to the middle; stop outside the band; reduce when volume expands.

4) Multi‑timeframe overlay​

• Layers: Mountain (HTF feed; e.g., 4H) + Candle (LTF; e.g., 15m) + Bollinger mid
• Read:
  • Use Mountain slope as higher‑timeframe bias; focus on LTF continuation in that direction.
  • Bollinger mid on LTF serves as a dynamic pullback reference.
• Execution:
  • Enter on LTF pullback to the mid in the direction of HTF slope; exit on mid loss or slope flattening.

5) Structure & stops with Renko/Kagi​

• Layers: Renko (or Range Bar) + Kagi
• Read:
  • Clean swing structure and reversal points; Kagi thickness highlights trend vigor.
• Execution:
  • Place stops beyond the prior brick swing; enter on Kagi thickening in trend direction.

rowsExpr examples (Eval, no JSON)​

Prefer passing expressions that evaluate to a list of dictionaries. You can reference two built‑in scopes: vars and data. If your platform supports mustache, you can wrap the expression, e.g. {{ ... }}.

Tip: Ensure timestamps are Unix seconds. If your source is in milliseconds, convert with r['ts'] // 1000 in a list comprehension.

Candle (from Yahoo feed in vars)​

type: Candle
rowsExpr: "{{ vars['fetch_yahoo_n_v7is']['data'] }}"
open: "o"
close: "c"
high: "h"
low:  "l"
timestamp: "ts"
limit: 500

If your ts is in milliseconds:

rowsExpr: "[{'ts': r['ts']//1000, 'o': r['o'], 'h': r['h'], 'l': r['l'], 'c': r['c']} for r in vars['fetch_yahoo_n_v7is']['data']]"

Line (close as a single value series)​

type: Line
rowsExpr: "[{'ts': r['ts'], 'value': r['c']} for r in vars['fetch_yahoo_n_v7is']['data']]"
timestamp: "ts"
fields: "value"
shade: false

Volume (bottom band)​

type: Volume
rowsExpr: "[{'ts': r['ts'], 'volume': r.get('volume') or r.get('v') or 0} for r in vars['fetch_yahoo_n_v7is']['data']]"
timestamp: "ts"

Ichimoku (computed server‑side from OHLC)​

Use the same OHLC rows; the worker computes Tenkan/Kijun/Span A/B/Chikou.

type: Ichimoku
rowsExpr: "{{ vars['fetch_yahoo_n_v7is']['data'] }}"
open: "o"
close: "c"
high: "h"
low:  "l"
timestamp: "ts"

Bollinger Bands (precomputed in vars)​

If you already have bands in vars['bb_20_2'] with middle/upper/lower:

type: Bollinger
rowsExpr: "{{ vars['bb_20_2'] }}"
timestamp: "ts"
middle: "middle"
upper:  "upper"
lower:  "lower"

Or derive from closes on the fly (simple example, pseudo‑rolling):

rowsExpr: "(lambda rows: [
  {'ts': rows[i]['ts'], 'middle': sum([r['c'] for r in rows[i-19:i+1]])/20,
   'upper':  (sum([r['c'] for r in rows[i-19:i+1]])/20) + 2*(((sum([(r['c']- (sum([q['c'] for q in rows[i-19:i+1]])/20))**2 for r in rows[i-19:i+1]])/20))**0.5),
   'lower':  (sum([r['c'] for r in rows[i-19:i+1]])/20) - 2*(((sum([(r['c']- (sum([q['c'] for q in rows[i-19:i+1]])/20))**2 for r in rows[i-19:i+1]])/20))**0.5)
  } for i in range(19, len(rows))
])(vars['fetch_yahoo_n_v7is']['data'])"

Heatmap (events → categories)​

Map heterogeneous event arrays into a unified shape { ts, y, value }:

type: Heatmap
rowsExpr: "
  ([{'ts': e['ts'], 'y': 'earnings', 'value': 1} for e in vars.get('earnings', [])] +
   [{'ts': n['ts'], 'y': 'news', 'value': 1} for n in vars.get('news', [])] +
   [{'ts': s['ts'], 'y': 'session-open', 'value': 1} for s in vars.get('sessions', [])])
"
timestamp: "ts"
category:  "y"
value:     "value"

Footprint (order flow with price levels)​

If your order‑flow provider is stored under vars['oflow']:

type: Footprint
rowsExpr: "{{ vars['oflow'] }}"
open: "o"
close: "c"
high: "h"
low:  "l"
timestamp: "ts"
levels: "levels"   # array of { price, buy, sell }

Notes

• You can pass a Python list directly as rowsExpr (no mustache needed).
• safe_eval sees: vars, data, and a small set of built‑ins (sum, len, min, max, sorted, list comprehensions, etc.).
• If a layer expects OHLC, provide field names via mapping options (open/close/high/low/timestamp).

Checklist before trading​

• Data sanity: timestamps increasing, fields present (e.g., o/h/l/c, value, volume).
• Visibility: keep 3–6 layers; hide diagnostics via legend on demand.
• Regime: trend vs. range — pick the recipe that matches the regime.
• Confirmation: volume or footprint to back price signals.
• Risk: define invalidation (where the idea is clearly wrong), not just target.

slug: multichart-legend-top-tooltip title: MultiChart — Top Legend and Tooltip authors: system date: 2025-10-14 tags: [charts, ux]​

Two UX improvements that make MultiChart easier to work with:

• Legend moved above the chart — quick layer visibility toggles in a single row. The chart reserves top space so nothing overlaps.
• Tooltip on hover — vertical guide line and a box with the time and values for all visible layers at that moment (OHLC, Bollinger M/U/L, Ichimoku T/K/A/B/Ch, Volume, etc.).

This speeds up analysis and cross‑layer comparisons.

slug: multichart-ichimoku-heatmap title: MultiChart — Ichimoku and Heatmap authors: system date: 2025-10-12 tags: [charts, indicators]​

We added two powerful visualizations to MultiChart:

• Ichimoku: Tenkan, Kijun, Span A/B (with cloud), Chikou. Default colors and readable cloud opacity. Tooltip shows T/K/A/B/Ch at the hovered time.
• Heatmap: A band at the bottom (time × Y category). Color from a palette (inferno by default; also viridis, magma, plasma). Does not affect the price scale.

We also polished backend computations (series normalization, safe parsing of values and timestamps).

Planned: Heatmap Y‑axis labels and Ichimoku component toggles in the configurator.

slug: multichart-new-layers title: MultiChart — New Layer Types authors: system date: 2025-10-09 tags: [charts, release, analytics]​

We’re shipping a bigger batch of new layer types for MultiChart. This lets you combine more analytical approaches on a single time axis.

What’s new:

• Price: Heikin Ashi, Bar, Equivolume, Area, Mountain (Area variant with a soft gradient)
• Advanced: Renko, Range Bar, Point & Figure, Kagi, Tick
• Indicators: Bollinger Bands
• Other: Bubble (radius from size, optional color from colorValue), Footprint (candle outline with per-level buy/sell)

Tips:

• Start with 3–5 layers for clarity (e.g., Candle + Bollinger + Volume).
• Use the global limit if you process larger datasets.

Docs: guides will be updated shortly; in the meantime, see the in‑app layer descriptions and on‑chart tooltips.

We shipped a platform-wide performance tune focused on perceived latency and resource efficiency.

Changes:

• Reduced initial workflow editor bundle size.
• Cached monetization lookups across dashboard sessions.
• Smarter diff-based dashboard layout persistence.

Expect faster navigation and smoother edits.

Docs: System Overview & relevant feature pages.

Threaded replies now auto-focus the input after send and optimistically insert your draft while confirming backend persistence, smoothing rapid follow-up exchanges.

Docs: System Overview → Messages.

The Credits tab now exposes auto top-up status inline and adds guidance for recommended thresholds based on recent consumption velocity.

Docs: Requirements → Billing Readiness.

Early usage insight counters show basic adoption metrics for your shared workflows and widgets (installs and duplicates). This helps guide iterative improvements and pricing decisions.

Docs: Managing Workflows → FAQ (adoption & duplicates context).

You can mark multiple messages read in a single interaction. Bulk selection reduces inbox cleanup friction for active monetizers receiving frequent system notices.

Docs: System Overview → Messages.

The Dashboards FAQ received clarifications on empty state causes and refresh behavior. Added quick tips on grouping widgets and prioritizing layout for readability.

Docs: Dashboards → FAQ.

Pricing chips now standardize copy and units across all lists: Paid: AMOUNT CURRENCY/mo or /cycle where applicable. Free items remain clearly marked.

This improves quick scanning of marketplace and workflow asset pickers.

Docs: System Overview → Monetization & Credits.

Dashboard widget coordinates now persist instantly—no more accidental reverts after refresh. The save model was optimized to batch minor drags while remaining resilient to network hiccups.

Highlights:

• Debounced save with conflict safety.
• Better visual ghost while dragging.
• Lower bandwidth usage.

See docs: Dashboards → Ordering & Updating.

A dedicated Dashboards FAQ page is now available covering empty states, resizing, and pricing visibility.

Browse it to troubleshoot common layout or data questions.

Docs: Dashboards → FAQ.

We refined the widget card layout for clarity.

Updates:

• Cleaner header hierarchy.
• Optional last-updated footer.
• Consolidated settings & refresh actions.

Docs: Dashboards → Widget Card.