Proactive Ekara Software

Synthetic Transaction
Monitoring tool

Synthetic Transaction Monitoring (STM) is the key to guaranteeing the absolute availability and reliability of your website and applications by proactively simulating critical user journeys 24/7.

Unlike passive monitoring, STM reveals exactly how your service performs within a controlled environment by executing scripted scenarios from multiple global locations even in the absence of real traffic. Armed with this proactive data, you can detect outages before your customers do, validate your SLAs, and make informed decisions to secure revenue, maintain flawless service quality, and protect your brand reputation.

What is Synthetic Transaction Monitoring?

Synthetic Transaction Monitoring (STM) uses scripted, multi-step user journeys executed by real browsers (from multiple locations, devices and network profiles) on a schedule — so you can detect outages before users do, validate SLAs, and keep critical flows working 24/7.

Definition

STM simulates end-to-end paths such as login → search → add-to-cart → checkout. Each step includes assertions (content, status codes, timings) and produces evidence (screenshots, network waterfalls, console logs) to speed up triage. Unlike basic uptime pings, STM validates the whole journey, not just a single URL.

STM (scripted journeys)

Full flows across pages & APIs
Runs on real browsers, real JS
Assertions + screenshots/HAR
Great for SLAs & critical paths

Simple uptime (HTTP)

Single endpoint reachability
No UI/script execution
Limited evidence on failure
Good for basic availability

When to use it

✓ Low or uneven traffic: catch issues even at night or before a campaign.
✓ Pre-production checks: gate releases with scripted journeys in CI/CD.
✓ Third-party dependencies: payments, SSO/IdP, search, CDNs, tag managers.
✓ SLA/contract validation: measure journey availability and step budgets.
✓ Multi-region reliability: run from several geos to spot localized incidents.

Pair STM with Real User Monitoring: detect with Synthetic, size user impact with RUM, then verify the fix with both.

The synthetic monitoring solution designed to optimize user experience

Digital performance is the engine of your business — and just a few seconds of disruption can cost you users, productivity, and revenue. With Ekara’s Synthetic Transaction Monitoring (STM), IT and DevOps teams can proactively detect and resolve issues before they impact users, ensuring application excellence 24/7.

Why choose Ekara to monitor your applications?

Ekara’s Synthetic Monitoring — also known as robotic supervision — relies on intelligent agents that automatically execute user journeys on the front end, 24/7. These robots operate from hundreds of public or private measurement points, alerting you in real time whenever an incident occurs.

What Ekara delivers:

How the synthetic tool works

Record a critical journey once, schedule it across locations and profiles, then get assertions, evidence, and alerts on every run — no user traffic required.

1
Record

No-code recorder captures clicks, fills & navigations. Add variables and secrets (tokens, credentials).
2
Schedule

Run every 1–5 min, follow-the-sun across regions. Maintenance windows & blackout periods supported.
3
Execute

Real browsers (Chrome/Edge) with device + network profiles; optional throttling for mobile conditions.
4
Assert

Content/status assertions, step budgets (DNS, TLS, TTFB, total), checkpoints for every critical action.
5
Alert

Thresholds & multi-step logic, retries & de-dup, on-call via Email, Slack/Teams, Webhook.
6
Triage

Screenshots/video, console logs, network waterfalls, DOM snapshot, release correlation.

Recorder & scripting

✓ No-code capture with code export
✓ Variables, secrets vault, data sets
✓ Wait conditions & selectors helpers

Runner & profiles

✓ Real browsers, headful
✓ Geo locations, device & network presets
✓ Parallel runs & isolation

Assertions & evidence

✓ Content/status/JSON path
✓ Screenshots, video on failure
✓ HAR/waterfall + timings

Stability & noise control

✓ Retries with back-off
✓ Alert de-dup & flapping guard
✓ Maintenance windows

Alerting & SLOs

✓ p95 step/total thresholds
✓ Error budget & availability
✓ Slack/Teams/Webhook

CI/CD integration

✓ Run on deploy & gate releases
✓ Compare pre/post build
✓ Exit codes & artifacts

Sample pseudo-script

// Login → Search → Checkout (pseudo)
step('Login', async ({page}) => {
  await page.goto(BASE_URL);
  await page.fill('#email', ENV.USER);
  await page.fill('#pass',  ENV.PASS);
  await page.click('button[type=submit]');
  await expect(page).toHaveText('Welcome');
});

step('Search', async ({page}) => {
  await page.fill('#q','wireless headphones');
  await page.click('#search');
  await expect(page).toContainText('.result','Noise Cancelling');
});

step('Checkout', async ({page}) => {
  await addToCart(page, 'Noise Cancelling');
  await page.click('#checkout');
  assert.timing('ttfb', '<800ms'); // budget
  await expect(page).toHaveText('Order summary');
});

Tip: add step budgets and assertions to prevent regressions before release.

Key capabilities of a synthetic transaction monitoring tool

Script critical user journeys, run them from real browsers across locations and schedules, and get assertions, evidence, and alerts to catch problems before users do.

Real-browser journeys

Execute multi-step flows (login → search → add-to-cart → checkout) with real JS, cookies and storage.

✓ Device & network profiles
✓ Headful Chrome/Edge

API synthetic

Chain REST calls with auth headers, environment secrets and JSON path assertions.

✓ Chained requests
✓ JSON asserts & timing

Locations & schedules

Minute-level cadence with follow-the-sun execution to spot regional or ISP issues.

✓ Multi-region runners
✓ Maintenance windows

Assertions & budgets

Validate content, status and timings (DNS/TLS/TTFB/FCP/total) with step-level thresholds.

✓ Content/Status checks
✓ p95 step budgets

Evidence & triage

Collect screenshots/video, console logs and HAR/waterfalls for root-cause analysis.

✓ Failure artifacts
✓ DOM snapshots

Noise control & alerts

Retries with back-off, de-duplication and multi-channel alerts tied to runbooks.

✓ Slack/Teams/Webhook
✓ On-call escalation

Synthetic monitoring use cases

Script real-browser journeys for your most critical flows — catch breakages early, validate SLAs, and protect revenue and productivity.

Checkout & payment gateways

Simulate cart → checkout → PSP handoff with real browsers to spot failures and slow steps before users do.

✓ Validate promo codes, taxes & shipping
✓ Assert PSP redirects, 3-DS, receipts
✓ Alert on p95 step time & availability

Add-to-cartCheckoutPSP

Search & merchandising

Script query + filters + sorting to ensure results render fast and facet logic stays correct across releases.

✓ Assert content contains expected SKUs
✓ Track FCP/TTFB and total journey time

SearchFacetsPDP

SSO / login & onboarding

Exercise IdP login (SAML/OIDC), MFA and first-time setup to catch certificate expiry and flow regressions early.

✓ Secrets vault (no plain-text creds)
✓ Assertions on redirects and tokens

SSOMFAOnboarding

Core flows & exports

Monitor navigation, search, filters and CSV/PDF exports in dashboards to protect daily active usage.

✓ Step budgets on heavy reports
✓ Evidence: screenshots & HAR

DashboardExportReports

Lead forms & calculators

Fill multi-step forms, validate server responses and success screens to prevent silent conversion drops.

✓ Assert field validation & thank-you
✓ Alert on error states and slow posts

FormsValidationConversion

Content navigation

Ensure menus, search, and media widgets respond quickly, even under low network conditions.

✓ Timing asserts: DNS/TLS/TTFB/FCP
✓ Multi-location schedule

NavigationMediaCDN

Partner portals & B2B workflows

Script order entry, approvals and invoice checks to keep field teams productive across regions.

✓ Assertions on role-based content
✓ Evidence on failure for quick triage

OrdersApprovalsInvoices

Third-party dependencies

Watch CDNs, tag managers, payment widgets and search APIs that often cause regional slowdowns.

✓ Segment by geo/ISP to localize issues
✓ Alert with maintenance windows

CDNTagsAPIs

Alerts, SLOs & incident workflow

Detect failures early, alert the right people, and resolve faster with evidence, SLOs and a clear runbook.

Alert rules

Build robust conditions to avoid noise and catch real incidents across locations.

Target

Threshold

Stability

Scope

Rule preview

IF metric:p95_total_ms > 4500ms AND stability:3x AND scope:any-location
THEN alert channels:Slack,Email
WITH de-dup:5m, maintenance:Sun 01:00–02:00

De-duplication prevents alert storms; combine with retry back-off.
Maintenance windows silence expected downtime.
Escalation routes incidents to on-call rotation (Slack/Teams/Webhook).

SLOs & error budget

Set availability targets per journey and track budget burn to prioritize fixes.

Target availability99.90%

Period30 days

Allowed downtime43m 12s

Formula: Error budget = (1 − SLO) × period

Used 58%

Remaining 42%

✓ Define SLO per journey (Checkout, SSO, Exports).
✓ Budget alarms at 50/75/100% burn.
✓ Pair with RUM to size real-user impact.
✓ Track MTTA/MTTR in the incident log.

Runbook

Identify failing step & location(s).
Open evidence (screenshot, HAR, console).
Roll back or hotfix; verify via re-run.

View example runbook

Incident workflow & evidence

Everything you need to triage quickly and verify the fix.

Detect — rule triggers with scope (e.g., ≥ 2 locations).
Notify — on-call gets Slack/Teams + email with evidence links.
Triage — check failing step, screenshot, console errors, HAR.
Fix — rollback or patch; annotate release.
Verify — force re-run + RUM segment check.

Step	Duration	Status	Artifacts
Payment redirect	5.2s	Fail	Screenshot · HAR
Login (SSO)	1.1s	OK	HAR
Search results	2.6s	OK	Console

Correlate step timings with third-parties (CDN, PSP, IdP) to isolate root cause.

Key Features of Ekara’s STM Tool

Deploy monitoring agents according to your needs

Instant notifications of outages and confirmed incidents

Create user journeys without technical skills

Quickly identify incident causes using AI

SLA, Performance, and Trend Tracking

Compatible with your existing technical monitoring tools (APM, observability, ITSM, hypervisor…)

Visualize your key performance indicators (KPIs) and trends to track SLAs and support strategic decision-making.

Use Cases

Typical Use Cases of Active Monitoring (STM)

Too cultivated use solicitude frequently. Dashwood likewise up consider continue entrance ladyship oh. Wrong guest given purse.
Friendship to connection am considered difficulty. Country met pursuit lasting moments why calling certain the.

E-commerce Journeys

Monitor checkout funnels and shopping carts

Enterprise Portals

Ensure the smooth operation of your digital workplace tools by monitoring internal portals, ERP, CRM, and legacy applications

Intranet Applications

Ensure business continuity of thick clients, thin clients, and VDI used in sensitive environments

Mobile or Hybrid Applications

Simulate the user experience across all channels

The Concrete Benefits of STM

Debug faster with evidence

Every failure ships with proof — screenshots/video, console errors, network waterfalls, and step timings — plus root-cause hints to cut MTTR.

Evidence toolkit

Screenshot / Video Repro without guesswork — exact UI state at failure. Open example
Console logs JS errors, warnings and traces aligned with the failing step. Open console
Network waterfall (HAR) DNS, TLS, TTFB, content download — spot slow third-parties. Open HAR
Step timings & budgets Per-step p95, thresholds and regressions vs last release. View timings

Waterfall preview

HTML CSS JS XHR/API IMG

document

TTFB 420ms

app.css

220ms

vendor.js

1.2s

search?q=...

1.4s

hero.jpg

310ms

Hint: a slow XHR often points to API latency or an upstream dependency.

Root-cause hints

Layer	Signal	Hint
CDN	High TTFB on static assets	Check cache hit ratio, edge routing, and regional POP health.
DNS	Resolution > 200ms in specific geos	Verify DNS provider status and regional resolvers; consider geo-DNS.
TLS	Handshake spikes	Renew expiring certs; enable session resumption and OCSP stapling.
3rd-party/API	XHR over p95 budget	Inspect upstream latency; rate limits; fallback strategy for widgets.
JavaScript	Console errors / long tasks	Ship source maps; break down bundles; defer non-critical scripts.

Click a layer to highlight matching rows while keeping all context visible.

Release correlation

Current release v3.18.0

Journey p95 (total) 2.9s

Δ vs previous +410ms

v3.17.22.5s

v3.18.02.9s

Pin failures to builds and commits.
Auto-open regression tickets with evidence links.
Force a re-run to verify the hotfix.

Synthetic + RUM: the complete picture

Synthetic monitoring is proactive & deep (scripted checks on schedule). RUM is real-world & broad (field data from actual users). Together, they surface incidents early and size their impact accurately.

Comparison

Synthetic (STM)	Real User Monitoring (RUM)
Traffic required No — runs 24/7 on schedule	Traffic required Yes — measures real visitors
Coverage Scripted flows (login, search, checkout, SSO, APIs)	Coverage All user sessions; segments (device, browser, country, ISP)
Best for Outage detection, SLAs, pre-prod, low-traffic hours	Best for Experience quality, Core Web Vitals, prioritization
Evidence Screenshots/video, console, HAR/waterfalls, step timings	Evidence Field timings (LCP/INP/CLS, FCP, TTFB), errors, long tasks
Environments Staging, pre-prod, prod; geos & device/network profiles	Environments Production only (real users)
During incidents Keeps running without traffic	During incidents Reflects real impact when users are affected

Tip — use STM to detect and reproduce; use RUM to quantify and prioritize.

Playbook: detect → size → verify

Detect with Synthetic — scripted journey fails in ≥ 2 locations; alert fires with screenshot & HAR.
Size with RUM — check affected browsers/regions and % of users over budget (LCP/INP/TTFB).
Fix & verify — roll back or hotfix; force re-run of the STM; confirm RUM metrics recover.

Why STM first?

It catches issues before users arrive, validates SLAs, and provides deterministic evidence.

Why add RUM?

It reveals who is hurt (device, browser, country) and the exact business impact.

Together

Reduce MTTR, prioritize what matters, and prevent regressions with budgets & alerts on both sides.

Request a demo Explore RUM

FAQ

Frequently Asked Questions About Ekara

This type of monitoring regularly and automatically executes user journeys — clicks, data entry, logins, forms — to test the performance and availability of your applications.

Ekara combines public or private bots, support for thick clients, artificial intelligence, and a no-code journey scripting studio.

Absolutely. Ekara is one of the few solutions that covers web, mobile, and thick-client environments — one of its recognized advantages.

Yes. Data and alerts from Ekara synthetic monitoring can be integrated with your APM, SIEM, ITSM, or other technical platforms to provide a comprehensive view of both front-end and back-end performance.

Not at all! With Ekara Studio, the 100% no-code scripting environment featuring unique AI options, any user can create, modify, or maintain their journeys independently.

Absolutely. Ekara supports on-premise monitoring using private on-site bots behind your firewall, ensuring secure supervision.

Yes! Ekara monitors any application in any measurement environment, including mobile, voice/IVR, call center telephony, APIs, and more.

Coverage & environments

Run synthetic checks where they matter: web (real browsers), APIs, and mobile profiles — across staging, pre-prod, and prod with private locations, IP allowlists and strict secrets handling.

Web — real-browser journeys

Headful Chrome/Edge executing real JS, cookies and storage to validate end-to-end flows.

✓ Device profiles (desktop/mobile), DPR & viewport
✓ Network throttling (3G/4G/5G, custom RTT/throughput)
✓ Timings per step (DNS/TLS/TTFB/FCP/total)
✓ Evidence: screenshots/video, console, HAR/waterfalls

LoginSearchCheckoutSSO

APIs — REST chains & assertions

Script chained requests with auth headers, extract variables from JSON and assert payloads & latency.

✓ Methods, headers, auth (tokens, keys), secrets vault
✓ JSONPath assertions & schema checks
✓ Per-request budgets & retries with back-off
✓ Correlate API slowdowns with UI steps

RESTAuthJSONChaining

Mobile — profiles & mobile conditions

Emulate mobile environments for web journeys; use mobile synthetic for native app scenarios.

✓ Mobile UA, viewport, touch events
✓ CPU/network throttling for real-world feel
✓ CDN/3rd-party variance by region/ISP
✓ Combine with RUM to size field impact

Mobile WebProfilesThrottling

Environments & deployment patterns

Capability	Staging	Pre-prod	Prod
Secrets management	Encrypted vault	Encrypted vault	Encrypted vault
Private locations (on-prem/remote runners)	Supported	Supported	Supported
IP allowlists / egress control	Yes	Yes	Yes
Data residency (EU/global)	Configurable	Configurable	Configurable
Evidence retention (screens, HAR)	Short	Medium	Custom by plan
CI/CD gating (block on regression)	Yes	Yes	Optional

CSP & connectivity

With strict CSP, allow the runner/reporting endpoints in script-src and connect-src.

Sample CSP additions

script-src 'self' https://cdn.ekara.example;
connect-src 'self' https://ingest.ekara.example https://api.ekara.example;

Keep credentials in the secrets vault; never inline tokens in scripts.

Best practices

✓ Use private locations for internal apps & allowlists.
✓ Separate staging and prod alert channels.
✓ Align journey budgets with SLO per environment.
✓ Rotate secrets and restrict runner permissions.

Give your users the experience they deserve

Because just one bad digital experience is enough to drive a customer away, Ekara helps you ensure journeys that are smooth, high-performing, and always accessible.