Forem: Jnnngs

3270Web: A Web-Based 3270 Terminal

Jnnngs — Mon, 16 Feb 2026 09:32:16 +0000

3270Web: A Web-Based 3270 Terminal Interface Built with Go

Working with 3270 terminals often means juggling:

• Desktop emulators

• VPN access

• Session configuration headaches

• Fragile automation bridges

For modern workflows — especially remote teams, containerised environments, and browser-centric tooling — this quickly becomes friction.

That’s why 3270Web exists.

3270Web is a web-based 3270 terminal interface written in Go, designed to provide interactive sessions and seamlessly bridge into automation via 3270Connect-compatible workflows.

What Problem Does 3270Web Solve?

Traditional 3270 access models assume:

• A locally installed emulator

• Direct network connectivity

• Human-only interaction

But modern environments increasingly require:

✅ Browser-based access

✅ Container-friendly deployment

✅ Session visibility & logging

✅ Automation integration

3270Web provides exactly that.

What 3270Web Is (and Isn’t)

3270Web is:

• A browser-based 3270 terminal UI

• A Go-based backend service

• A session recording & replay tool

• An automation bridge into 3270Connect

It is not:

• A replacement for mainframe logic

• A pixel-based screen scraper

• A generic SSH/RDP gateway

Think of it as a modern access + workflow capture layer for 3270 systems.

Key Features

▸ Web UI for Interactive 3270 Sessions

Run fully interactive 3270 terminal sessions directly in your browser.

Benefits include:

• No desktop emulator required

• Centralised deployment

• Detailed session logging

• Easier remote access scenarios

▸ Virtual Keyboard Support

3270 terminals rely heavily on:

• Function keys

• Special control sequences

• Non-standard key mappings

3270Web includes a virtual keyboard for complete compatibility with real terminal interaction.

▸ Full 3270 Terminal Settings

Mainframe environments vary widely.

3270Web exposes configurable options such as:

• Terminal models

• Screen dimensions

• Encoding options

• Backend connection parameters

Designed to support virtually any TN3270-compatible backend.

▸ Record Sessions to `workflow.json`

One of the most powerful capabilities:

👉 Record live terminal sessions directly into a workflow.json file

These workflows are:

✅ Compatible with 3270Connect

✅ Reusable for automation

✅ Human-generated but machine-executed

This turns exploratory or manual sessions into repeatable automation assets.

▸ Load & Playback Workflows

Previously recorded workflows can be:

• Loaded back into the UI

• Replayed interactively

• Used for validation/testing

• Passed directly into 3270Connect

Perfect for:

• Regression testing

• Demo environments

• Workflow debugging

• Training scenarios

▸ Docker & GHCR Deployment

3270Web is built with containerised deployment in mind.

Includes:

• Docker image

• GitHub Container Registry (GHCR) workflow

• Simple infrastructure integration

Ideal for:

✅ Dev/test labs

✅ Remote access gateways

✅ Cloud-hosted tooling

✅ Ephemeral environments

Why Pair 3270Web with 3270Connect?

These tools are intentionally complementary:

Tool	Purpose
3270Web	Interactive access + workflow capture
3270Connect	Headless automation engine

A typical flow:

1️⃣ Explore workflow interactively in browser

2️⃣ Record session to workflow.json

3️⃣ Execute at scale via 3270Connect

This bridges the gap between:

👤 Human discovery

🤖 Deterministic automation

Real-World Use Cases

3270Web fits naturally into:

• Legacy modernisation projects

• Remote mainframe access scenarios

• Training & sandbox environments

• Automation workflow design

• Debugging 3270Connect scripts

• Containerised lab setups

Why Go?

Using Go provides:

✅ Compiled, predictable binaries

✅ Low runtime overhead

✅ Strong concurrency support

✅ Easy containerisation

✅ Minimal dependency surface

Important for enterprise and regulated environments.

When 3270Web Makes Less Sense

Honest constraints:

• If you already have stable emulator infrastructure

• If browser access is not permitted

• If workflows change constantly with no repeatability

• If human-only usage is required

Final Thoughts

3270 systems are still mission-critical.

But tooling around them doesn’t need to feel stuck in the 1990s.

3270Web provides:

• Modern browser-based access

• Deep session visibility

• Workflow recording

• Seamless automation integration

• Container-friendly deployment

A small, focused tool solving a very real problem space.

Links

• GitHub: https://github.com/3270io/3270Web

• Automation engine: https://github.com/3270io/3270Connect

If you’re working in:

Mainframe #LegacyModernization #Golang #Automation

…this might save you a surprising amount of friction.

Automating 3270 Mainframe Workflows with Go

Jnnngs — Wed, 21 Jan 2026 18:31:35 +0000

Why 3270Connect Exists

Mainframes are not legacy in the sense people often assume.

They’re legacy in interface, not importance.

Across banking, insurance, logistics, and government systems, 3270 terminals still sit at the heart of critical workflows. The problem isn’t that these systems exist — it’s that automating them reliably is still surprisingly difficult.

That gap is why 3270Connect exists.

The Real Problem with 3270 Automation

On paper, automating a 3270 terminal sounds simple:

Connect to TN3270
Send keystrokes
Read the screen
Repeat

In practice, it’s anything but simple.

Common pain points include:

Stateful screens with no stable identifiers
Timing issues (screens that appear “ready” but aren’t)
Concurrency limits when running multiple sessions
Fragile scripts tied to exact screen layouts
Poor error visibility when automation fails mid-flow

Many teams end up with brittle Expect scripts or UI-driven screen scraping that works just enough to be dangerous.

What 3270Connect Is (and Isn’t)

3270Connect is an open-source automation engine designed specifically for programmatic interaction with 3270 terminals.

It is:

Written in Go
Built for concurrent sessions
Designed around explicit screen state handling
Suitable for headless, service-driven automation

It is not:

A GUI emulator
A screen recorder
A replacement for core mainframe logic

Think of it as infrastructure glue — useful when you need repeatable, controlled interaction with existing mainframe workflows.

Why Existing Tools Often Fall Short

Most existing approaches fall into one of three categories:

1. Terminal scripting tools

These tend to:

Be sequential
Lack structured error handling
Break easily with minor screen changes

2. GUI-based screen automation

These:

Rely on pixel position or text matching
Are slow and fragile
Don’t scale well for backend automation

3. Custom in-house tooling

Often:

Hard-coded to a single system
Poorly documented
Difficult to extend or hand over

What’s missing is a programmable, concurrent, automation-first approach that treats 3270 like a system interface — not a human UI.

Design Principles

1. Automation First

3270Connect assumes:

No human is watching the screen
Failures must be detectable and explainable
Automation needs retries, timeouts, and recovery paths

2. Concurrency by Design

Many tools treat concurrency as an afterthought.

3270Connect treats it as a requirement.

You can:

Run multiple sessions in parallel
Isolate failures per session
Scale automation horizontally
Simulate random human "thinking" between transactions and steps

3. Explicit Screen State Handling

Rather than blindly sending keystrokes, workflows are built around:

Waiting for known screen conditions
Validating expected states
Failing fast when something unexpected appears

This dramatically reduces “silent failures”.

Real-World Use Cases

Some examples where tools like this are genuinely useful:

TN 3270 Volume Testing with legacy systems
Regression testing during mainframe modernisation
Nightly operational workflows that still depend on 3270 screens
Bridging automation gaps while systems are gradually replaced

In many organisations, full replacement isn’t immediate — automation buys time and reduces risk during transition.

Why It’s Open Source

Mainframe tooling lives in a strange space:

Highly specialised
Often locked behind expensive licenses
Hard to evaluate without real workloads

By keeping 3270Connect open:

Teams can audit the code
Security teams can asses

Forem: Jnnngs

3270Web: A Web-Based 3270 Terminal

3270Web: A Web-Based 3270 Terminal Interface Built with Go

What Problem Does 3270Web Solve?

What 3270Web Is (and Isn’t)

Key Features

▸ Web UI for Interactive 3270 Sessions

▸ Virtual Keyboard Support

▸ Full 3270 Terminal Settings

▸ Record Sessions to workflow.json

▸ Load & Playback Workflows

▸ Docker & GHCR Deployment

Why Pair 3270Web with 3270Connect?

Real-World Use Cases

Why Go?

When 3270Web Makes Less Sense

Final Thoughts

Links

Mainframe #LegacyModernization #Golang #Automation

Automating 3270 Mainframe Workflows with Go

Why 3270Connect Exists

The Real Problem with 3270 Automation

What 3270Connect Is (and Isn’t)

Why Existing Tools Often Fall Short

1. Terminal scripting tools

2. GUI-based screen automation

3. Custom in-house tooling

Design Principles

1. Automation First

2. Concurrency by Design

3. Explicit Screen State Handling

Real-World Use Cases

Why It’s Open Source

▸ Record Sessions to `workflow.json`