Three months after closing its $6.75 billion purchase of Press Ganey Forsta, Qualtrics is cutting jobs across the combined company — a reduction that the experience-management technology company says reflects duplication between two organizations that were built independently.

The cuts are global, including the company’s dual headquarters in Seattle and Provo, Utah, and its international offices. Qualtrics is not publicly disclosing how many jobs were cut, and did not break out numbers by office, region, or job function.

One clue: Qualtrics sent impacted Seattle employees layoff notices under the Worker Adjustment and Retraining Notification Act, or WARN, according to one copy reviewed by GeekWire. The notice covers workers at Qualtrics Tower, 1201 Second Ave., its Seattle headquarters.

The Washington law applies only to layoffs of 50 or more at one site — so at least that many jobs were cut at the Seattle HQ. As of publication time, Qualtrics had not appeared in the Washington or Utah state WARN databases, which can sometimes lag the notices to employees by a day or more.

Individual employees learned their status by email Wednesday morning.

In a memo to employees, obtained by GeekWire, Qualtrics CEO Jason Maynard called the acquisition a “defining milestone” for the company but said it “meant making hard decisions about what the organization needed to operate and function as a single uniform team.”

“Since the acquisition closed, we’ve gone function by function, team by team, to understand where we have overlap and determine what we needed to do to move forward as one company,” he wrote, noting that the decisions were “made based on the structure of our combined organization: the roles we need, the capabilities we are building toward, and where we have duplication.”

Qualtrics makes software that companies use to collect, analyze, and adapt to feedback from customers and employees, a category of technology that it branded “experience management.”

Current and former employees posting publicly Wednesday on LinkedIn and other forums described cuts spanning departments and offices, including Seattle, Provo and international locations, and hitting both the legacy Qualtrics and Press Ganey Forsta sides of the business.

The Press Ganey Forsta acquisition, announced in October and completed in May, added what Qualtrics called the largest healthcare experience dataset in the industry. Press Ganey Forsta, based in Indiana, was itself the product of earlier mergers, and its Forsta products competed directly with Qualtrics.

The cuts follow a leadership shakeup in April, when Maynard removed five senior executives and outlined a broader reorganization spanning marketing, customer operations, IT and corporate development. Maynard, who joined from Oracle, became CEO in February.

It’s not the first round of cuts under private equity ownership. Qualtrics cut about 780 jobs, roughly 14% of its workforce, in October 2023 under then-CEO Zig Serafin, who cited complexity from years of rapid hiring. It had cut about 270 jobs earlier that year.

Qualtrics has been owned by private equity firm Silver Lake and Canada Pension Plan Investment Board since 2023, when they acquired it for $12.5 billion. It was the second time the company changed hands in under five years, following SAP’s $8 billion acquisition in 2019 and a 2021 IPO.

In my global instructions and memory rules for AI coding assistants (like Google Antigravity / Gemini / Claude), I keep a specific directive:

"When you need to create a temporary script to perform an action and the language doesn't really matter, prefer Dart over Python if Dart is an acceptable straightforward solution."

Whenever developers see this rule, they ask: Why Dart? Isn’t Python the undisputed king of glue scripts, quick automation, and AI tooling?

Python may be the default reflex for human developers, but from an AI pair-programming perspective, Python introduces unnecessary friction. Modern Dart consistently yields higher first-run success rates, zero environment headaches, and cleaner code.

Here is why this rule will make your AI workflows significantly more reliable.

1. Zero-Ceremony Execution: Escaping "Environment Hell"

When an AI writes a temporary Python script to process files or hit an endpoint, it frequently fails before line 1 even executes:

• Is the shell aliased to python or python3?
• Did it hit PEP 668 (error: externally-managed-environment)?
• Are dependencies managed with pip, pipx, poetry, conda, or uv?
• Did the agent import requests or httpx, only to discover you don’t have them installed in your active subshell?

With Dart, if the Dart SDK is installed, dart run script.dart (or simply dart script.dart) runs anywhere, immediately.

There is one official toolchain. No virtual environment activation, no broken path dependencies, and no package manager guessing games.

2. A Real "Batteries-Included" Core Library

Python's standard library is broad, but dated. To do ergonomic HTTP or clean subprocess streaming, agents almost always reach for third-party packages.

Dart’s core libraries (dart:io, dart:convert, dart:async) are built directly into the runtime and provide everything needed for system tooling out of the box:

• JSON & Data Encoding: jsonDecode, jsonEncode, utf8, base64 require zero external dependencies.
• Subprocess Management: Process.run() and Process.start() handle stdout/stderr cleanly without obscure shell escape pitfalls.
• Symmetrical File I/O: Direct access to both synchronous (readAsStringSync(), listSync()) and asynchronous APIs.

An agent can parse multi-megabyte JSON trees, decode base64 binary streams, and coordinate CLI processes in a single self-contained .dart file without touching a package manifest.

3. Need More Batteries? dart pub add Without Virtualenv Headaches

What happens when your script does need external packages (e.g., specialized cryptography, HTML scraping, or CLI argument parsers)?

In Python, pulling in a package is a minefield:

• Do you install globally and risk polluting system packages?
• Do you force the user or agent to run python3 -m venv .venv && source .venv/bin/activate?
• Which config file format do you generate: requirements.txt, Pipfile, setup.py, or pyproject.toml?

In Dart, there is zero package management friction:

1. One-Command Setup: An agent simply runs:

   dart pub add http path crypto

1. One Universal Manifest: There is only pubspec.yaml—clean, minimal, and standardized.
2. No Virtual Environments: Dart resolves and downloads dependencies into a centralized global cache (~/.pub-cache) and links them locally via .dart_tool/. You never have to activate a virtualenv, manage path shims, or resolve corrupted local site-packages.

Even when you need third-party packages, Dart remains painless.

4. Sound Typing + Modern Dart 3 Ergonomics

Dynamic typing in LLM-generated Python is a frequent source of bugs. Agents regularly produce code that trips on nested structures:

• KeyError on unexpected dictionary keys
• AttributeError: 'NoneType' object has no attribute 'get'
• Subtle type-coercion bugs when parsing CLI output

Dart provides sound static typing paired with fast local type inference (var / final), so scripts remain as concise as Python while the compiler catches structural errors before execution.

With Dart 3 Pattern Matching, extracting nested data from APIs or JSON logs is declarative and safe:

// Safe, expressive JSON extraction in Dart 3
final userName = switch (json) {
  {'user': {'profile': {'name': String n}}} => n,
  _ => 'Unknown User',
};

Add Records (String status, int count) to the mix, and the agent can return multiple structured values without defining throwaway classes or relying on untyped Python tuples.

5. Predictable, Deadlock-Free Asynchrony

Writing concurrent scripts in Python (asyncio) is notoriously fraught:

• Mixing synchronous file operations or subprocesses inside an event loop often blocks execution.
• Running into RuntimeError: This event loop is already running when tools invoke nested loops.

Dart was engineered from day one around a single-threaded event loop with first-class Future, Stream, and async/await:

// Clean, concurrent fan-out without third-party libraries
void main() async {
  final tasks = [
    fetchStatus(1),
    fetchStatus(2),
    fetchStatus(3),
  ];
  final results = await Future.wait(tasks);
  print('Completed: $results');
}

Concurrency in Dart scripts is lightweight, predictable, and doesn't suffer from obscure event-loop lifecycle bugs.

6. What About Rust?

Whenever static typing and reliability are mentioned, the immediate question is: "Why not tell the AI to write temporary tools in Rust?"

Rust is unmatched for production infrastructure, high-performance engines, and memory-critical services. But for AI-generated ad-hoc scripts and glue code, Rust introduces a different set of bottlenecks:

1. Minimalist std: Rust’s standard library intentionally excludes JSON parsing (serde_json), HTTP clients (reqwest), and an async runtime (tokio). An AI cannot write a standalone, zero-dependency script for common scripting tasks.
2. Compilation Latency: Compiling Rust crates through rustc/LLVM introduces a multi-second delay. In a tight agentic feedback loop (write → execute → inspect stdout → iterate), that compilation lag slows down the interaction.
3. Borrow Checker Ceremony: Ownership, lifetimes (&str vs String), and Box<dyn Error> force the LLM to spend extra tokens and reasoning cycles managing memory semantics that simply don't matter for a 50-line throwaway utility script.

⚖️ The Scripting Showdown

Dart occupies the sweet spot: the scripting agility and garbage collection of Python combined with the type safety and single-toolchain reliability that agents need.

7. The Training Data Paradox

Why does the AI default to Python in the first place? Dataset inertia.

Python dominates GitHub and StackOverflow by sheer legacy volume. But sheer volume does not equal linguistic ergonomics or agent reliability.

When you explicitly guide your AI coding assistant to use Dart for tooling and automation:

1. First-run execution rate increases because syntax and type safety prevent runtime traps.
2. Scripts run fast on Dart’s JIT compiler.
3. Artifacts are maintainable: What started as a quick one-off script is already typed, readable, and ready to evolve into a permanent CLI tool if needed.

💡 Try It In Your Own Setup

Add this instruction to your AI coding rules (.cursorrules, CLAUDE.md, Antigravity instructions, or system prompt):

When generating one-off scripts, automation tools, 
or data-processing utilities where the language 
is not specified, prefer Dart over Python if Dart 
provides a straightforward solution.

Dart isn't just for Flutter apps—it's one of the cleanest, most reliable scripting languages available for AI-assisted development.

Managing multiple WordPress.com sites just got easier. 

The Hosting Dashboard now has a persistent top bar and left sidebar that move with you between sites. Domain names, hosting, updates, and performance are now just one click away.

So whether you manage one WordPress.com site or 20, you’ll always know where things are.

Navigation that stays with you across sites

Instead of navigating through a separate set of controls for each site, you now work from the same persistent interface as you move between them.

If you’ve used WordPress Admin, the layout will feel familiar.

We intentionally aligned the sidebar with WP Admin patterns, so you spend less time figuring out where things are and more time getting work done.

What changes when you manage multiple sites

These changes become clearest when you’re switching between sites or repeating the same task across several of them.

Managing client sites: Routine tasks add up when you’re managing several sites, including the same plugins that need updating. Previously, that meant navigating out, switching sites, and starting over every time. Now your sites are always visible in the persistent nav. Move between them without losing your place.

Running multiple blogs or stores: Checking hosting status, renewing domain names, reviewing updates — tasks that used to require bouncing between dashboards are now accessible from one consistent view. Less hunting, more doing.

Coming from self-hosted WordPress: One reason people stay self-hosted is that WP Admin feels like home. The Hosting Dashboard follows the same sidebar logic, so moving between self-hosted WordPress and WordPress.com asks less of you.

One dashboard, whether you manage one site or 200

Whether you’re managing a handful of sites or a full client roster, the Hosting Dashboard works the same way. 

The interface doesn’t change as you grow, and neither does your workflow. The same navigation and workflow stay consistent as your site list grows.

This is only a navigation update — your sites, content, and settings stay exactly as they are.

Try your improved Hosting Dashboard

The updated navigation is now live in your Hosting Dashboard. Open it and try switching between a couple of sites, and you’ll see everything stays where you left it.

If you have any feedback or questions, our support team is here to help.