Perspective vs WebDev Module: When to Use Each

This is the question that comes up in every Ignition architecture meeting once the team gets past the basics: "Should we use Perspective or the WebDev module for this?"

The answer is almost never "one or the other." The best deployments use both — but knowing which tool for which job is the difference between a system that hums and one that fights you at every turn.

Let's break it down honestly.

The 30-Second Version

Perspective is a full application framework. It manages sessions, user identity, component state, and bidirectional communication. It's designed for interactive screens where operators click buttons, fill forms, and make decisions.

WebDev is a web server toolkit. It lets you serve custom HTML pages and build REST APIs directly from your Ignition Gateway. It's designed for display-only dashboards, system integrations, and anywhere you need full control over the output.

Neither is better. They solve different problems.

When Perspective Is the Right Call

Interactive Operator Screens

If operators need to do things — acknowledge alarms, enter quality data, change setpoints, start batch recipes — Perspective is purpose-built for this. Its component library includes input fields, dropdown selectors, date pickers, tables with inline editing, and dozens of interactive widgets. Each one comes with built-in data binding, validation, and change handling.

Building the same interactivity in WebDev means writing JavaScript event handlers, managing form state, making AJAX calls to custom endpoints, and handling error states manually. It works, but you're rebuilding what Perspective already provides.

Rule of thumb: If the screen writes data back to the system, start with Perspective.

Role-Based and Session-Aware Views

Perspective knows who's logged in. It can show different content to operators versus supervisors versus maintenance techs, all within the same view. Session properties let you pass user context down into every component, and the security model integrates directly with Ignition's Identity Provider system.

WebDev supports HTTP Basic authentication and can check roles, but it doesn't maintain a session. Every request is stateless. If you need "show this widget only to users in the Supervisors role," Perspective handles it natively. In WebDev, you'd build that logic into every endpoint.

Rapid Prototyping

When the project lead says "I need a screen showing Line 3 status by end of day," Perspective wins on speed. Drag a few components onto a canvas, bind them to tags, style with the property editor, publish. You can go from blank view to functional screen in an hour.

WebDev's equivalent workflow is: create an HTML resource, write the markup and CSS, create a Python resource for the data endpoint, write JavaScript to fetch and render the data, debug CORS or authentication issues, and iterate. It takes longer — but the end result is different (more on that below).

Mobile-Responsive Workstation Apps

Perspective was built mobile-first. Its flex container system, breakpoint-aware layouts, and touch-friendly components mean you can design a view once and have it adapt from a 4K monitor to a phone screen. The built-in Workstation launcher and session management handle multi-page navigation, route parameters, and deep linking.

If you're building something that feels like an app — with navigation, multiple pages, and user workflows — Perspective gives you that structure out of the box.

When WebDev Is the Right Call

TV Displays and Floor Dashboards

This is WebDev's killer use case, and it's not close.

Every manufacturing plant has screens on the floor — production counts, OEE, downtime reasons, quality metrics. These displays run 24/7. Nobody interacts with them. They just need to show data, reliably, forever.

Perspective can do this, but it has friction:

• Sessions time out (default 30 minutes of inactivity) and need to be reconfigured for long-running displays
• The WebSocket connection can drop, showing a "session disconnected" overlay until it reconnects
• Each open display consumes a Perspective session, which counts against your license
• Authentication prompts can appear after Gateway restarts or certificate changes

A WebDev dashboard is a plain web page. It opens in Chrome, runs in kiosk mode, and polls a JSON endpoint on a timer. No sessions, no WebSocket state, no timeouts. If the Gateway reboots, the page keeps trying its fetch() call until it gets data again. No human intervention required.

We've deployed WebDev dashboards to factory floor TVs that have run months without a single touch. Try that with Perspective and you'll be debugging session management.

REST APIs and System Integration

If your ERP needs to push work orders into Ignition, or your MES needs to pull quality data out, you need an API. WebDev was literally designed for this.

Each Python resource maps to a URL endpoint. Define doGet for reads, doPost for writes, doPut for updates, doDelete for removals. Return JSON, set status codes, validate inputs. It's straightforward REST.

# doPost — receive a work order from SAP
def doPost(request, session):
    import system

    body = request['data']
    wo_number = body.get('workOrder')
    part_number = body.get('partNumber')
    quantity = body.get('quantity')

    if not all([wo_number, part_number, quantity]):
        return {"json": {"error": "Missing required fields"}, "code": 400}

    system.db.runPrepUpdate(
        "INSERT INTO work_orders (wo_number, part_number, qty, status) VALUES (?, ?, ?, 'PENDING')",
        [wo_number, part_number, int(quantity)],
        "production_db"
    )

    system.tag.writeBlocking(
        ["[default]Line1/ActiveWorkOrder"],
        [wo_number]
    )

    return {"json": {"status": "created", "workOrder": wo_number}, "code": 201}

Perspective has no equivalent for this. It's a visualization module — it consumes data, it doesn't expose it. If you need your Gateway to be an API server, WebDev is the only option.

Performance-Critical Displays

Perspective's architecture has layers: the component tree, the binding engine, the session state manager, and the WebSocket communication layer. Each layer adds latency. For most screens, it's imperceptible. But when you're rendering 200+ data points that update every second on a large display, it adds up.

A WebDev dashboard cuts through all of that. It makes a fetch() call to a JSON endpoint, gets a blob of data, and updates the DOM. No binding engine. No component lifecycle. No session sync. The result is dashboards that load in under a second and update with zero perceptible lag.

This matters most for:

• Large overview displays — plant-wide dashboards showing all lines at once
• High-refresh data — cycle time monitoring, real-time throughput counters
• Andon boards — where milliseconds of lag feel broken to floor operators

Pixel-Perfect Design

This one matters more than people think.

Perspective gives you components with properties. You can style them — colors, fonts, padding — but you're working within the constraints of what each component exposes. Want a specific animation? A custom chart that doesn't exist in the component library? A layout that doesn't fit the flex container model? You're fighting the framework.

WebDev gives you raw HTML and CSS. CSS Grid, Flexbox, animations, SVG, Canvas — the entire web platform is available. If your design team hands you a mockup, you can build it exactly. No compromises, no "close enough."

For executive dashboards that need to look polished, or for display boards where branding matters, this is the difference between "it works" and "it's impressive."

The Real-World Architecture

The strongest Ignition deployments we've worked with don't pick one module — they use both strategically:

• Perspective for workstation apps — operator HMI screens, supervisor portals, maintenance interfaces. Anything where humans interact with data.
• WebDev APIs for integration — receiving data from ERPs, feeding data to reporting tools, connecting mobile apps and barcode scanners.
• WebDev dashboards for displays — production floor TVs, conference room overviews, executive summary boards. Anything that runs unattended.

The WebDev dashboards and Perspective screens often share the same data layer. Named queries in the Gateway serve both. Tag reads are the same. The only difference is the presentation: Perspective renders interactive views for users; WebDev renders optimized, read-only views for screens.

Decision Matrix

Use this as a quick reference when you're standing at the whiteboard planning your next project:

Common Mistakes

Mistake 1: Using Perspective for TV Dashboards

This is the most common one. Teams default to Perspective because it's what they know. It works initially, then six weeks later someone's rebooting the display PC because the session disconnected and nobody noticed. Floor displays need to be fire-and-forget — WebDev gives you that.

Mistake 2: Using WebDev for Everything Because "It's More Flexible"

Flexibility has a cost: development time. If you need a form with 15 fields, validation, role-based access, and audit logging, Perspective gets you there in a day. WebDev gets you there in a week. Don't pay the flexibility tax when you don't need to.

Mistake 3: Not Sharing the Data Layer

We've seen shops build completely separate queries for their Perspective screens and WebDev dashboards. Same data, twice the maintenance. Use Named Queries in the Gateway that both modules consume. One source of truth, two presentation layers.

Mistake 4: Treating WebDev as "Lesser"

Some teams treat WebDev like a hack or a workaround — something you reach for when Perspective can't do something. That's backwards. WebDev is a first-class Ignition module with its own strengths. The best architectures plan for WebDev from the start, not bolt it on later.

The Skillset Gap

Here's the uncomfortable truth: most Ignition teams are Perspective-only because that's the skillset they have.

Perspective requires knowledge of Ignition components, bindings, and expressions — skills that control engineers and integrators build naturally as part of their Ignition work. It's a closed ecosystem with well-defined boundaries.

WebDev requires HTML, CSS, JavaScript, REST API design, and an understanding of how browsers work. These are web development skills — a different discipline entirely. Most control engineers and Ignition integrators didn't sign up for that, and it's unreasonable to expect them to excel at both.

This is exactly why the WebDev module is underutilized. It's not a technology problem — it's a talent problem. The teams that do have both skillsets build some of the most impressive Ignition deployments in the industry.

---

Want WebDev dashboards without hiring a web developer? That's literally what we do. We build custom WebDev dashboards and APIs for Ignition environments — you send us a project backup and tag list, we send back production-ready code. Take the readiness check and see if your system is a fit.