# JDE Orchestrator API Concurrency Sizing Calculator

> Source: https://netray.co/tools/jde-orchestrator-thread-sizing-calculator
> Publisher: Netray (netray.co), AI and integration engineering for ERP and manufacturing systems.
> Section: Free Tools

## Short answer

Convert peak calls per hour and average response time into concurrent requests, threads and JVM count, with a burst factor.

## Category

oracle

## Erp

Oracle JD Edwards EnterpriseOne

## Audience

- JDE integration developer
- JDE CNC administrator
- Enterprise architect

## Tool

**Kind:** calculator

**Inputs:**

#### Peak calls per hour

**Key:** calls

**Type:** number

**Default:** 6000

**Min:** 0

**Step:** 500

**Unit:** calls/hr

#### Average response time

**Key:** avg_ms

**Type:** number

**Default:** 800

**Min:** 1

**Step:** 50

**Unit:** ms

**Help:** Measured end to end at the AIS server, not the browser.

#### Burst factor

**Key:** burst

**Type:** number

**Default:** 3

**Min:** 1

**Max:** 20

**Step:** 0.5

**Help:** Ratio of busiest minute rate to the hourly average.

#### Request threads per JVM

**Key:** threads

**Type:** number

**Default:** 25

**Min:** 1

**Step:** 1

**Unit:** threads

#### Target thread utilization

**Key:** util

**Type:** slider

**Default:** 60

**Min:** 30

**Max:** 90

**Step:** 5

**Unit:** %

**Outputs:**

#### Average calls per second

**Key:** per_sec

**Expr:** calls / 3600

**Format:** decimal

#### Average concurrent requests

**Key:** concurrent

**Expr:** per_sec * avg_ms / 1000

**Format:** decimal

**Description:** Little's law: arrival rate times time in system.

#### Concurrent requests at burst

**Key:** burst_conc

**Expr:** concurrent * burst

**Format:** decimal

#### Threads needed

**Key:** needed

**Expr:** ceil(burst_conc / (util / 100))

**Format:** integer

**Primary:** true

#### JVMs needed

**Key:** jvms

**Expr:** ceil(needed / threads)

**Format:** integer

**Primary:** true

**Chart:**

#### Threads needed vs response time

**Type:** line

**X:** avg_ms

**From:** 100

**To:** 3000

**Steps:** 30

**Series:**

- needed

**Disclaimer:** Planning model. Downstream limits such as the enterprise server and database can cap throughput before threads do.

## Content

**Intro:** When an Orchestration is called by a scanner, portal or integration platform, the number of requests in flight decides whether the AIS tier keeps up. Little's law makes that arithmetic simple.

**Sections:**

#### How to use it

**Body:** Take peak calls per hour from the calling system's logs and average response time from AIS or orchestrator logging. Pick a burst factor from the busiest minute. The result shows threads and JVMs required. Try response times of one second versus three to see how slow downstream steps multiply the need.

#### Little's law

**Body:** Concurrent requests equal arrival rate times average time in the system. At 6,000 calls per hour and 800 milliseconds, the average is about 1.3 concurrent requests, but a burst of three times that needs about four. Threads are then divided by utilization so the pool is not saturated.

**Bullets:**

- Slow orchestrations hold threads longer.
- Use the 95th percentile when SLAs are strict.
- Retries from callers inflate the real arrival rate.

#### Practical notes

**Body:** The sweep shows how latency, not volume, often drives capacity. Before adding hardware, look at what the slowest orchestration step is waiting on, such as a form call or a UBE, and whether it can be made asynchronous.

**Cta:** Netray can help design and load-test integration patterns around JDE Orchestrator.

**Faq:**

#### Does a burst factor matter?

**Answer:** Yes. Averages hide peaks, and queues form in the busiest minute. Measure the ratio of your peak minute to the hourly average and enter that.

#### What is a safe thread utilization?

**Answer:** Many teams target 50 to 70 percent so latency stays stable when load varies. The right level depends on your tolerance for queuing.

#### Should I size on the average response time?

**Answer:** Averages hide the slow tail. For strict response commitments, use a higher percentile response time.

#### Does this include the enterprise server?

**Answer:** No. It sizes the AIS web tier threads only. Calls still run logic on the enterprise server and database, which need their own check.

## Search terms

jde orchestrator capacity, jde ais server sizing, jd edwards rest api concurrency, jde orchestrator performance, littles law api threads, jde integration load planning

---
Talk to an engineer: https://netray.co/contact?intent=erp_ai | Machine catalog: https://netray.co/agent/catalog.json