Relativity gives TIFF-on-the-fly jobs priority over processing and native imaging jobs so reviewers can access document images when they need them. This on-demand rendering supports quick review and printing, especially when legal teams are working against tight deadlines.

Multiple Choice

What takes precedence over processing and native imaging jobs in Relativity?

In Relativity, TIFF-on-the-fly jobs take precedence over processing and native imaging jobs due to their function in the workflow. These jobs are designed to create TIFF images in real-time as documents are accessed or requested, making them critical for immediate review and printing needs. Their ability to produce images dynamically means that they are prioritized to ensure that users can view or print documents without unnecessary delays. This prioritization is essential in legal contexts where timely access to document images can be crucial for case management. By allowing TIFF-on-the-fly jobs to take precedence, Relativity ensures that users can work efficiently, particularly during high-pressure situations like trial preparation or depositions, where quick access to visual representations of documents is often required. Other job types, while important, do not have the same urgency or immediate impact on user workflow as TIFF-on-the-fly jobs, which is why they follow in priority when processing tasks are managed in the Relativity environment.

In a busy Relativity workspace, some work can wait in a queue. Other work becomes urgent the moment someone opens a document. TIFF-on-the-fly jobs belong to that second group: they take precedence over processing and native imaging jobs because they create document images when users need them. That priority helps keep review moving, especially when a file must be viewed or printed right away.

The idea is simple, though the workflow behind it matters. Relativity handles many kinds of work in the background, from bringing data into a workspace to generating images for later use. TIFF-on-the-fly jobs answer a more immediate need: a user has requested an image, and the system must create it on demand. Understanding that distinction makes the job priority easier to grasp.

Why an image may need to be created on demand

A TIFF image is a visual representation of a document. Legal teams often use these images to review materials, add annotations, or include pages in a production. Some documents already have images available. Others may need to be rendered from their native files, such as a spreadsheet, email, or word-processing document.

A TIFF-on-the-fly job creates an image as it’s needed, rather than waiting for a separate imaging job to generate images in advance. The request might come when a user opens a document or asks to view or print it. Relativity then has to turn the source file into a format the user can see.

That timing is the key. If the system had to wait behind a long list of background tasks, a user could be left staring at a loading screen while an important document remained out of reach. In a legal review, even a short delay can interrupt a discussion or slow down work on a filing. The system gives these on-demand image requests higher precedence so the requested content can appear sooner.

Priority is about timing, not importance

It’s tempting to think that a higher-priority job is always more important than every other job. That’s not quite it. In Relativity, priority reflects when a task is needed and what depends on it.

Processing jobs have a major role in a workspace. They bring electronically stored information into a usable form, extract text and metadata, and prepare documents for review. Without that work, teams may not have the records they need. Native imaging jobs also matter: they create images from native files, often in a planned or batch workflow.

But these jobs usually serve broader, ongoing tasks. A TIFF-on-the-fly request is different. Someone has asked for a specific image now. The request is tied to an active user action, so it receives priority over processing and native imaging jobs. Those background jobs remain important; they simply don’t take precedence over the immediate request.

Think of it like a print shop. A large batch of materials may be queued for later, but a customer at the counter needs one page printed now. The single page doesn’t matter more in the grand scheme. It’s just the task with the most immediate deadline.

What happens behind the scenes

When a user requests an image that isn’t already available, Relativity must render it. The source file is read, converted, and returned in a form that can be displayed or printed. The process depends on the file and the system’s configuration, so not every document will take the same amount of time.

The job’s high priority helps the image request move ahead of processing and native imaging work in the queue. That doesn’t mean every image appears instantly. A complex file, system load, or other technical issue may still affect how quickly it’s ready. Priority helps determine which work the system handles first; it doesn’t remove the work required to create the image.

There’s another useful distinction here: on-demand image creation isn’t the same as creating images for an entire collection in advance. Batch imaging can prepare many files so they’re ready for later review. TIFF-on-the-fly jobs fill gaps when a user needs an image that hasn’t already been created. One approach prepares ahead; the other responds to a request in the moment.

Why the distinction matters in legal review

Legal matters often involve large collections of emails, office files, PDFs, and other records. Reviewers may move quickly from one document to another, and teams may need to inspect a page together during a meeting or share a visual copy of a record. If the needed image isn’t ready, the delay can break the flow.

That’s especially noticeable during time-sensitive work, such as preparing materials for a deposition or reviewing a document during a case discussion. A reviewer may already have found the relevant record. The remaining step is simply to see it in image form. Giving the on-demand job priority helps connect the request to the result without making the user wait behind unrelated background work.

The benefit is practical rather than flashy: less friction. A system’s job queue can feel like plumbing—easy to ignore when everything works, impossible to ignore when it doesn’t. Prioritizing requests linked to live user activity helps keep that plumbing from becoming a bottleneck.

How this fits with other Relativity jobs

Relativity workspaces rely on different job types, each with a distinct role. Processing prepares incoming data. Native imaging creates images as part of a planned workflow. Other jobs may manage inventories, publish updated content, or support production tasks. Their place in the queue depends on the job and the system’s configuration.

TIFF-on-the-fly jobs stand out because they are triggered by an immediate request to view or print a document image. Their precedence over processing and native imaging jobs reflects that direct connection to a user’s current task. It isn’t a judgment on the value of processing or imaging; it’s a way to keep on-demand work responsive.

That distinction also helps when teams diagnose delays. If a user is waiting for an image, it’s useful to understand that the request may be handled through on-the-fly imaging rather than through a large imaging batch. If many jobs are running at once, administrators can consider the queue and the broader system load when investigating what’s slowing things down.

Keeping expectations realistic

Priority improves responsiveness, but it doesn’t guarantee that every request will be immediate. Image creation still requires system resources, and some native files are more demanding to render than others. Workload, file size, and configuration can all affect the experience.

It also helps to remember that on-the-fly imaging serves a specific need. It isn’t a replacement for processing or planned imaging. Those workflows prepare and manage data at a larger scale, while TIFF-on-the-fly jobs respond to requests for images that users need right then. Each has its place.

In short, TIFF-on-the-fly jobs take precedence over processing and native imaging jobs because they support immediate access to document images. They help users view or print a requested file without waiting behind broader background tasks. The logic is straightforward: when someone needs an image now, the system gives that request the first turn.