Enterprise workload automation

Define work. Run it where files live. Observe and secure.

Just Run It is a web-based control plane for jobs, workflows, and schedules— with agents you install on the systems that actually run your scripts and binaries. Personal and group workspaces support federated teams on one shared platform.

Control plane UI + REST API Agents Linux, Windows, containers Deploy Docker, Kubernetes, bare metal
Just Run It operations dashboard

What the product offers

A complete offering for script- and binary-centric automation—without forcing every workload into a single host.

Define

Jobs, workflows & schedules

  • Job types: shell COMMAND, HTTP, NOOP, GIT_RELEASE (download release assets and execute)
  • Workflows with ordered steps, conditions, and restart from a failed step
  • Cron schedules targeting a job or a workflow
  • Search, filter, and paging across catalogs and history
Execute

Agents where work runs

  • Out-of-process agents claim work from the control plane
  • Same agent JAR on Linux and Windows
  • Preferred agent pinning for host-specific scripts
  • Cancel / kill, retries, and orphan recovery when an agent is lost mid-run
Govern

Security & workspaces

  • Local users with VIEWER / OPERATOR / ADMIN roles
  • Optional OIDC SSO (Entra ID, Okta, Keycloak, and similar)
  • Personal, group, and platform workspaces for federated teams
  • Audit trail with actor attribution

Capabilities by role

What users, administrators, and systems operators can do day to day.

AreaCapability
CatalogBrowse jobs, workflows, and schedules in workspaces you can see (personal, groups, platform shared)
RunRun now for jobs and workflows (OPERATOR+); view execution status and logs
CreateCreate and edit jobs, workflows, and schedules in workspaces you manage (personal ownership or group manager)
SchedulesAttach cron expressions; human-readable schedule descriptions in the UI
HistorySearch and filter executions; open detail with error reason and log output; filter failed runs
RecoveryCancel queued/running work; requeue orphaned executions after agent loss (where permitted)
Workspace filterSidebar switcher focuses lists and dashboards on a selected workspace
ThemesDark, medium, and light UI themes
AreaCapability
Full visibilitySee and manage definitions and executions across all workspaces
UsersAdmin user management: create, enable/disable, roles, password reset, delete
GroupsCreate group workspaces; add and remove members (OWNER / MANAGER / MEMBER)
Platform workspaceMaintain company-shared job definitions visible to authenticated users
Security modesLocal accounts, hybrid, or OIDC-primary SSO with role mapping from the identity provider
AgentsRegister, monitor, and remove agents; align naming for preferred-agent targeting
APIFull REST surface for automation, CI, and integration
AreaCapability
TopologyStateless application nodes, PostgreSQL as system of record, optional HA (multi-node + DB lease for scheduler)
Execution modeslocal (server runs jobs) or agent (workers claim work)—production typically agent mode
ContainersDocker Compose stack (Postgres + app nodes + agents); multi-stage images built from source
KubernetesHelm chart for server HA, agents, and optional in-cluster Postgres
Appliance / NASSynology Container Manager package under deploy/synology
HealthSpring Actuator health, readiness, metrics, Prometheus endpoint
NotificationsOptional email on failure (and optional success) via SMTP
ArtifactsConfigurable cache directory for GIT_RELEASE downloads on server or agent hosts
ObservabilityDashboard counts, audit events, execution diagnostics for ops triage

Agent flexibility

Run automation on the hosts that hold your applications, data, and scripts—across teams and data centers.

How agents work

  • Pull model — agents open outbound HTTPS to the control plane; the server does not need to dial agent hosts
  • Identity by name — register, heartbeat, and claim use a unique agent name
  • Hostname is a label — optional display metadata for operators; not used for routing
  • Preferred agent on a job pins work to a named agent (the host that has your files)
  • Linux & Windows — same agent package; shell via /bin/sh or cmd.exe
  • Scale-out — run multiple agent processes for parallel capacity

Full detail: Agents guide (download)

Federated agent placement

  • Install agents on app servers, batch hosts, jump boxes, or containers next to workloads
  • EU / US / LOB teams keep code and secrets on their systems while sharing one control plane
  • COMMAND jobs invoke existing start/status/stop scripts already installed on the agent host
  • GIT_RELEASE jobs can pull versioned binaries onto the agent and execute them
  • Orphan detection marks work when an agent goes offline mid-run; operators cancel or requeue
Agents management screen

Workspaces for federated teams

One control plane; clear boundaries for who sees and manages which automation.

Personal

Private by default

Each user receives a personal workspace. Operators create and schedule their own jobs without cluttering a global catalog.

Group

Team collaboration

Administrators create group workspaces and assign members as OWNER, MANAGER, or MEMBER. Shared pipelines stay with the team that owns them.

Platform

Company shared

A platform workspace holds common definitions visible to authenticated users, with administrative control over edits.

Why this matters for federation

  • Control plane federation — multiple teams use one HA deployment instead of shadow schedulers
  • Agent federation — agents remain on team-owned systems; preferred agent binds a job to the right host
  • Least privilege of view — non-admins only see workspaces they belong to; admins retain full oversight
  • Same-workspace integrity — workflow steps and schedules must reference jobs in the same workspace

Deployment options & environments

From lab laptop to multi-node production—same product family.

Supported deployment models

  • Local JAR — single process with embedded H2 for evaluation
  • Docker Compose — PostgreSQL, dual app nodes, dual agents (recommended lab / small prod)
  • Kubernetes / AKS — Helm chart for server, agents, optional Postgres
  • Synology Container Manager — packaged compose for NAS environments
  • Bare metal / VM — Java 21 runtime; agent JAR on any JVM host
Java 21 Spring Boot PostgreSQL 16 Docker Helm OIDC ready

Reference architecture

UI / API  ──►  App node  ·  App node   (N replicas)
                     │           │
                     └──── shared DB ────┘
                            │
                       PostgreSQL
                            ▲
              Agents ───────┘  (claim work / report status)

Environments typically separate lab, pre-production, and production control planes, with agents co-located to each environment’s application estate.

Downloads

Public product materials for evaluation and licensing discussions. Internal engineering notes are not published here.

User Guide (PDF)

Capabilities, UI walkthrough with screenshots, technologies, and deployment models.

Download PDF

Product overview (HTML)

Offering summary: features, roles, agents, workspaces, and deployment options.

Download HTML

Agents guide

Registration, name vs hostname, preferred agent, and federated placement.

Download Markdown

Capabilities by role (HTML)

User, administrator, and systems operator capability lists for RFP-style review.

Download HTML

Licensing & information

Talk to us about licensing Just Run It

For commercial licensing, evaluation access, or architecture discussions, email us. We respond with next steps for your environment and use case.

Email

Phone

Leave a message — we will call back to discuss your needs.

Website: https://justrunit.io

Compose email Call 318-232-2280

What to include (optional)

  • Organization and primary use case
  • Approximate agent count / environments
  • Preferred deployment model (Docker, Kubernetes, on-prem)
  • Timeline for evaluation or production

Product: Just Run It
Domain: justrunit.io
Email: justrunit.io@gmail.com
Phone: 318-232-2280 (leave a message)
Category: Enterprise workload automation control plane