Technical FAQs for "PrizmDoc Viewer"

Document management can be a challenge for any organization, and law firms and legal departments are no exception. In fact, a recent Annual Law Department Operations Survey, found that “improving business processes” is the number one challenge for legal operations professionals in the era of digital transformation.

Most law firms have begun the move to a digital means of processing paper, managing case files, and securely collaborating on documents. But with mountains of paperwork that must be securely stored and easily located, making the leap to digital is no small feat.

In attempt to manage case files in a more efficient, cost-effective manner, some companies are implementing legal application software. Unfortunately, these platforms can be quite limited on their own. Often, the integration of document viewing and collaboration APIs into legal software is needed to help law firms and legal departments streamline processes without disrupting current case work.

Understanding the Challenges of Legal Document Management

CMS Wire’s 2019 State of the Digital Workplace named document management the most valuable digital office tool — beating out microservices, artificial intelligence, and other emerging technology. However, when asked how their document management systems were performing, only 12 percent  of respondents said it was working well. 

So, why are most document management systems providing such lackluster results? Often, the solutions simply aren’t able to address all of the complexities of managing the legal document workload. Let’s break down some of the most common issues law offices are facing when it comes to case file management:

Document Capture and Organization

Many firms are struggling to manage a tidal wave of paperwork coming their way via email and text, and thanks to smartphone cameras and other digital tools, these documents can also consist of .TIFF,.JPG, PDF, or raster files. 

Even paper forms can cause problems if they aren’t converted into digital formats. When law firms are filing affidavits or witness statements as paper files without backing them up electronically, they can easily be miscategorized or misplaced.

For legal organizations struggling with a variety of document formats,  Above The Law  recommends focusing first on information management in order to find an effective way of saving, searching, and working on multi-format documents.

Security

As CMSWire points out, “Security is, and will always be, a concern regarding legal documentation.”  If legal documents are corrupted, altered, or deleted due to a cyberattack or human error, serious repercussions, even bankruptcy, can result. 

These issues can seem insurmountable for legal organizations with thousands of files spread out across multiple storage locations and formats. If legal teams aren’t able to audit, search, and view files on-demand, they could face legal challenges, fines, or loss of reputation.

eDiscovery

Proper discovery during a case includes maintaining files in a way that makes information easily searchable and viewable. The eDiscovery process requires a wide-ranging search through operational and organizational data across multiple sources. Keyword-driven, full-text searches simplify this process by quickly identifying relevant documents. Document-viewer interactivity also makes it easier for attorneys to determine context and confidently include or exclude files.

What to Look For in a Solution

In order to improve document management, legal departments need a more tailored solution that provides a better user experience; one that operates more like their preferred consumer applications (think Amazon and Google) and can be quickly put to use with minimal training. Solutions should also feature a clean, modern interface that can be accessed on any device,  including personal computers, tablets, and smartphones. 

To avoid compliance challenges, the best options should also include advanced document search, editing, and viewing capabilities driven by best-in-class APIs designed to work with existing databases and tools. These integrations can help ensure chain of custody, quickly locate documents, and redact critical information, so that law offices can meet regulatory obligations without damaging the client experience.

Unfortunately, most legal applications don’t include custom document management functionality.  When it comes to building a tailor made solution, a good place to start is by talking with your current vendor about embedding secure, standards-based APIs and proven SDKs into existing platforms. Once those capabilities are in place, your legal organization should have a much easier time streamlining processes without disrupting current case work.

Technology change is coming to the legal industry. As noted by a recent IT Pro Portal survey, 60 percent of legal staff “would be happy to work alongside robotic technology if it meant fewer manual processes,” while the American Bar Association found that 49 percent of lawyers are now using legal analytics to improve service delivery.

Staffing firm Robert Half puts it simply. To enhance client service and efficacy, “law firms will take a more proactive approach to technology.” But as the tech market diversifies, new challenges emerge. Companies need to find best-fit solutions that both maximize digital budgets and deliver ROI. Let’s break down the coming “C” change with a look at three top-performing technology trends for 2020.

   Cultural Change 

Digital transformation has been making its way into the legal industry, but the trend toward broader technology adoption and integration has created a personnel plateau. While new solutions help streamline key processes such as document redaction, forms data capture, and document automation, they’re not enough in isolation. Steady gains demand technology deployments that align with existing process frameworks to encourage meaningful, cultural change.

Consider document automation. As noted by Law.com, while 2019 saw increased legal spending on automated contract review and document automation solutions, spending alone doesn’t guarantee success. Firms need tools capable of integration with current legal applications, allowing teams to leverage existing frameworks. The result? Cultural change that comes from within rather than being imposed from without.

    Communication and Collaboration

As noted by Forbes, while the legal industry has often focused on “silver bullets” to solve technology problems at scale, firms have been reticent to deploy solutions focused on existing process improvement. Case in point? Communication and collaboration. 

Law firms are expected to increase the availability of remote work options. As clients expect personalized, prompt, and digitally-proficient service, 2020 requires the adoption of technology solutions and best practices that enable communication anywhere, anytime.

In practice, this means deploying tools that allow staff to view multiple file types in a single browser, quickly add comments or annotations, and covert documents on-demand to encourage collaboration without compromising risk management. With documents kept in your application ecosystem, staff won’t need to leverage outside tools — such as email — that introduce potential compliance issues.

   Casework Consolidation

The third “C” is consolidation. Is it coming to legal firms this year? We think so. Here’s why. According to The Balance, ongoing amendments to the Federal Rules of Civil Procedure are changing the landscape of litigation as electronically stored information (ESI) such as emails, text messages, mixed media, and mobile data all become fair game in document discovery — and critical to successful casework.

The result? Law firms need technology solutions that both empower eDiscovery processes and consolidate casework efforts, making it easier to find what they’re looking for — faster — and ensure effective access control. From full-text, keyword-driven support for document searches to full-featured digital rights management (DRM), firms need all-in-one eDiscovery solutions that are easy to integrate, simple to customize, and help consolidate casework under a single search solution.

While collection and storage solutions have evolved to help manage the document deluge, problems emerge when it comes to personnel. As noted by Tech Republic, staff now cycle through 35 applications and perform more than 130 cut-and-paste actions per day as they attempt to view key resources and complete critical tasks. Big data is taking over the world, but it’s not being managed effectively. Documents of all shapes, sizes, files, and formats are everywhere.

The solution to this application overload in a document-dominated world? Customizable APIs — like those powering Accusoft’s industry-leading PrizmDoc™ Viewer — that allow developers to tackle everything from quick integrations to basic interface adjustments and advanced customization. Ready to do more with documents and get staff back on track? Here’s how PrizmDoc API customization can help.

Level One: Integration

As noted by the SD Times, APIs are the ideal solution for new-decade deployments because they offer the critical advantage of easy integration. Instead of taking the long road of designing applications, identifying interdependencies, and regulating resource calls from the ground up, customizable API solutions offer the shortcut of easy integration with existing apps, allowing staff to stay under the umbrella of familiar functions while adding value-driven features.

By simply adding the jQuery plugin to existing web applications, teams can use the full feature set of PrizmDoc Viewer  — which includes multi-format document viewing, search, annotation, redaction, and conversion — without the need for complex customization.

Level Two: Customizable Configuration Parameters

For many organizations, minor customization to basic functions like tab display and localization help viewer APIs align with user expectations and existing application frameworks. Using the jQuery namespace plugin, developers can customize basic UI elements and set specific initialization parameters. Teams can choose to hide or display tabs, specify the size of the viewer, and set the mode of comparison tools. 

Worth noting? Modifying PrizmDoc Viewer via the jQuery plugin requires no modification to actual code, allowing powerful customization with minimal effort and ensuring the viewer is always compatible with future release versions.  

Level Three: Interface API Customization

Need to do more with your customizable API? PrizmDoc Viewer is designed using an open markup approach, meaning all HTML and .css code is fully open and customizable. By modifying HTML templates or injecting your own code, you can create a completely redesigned interface that aligns with existing application formats or use the API’s unminified, unobfuscated JavaScript library to edit the business logic and behavior of the viewer. 

For example, PrizmDoc Viewer offers total control over the configuration and customization of its eSignature, allowing you to modify existing parameters or build your own from the ground up, complete with programmatic field fill-in.

Level Four: Completely Customize Your Document Viewer

Want complete customization control? Use PrizmDoc Viewer as sample code and build your own viewer from the ground up. Our Developer Guide provides insight on using the Viewer API to modify or augment application behavior and the configuration of PrizmDoc application services (PAS) and the PrizmDoc server to enhance both viewing functionality and automated document processing.

With effective document management now critical to business success, full-featured viewer integration and customization is required to help combat application overload, align software functionality, and improve end-user access. From out-of-the-box support to building from scratch, the customizable API of PrizmDoc Viewer gives your team total control.

Auto loans reached record high levels in 2019 as high-tech features and low interest boosted buyer interest. For vehicle loan processors, this creates both market opportunity and increased competition. If credit providers can’t keep pace with increasing complexity and evolving consumer expectations, it’s a hard road to revenue. To deliver market-leading lending, companies must tackle car loan automation: volume, variety, and velocity. 

Accounting for Volume

Data volumes are on the rise: 2.5 quintillion bytes of data are now generated every day, and this number is only increasing as connection speeds increase and mobile technology streamlines the process of creating, consuming, and communicating information.

What does this mean for vehicle credit application processors? That loan applications can easily get off track as staff spend time first sourcing the key data from clients and then finding software tools capable of viewing individual assets within their application. Accurate car loan calculation requires everything from credit score data to mortgage information, employment histories, W2s, pay stubs, banking histories, and current vehicle details. But with disparate data sources for each, it’s easy for auto loans to stall out.

Accusoft’s PrizmDoc Viewer streamlines the process. This HTML5 document viewer lets users view, convert, and annotate dozens of file types directly from your loan application software. The embedded functionality means you don’t need to download special tools or add another step to your car loan process.

Adapting to Variety

Data variety is also on the rise. For example, digital pay stubs now come in multiple formats including XLS or PDF, and potential clients may also send them as JPG or TIFF images. Word documents remain common for basic loan agreements and eSignatures, while many loan processors still require applicants to fill out forms by hand. 

The result? Loan providers need a way to consolidate this data and produce information-rich templates without wasting customer time or increasing IT complexity. ImageGear for .NET, C/C++, or Java easily integrates with existing applications and makes it possible to convert multiple document types into a single PDF. Even better, ImageGear’s OCR add-on empowers users to quickly search for and identify data within PDFs.

Automating Velocity

Speed matters, but with the volume and variety of data increasing, it’s easy for credit processors to go down under the deluge. Plus, with consumer choice increasing, clients aren’t willing to wait on slow loan processors. As noted by PWC, “A fast end-to-end application process is the largest differentiator in auto loan financing.” If buyers can get loan approval from the competition in 48 hours when you take a week, your sales won’t leave the starting line.

FormSuite for Structured Forms makes it easy for users to identity structured forms from predefined templates. This enables users to quickly capture data from forms. This embeddable SDK helps your financial application capture key data fields, enabling your developers to build a custom route for this information to secure databases. 

In addition, solutions like OnTask empower your team to create feature-rich forms at scale. Key data fields can be auto-populated with customized client information to reduce error rates, clients can complete remaining fields online, staff can make track the progress of form completion, and all parties can provide verified digital signatures to align processing speed with consumer expectations.

The auto loans market is changing as data volume, variety, and velocity increase. Tackle car loan processes and deliver on-demand automation with PrizmDoc Viewer, ImageGear, OnTask, and FormSuite.

Getting Started with PrizmDoc Viewer.  Searching for documents wastes time. Almost five hours a week for many information workers. But it doesn’t stop there. Documents require third-party applications to view, edit, and share. PrizmDoc™ Viewer integrates with your existing applications to deliver in-browser viewing that displays accurate and complete document content on-demand. Ready to get started? Here’s what you need to know.

Architecture Overview

Let’s start with the basics. What pieces do you need?

PrizmDoc Viewer contains three key components:

• The HTML5 Viewer — This runs in-browser to display your content.
• The Backend — This converts documents to SVG format for viewing.
• The Reverse Proxy — This is your web application. It sits between the viewer and the backend to request your content.

The backend itself has two components: PrizmDoc Application Services (PAS) and PrizmDoc Server. Both run on their own hosts or ports using their own REST APIs. PrizmDoc Server is the computing powerhouse of Accusoft’s document viewer — the actual engine that converts documents to SVG. 

PAS, meanwhile, has privileged access to your source document storage and is responsible for functions such as pre-converted content caching and the saving and loading of annotations. PAS doesn’t do the heavy lifting of document conversion; instead, your web app makes REST API calls to PAS, which in turn calls PrizmDoc Server to complete the conversion and serve SVG documents. 

If you need direct conversion for non-viewing work such as file format changes or burned-in annotations, your web app can make REST API calls directly to the Server.

Illustrating the Viewing Sequence

Next up: How does this all work?

Think of it like a conversation.

First your web app POSTs to PAS and asks for a new viewing session. PAS responds with a new ViewingSessionID. This lets your web app render the page HTML and pass it along to the in-browser document viewer, while simultaneously delivering original documents to PAS.

PAS talks to PrizmDoc Server, asking it to start conversion. Meanwhile, the document viewer has its own question for the PAS (via your web proxy): Can I have the first page now? Once available, PAS sends the first page back as an SVG even as other pages are still being converted, letting users view and interact with documents while conversion is underway. 

Sample Applications

How it all comes together: What does this look like in practice?

Start simple. Use one of our minimal “hello viewer” sample applications to see PrizmDoc Viewer in action. The Node.js, C#, and Java apps all load a single document into the browser using PrizmDoc, making it easier to visualize how the HTML5 viewer, your reverse proxy, and the PrizmDoc backend interact to deliver SVG content on-demand. From here, it’s easy to scale up and start converting, viewing and annotating documents at scale — all without leaving your application.

Document access drives productivity. Time spent searching for conversion tools puts on the breaks. Make it easier for staff to view the content they need, when they need it by integrating in-browser, in-app, on-demand document viewing. Try PrizmDoc Viewer on your own terms and on your own timeline.  Getting started with PrizmDoc Viewer is easy!  Try it now.

Document automation is a challenge most organizations face whether they realize it or not. Many teams end up collaborating through means of emailing, downloading, scanning, etc. In addition, some teams simply navigate through multiple programs and shared drives to accomplish tasks. While all of these options may seem like tried and true processes, wouldn’t it be easier if it could all happen in one secure place?

That’s where Accusoft’s PrizmDoc™ Suite comes in. Our solutions enable organizations to integrate our document viewer and editor into their own applications with ease. Through a collection of UI components and content manipulation APIs, PrizmDoc Suite helps web developers embed document viewing, editing, processing, and conversion into their applications. Our functionality integrates on the client and server side smoothly, creating a seamless experience for both you and your users.

If you have development resource or bandwidth constraints, let Accusoft be a part of your team. We have enablement services to help you speed things up. Let’s talk through how our team of experts can get your application up and running smoothly in no time.

Help Us Help You

It doesn’t matter what PrizmDoc product you need help integrating. We have you covered. Our PrizmDoc Suite Enablement Services help your team determine the best implementation approach to get your application up and running faster.

We start the process by discussing your feature requirements. What parts of our PrizmDoc Suite matter most to your organization? We want to understand your system architecture to provide the best service possible. So, we’ll be asking you questions like: “How will this product be used?” This helps us provide the best options for your specific organization.

Ease into Integration

First, we perform system analysis, considering factors like system architecture, server environment, data workflow, and more. Detailed instructions will follow, including assistance with planning and architecting solutions for your organization’s best performance.

Once we develop a plan, it’s time to train your team. We customize our training to your specific needs. Our goal is to create a strong foundation for future development and ongoing system maintenance. With our enablement training, your team will receive targeted guidance for creative feature implementation. We’ll focus on your organization’s unique challenges and deliver a training that makes the most sense for you.

We’d be happy to train your team on-site, but if that’s not possible, we’ll gladly set up remote training as well. We recommend that you bring multiple developers from your team to the training to enable open communication between our teams.

After It’s All Said and Done

Our customer service doesn’t end here. Accusoft offers an added full-support option for organizations that need ongoing assistance. You’ll receive free Upgrade Support for 90 days after your initial purchase, which includes email support and all product upgrades.

Customers wanting longer-term support may choose to extend Upgrade Support, or to move to Priority or Expedited support. Our support plans range from availability via email to 24/7 on call support. We value your partnership, and strive to provide the best possible customer service available.

Learn more about our enablement services in our fact sheet.

It’s a business battlefield out there. Not one of munitions and machines, but time and resources. Companies are struggling to provide end-users and consumers with the content they need, when they need it, without breaking the bank. Document management now helps companies make progress without losing productivity.

As noted by the SocioHerald, document management solutions are “booming worldwide” and on track for significant growth over the next five years, but as data volumes increase and connectivity allows simple sharing of more complex and media-rich content, large documents pose a new challenge. How do organizations deliver high-volume content quickly and accurately to drive on-demand end-user interaction?

Accusoft’s PrizmDoc Viewer can help deliver peace of mind — and win the large document loading war — with dual-pronged delivery of document pre-conversion and server-side search.

The Need for Speed

As noted by Forbes, one second is now the “magic number” when it comes to loading webpages — any slower and potential consumers begin to abandon ship. Welcome to the future.

Employees are now used to this kind of rapid retrieval when they search for data online, so they bring these same expectations into the office when it comes to document loading and access times. What does this mean in practice? Both user satisfaction and overall productivity suffers when documents don’t load fast enough.

So how do companies get to the finish line faster? Start with document pre-conversion. PrizmDoc Viewer contains a pre-conversion API that allows companies to create viewing packages for large documents using POST requests and JSON formatted source objects. Combined with the PAS layer of PrizmDoc server, this pre-conversion feature allows massive documents — such as Tolstoy’s 1493-page epic War and Peace — to load in just 0.69 seconds.

The caveat? Pre-conversion isn’t enough in isolation. To ensure users find what they’re looking for, and fast, organizations also need the benefit of server-side search.

Search and Rescue

Eighty percent of Americans now experience some type of “tech frustration” every day. Spotty connections and smartphone failures top the list, but documents also make the cut. Client-side searches within large documents can put a strain on a browser-based document viewers’ memory load. The best case scenario? Massive load times that frustrate staff efforts. Worst case? Complete viewer crashing as the browser overloads.

There’s a better way. With PrizmDoc Viewer’s server-side search feature, you can offload search work to the server, significantly reducing the strain on client-side viewer code. Using PrizmDoc’s Viewer configuration options, developers can also create custom server-side search parameters to reduce the strain on memory-capped browsers or more easily access text-heavy documents. Put simply? Server-side search can help rescue document retrieval speeds and reduce user frustration.

Document Detente

Slow-loading, large documents can ramp up hostilities between staff trying to get their work done and the tech initiatives that supposedly boost productivity. Fortunately, there are ways to reduce loading times and achieve document detente with PrizmDoc Viewer. Accusoft’s pre-conversion APIs and customizable server-side search parameters make this tech treaty even easier to achieve with straightforward in-app integration, providing complete functionality under the banner of in-house applications.

Ready to ramp up productivity and win the war on large document loading? See server-side speed in action with the server-side search demo or enlist the in-app advantage with a free trial today!

The PrizmDoc™ e-Signer supports filling out forms created using the PrizmDoc™ Template Designer, demonstrated here. Using the e-Signer, form fields can be filled out manually, filled out programmatically, or pre-populated with default values.

Once the fields are filled out, the user can click the Download Signed Form button to download a PDF with the filled in data. When this button is pressed, the e-Signer uses the PrizmDoc Server “MarkupBurner” API to “burn” the data into the document.

But what if you already have all of your user’s data, and you want to skip straight to burning the data into the document without loading the form into the e-Signer? In this post, I will outline how to create a Node.js service to do so.

The example code and instructions for running the service are available in the Accusoft prizmdoc-form-burner-example GitHub repository.

1. Handle Routing Form Burner GET Requests

This service will handle routing GET requests for burning data into a form, and this initial step sets up the route handling.

For this example, you will need to put your form definition file (or files) in a folder named “FormDefinitions” along with a form data file (with the same name but with a “data.json” file extension). Your form data file must contain key-value pairs, where each key is a form field ID and each value is the value to use to fill in the field. For example:

{
  "Text1": "Doe",
  "Text2": "John"
}

The corresponding form document will need to be put into a folder named “Documents”.

You will need to have Node.js and PrizmDoc Server installed. As an alternative to having PrizmDoc Server installed, you could connect to PrizmDoc Cloud.

Use npm to install express and axios. Express will be used to listen on port 3001 and route a GET request for a “form burner,” as shown below. Axios will be used to make http requests to PrizmDoc Server (in step 3).

Create a main.js file and, as shown below, require express, axios, and fs (which will be used to load a form data file, as shown below, as well as the form document and form definition file).

const express = require('express');
const axios = require('axios');
const app = express();
const fs = require('fs');

// PrizmDoc Server must be installed to use this.
const host = 'http://localhost:18681';

// Use the following instead to use PrizmDoc Cloud.
// const host = 'https://api.accusoft.com';
const apiKey = 'YOUR_API_KEY';

app.get('/formBurner/:id', function (req, res) {
  // This example uses the field value provided in the data.json file in the FormDefinitions folder.
  // You can update the code to instead load the data from elsewhere, such as a database.
  fs.readFile(`${__dirname}/FormDefinitions/${req.params.id}.data.json`, 'utf8', function (err, data) {
    const fieldValues = !err ? JSON.parse(data) : {};
    // See step 2 for the implementation of convertForm.
    convertForm(fieldValues, req.params.id, res);
  });
});

var server = app.listen(3001, () => console.log('listening on port 3001'));

2. Convert Each Form Field to Markup

The PrizmDoc Server MarkupBurner API takes markup JSON as input. It is necessary to convert each form field to the proper markup format. The convertForm method below opens the form definition file with the specified form definition ID and converts each field to markup, using the specified field values to fill in the fields. The markup is then burned into the form document (see step 3).

This example only demonstrates converting text fields but could be updated to also convert other field types, such as signatures and checkboxes.

const convertForm = (fieldValues, formDefinitionId, res) => {
  fs.readFile(`${__dirname}/FormDefinitions/${formDefinitionId}.json`, 'utf8', function (err, data) {
    const formDefinition = JSON.parse(data);
    let marks = [];

    const globalFontName = (formDefinition.globalSettings && formDefinition.globalSettings.fontName) || 'Fira Sans';
    const globalFontColor = (formDefinition.globalSettings && formDefinition.globalSettings.fontColor) || '#000000';

    formDefinition.formData.forEach(field => {
      if (field.template === 'TextTemplate') {
        let mark = {};
        if (field.multiline) {
          mark.type = 'TextAreaSignature';
          mark.maxFontSize = field.fontSize || 8;
          mark.fontStyle = [];
        } else {
          mark.type = 'TextInputSignature';
        }
        mark.uid = field.fieldId;
        mark.interactionMode = 'Full';
        mark.creationDateTime = '2019-06-25T19:28:13.396Z';
        mark.modificationDateTime = '2019-06-25T19:28:13.396Z';
        mark.mask = null;
        mark.maxLength = 0;
        mark.rectangle = { x: field.rectangle.x, y: field.rectangle.y, width: field.rectangle.width, height: field.rectangle.height };
        mark.pageData = { width: field.pageData.width, height: field.pageData.height };
        mark.pageNumber = field.pageNumber;
        mark.fontColor = (field.fontColor === 'UseGlobalFontColorSetting') ? globalFontColor : field.fontColor;
        mark.fontName = (field.fontName === 'UseGlobalFontNameSetting') ? globalFontName : field.fontName;
        mark.horizontalAlignment = field.horizontalAlignment ? (field.horizontalAlignment.charAt(0).toUpperCase() + field.horizontalAlignment.slice(1)) : 'Left';
        // If a field value is not provided, this example uses the value of "example".
        mark.text = (fieldValues[field.fieldId] !== undefined) ? fieldValues[field.fieldId] : 'example';
        marks.push(mark);
      }
    });

    // See step 3 for the implementation of burnForm.
    burnForm(marks, formDefinition.templateDocumentId, res);
  });
};

3. Burn the Markup into the Form

Use the PrizmDoc Server MarkupBurner API to burn the markup into the form document, as shown below. The burned document is returned in the response to the formBurner request.

const burnForm = async (marks, documentName, res) => {
  const { affinityToken, markupFileId } = await postMarkup(marks);
  console.log(`markupFileId: ${markupFileId}`);
  const documentFileId = await postDocument(documentName, affinityToken);
  console.log(`documentFileId: ${documentFileId}`);
  const processId = await postBurner(documentFileId, markupFileId, affinityToken);
  console.log(`processId: ${processId}`);
  const burnedDocumentFileId = await getBurner(processId, affinityToken);
  console.log(`burnedDocumentFileId: ${burnedDocumentFileId}`);
  const burnedDocument = await getBurnedDocument(burnedDocumentFileId, documentName, affinityToken);
  res.end(burnedDocument, 'binary');
};

First, the markup and form document are uploaded to PrizmDoc Server as “work files”.

const postMarkup = async marks => {
  const response = await axios({
    url: `${host}/PCCIS/V1/WorkFile?FileExtension=json`,
    data: {
      marks
    },
    method: 'POST',
    headers: {
      'Content-Type': 'octet-stream',
      'acs-api-key': apiKey
    }
  });

  return { markupFileId: response.data.fileId, affinityToken: response.data.affinityToken };
};

const postDocument = async (documentName, affinityToken) => {
  const response = await axios({
    url: `${host}/PCCIS/V1/WorkFile`,
    data: fs.readFileSync(__dirname + '/Documents/' + documentName),
    method: 'POST',
    headers: {
      'Content-Type': 'octet-stream',
      'acs-api-key': apiKey,
      'Accusoft-Affinity-Token': affinityToken || ''
    }
  });

  return response.data.fileId;
};

Next, a markup burner is created, using the uploaded markup and form document as input.

const postBurner = async (documentFileId, markupFileId, affinityToken) => {
  const response = await axios({
    url: `${host}/PCCIS/V1/MarkupBurner`,
    data: {
      'input': {
        'documentFileId': documentFileId,
        'markupFileId': markupFileId
      }
    },
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'acs-api-key': apiKey,
      'Accusoft-Affinity-Token': affinityToken || ''
    }
  });

  return response.data.processId;
};

Then, the status of the markup burner is checked until it’s completed.

const sleep = (ms) => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

const getBurner = async (processId, affinityToken) => {
  const response = await axios({
    url: `${host}/PCCIS/V1/MarkupBurner/${processId}`,
    method: 'GET',
    headers: {
      'Content-Type': 'application/json',
      'acs-api-key': apiKey,
      'Accusoft-Affinity-Token': affinityToken || ''
    }
  });

  console.log(`MarkupBurner percentComplete: ${response.data.percentComplete}`);

  if (response.data.state === 'complete') {
    return response.data.output.documentFileId;
  }

  if (response.data.state === 'error') {
    return;
  }

  await sleep(1000);
  return getBurner(processId, affinityToken);
};

Finally, the burned document is retrieved.

const getBurnedDocument = async (documentFileId, documentName, affinityToken) => {
  const response = await axios({
    url: `${host}/PCCIS/V1/WorkFile/${documentFileId}`,
    method: 'GET',
    responseType: 'arraybuffer',
    headers: {
      'Content-Type': 'application/pdf',
      'acs-api-key': apiKey,
      'Accusoft-Affinity-Token': affinityToken || ''
    }
  });

  // Uncomment the line below to save the burned document to disk.
  // fs.writeFileSync(`${__dirname}/${documentName}_burned.pdf`, response.data);

  return response.data;
};

Using the Service

Once you’ve followed these steps, you can use the service to directly burn your user data into your forms.

Run “npm install” and then “node main.js” to run the service. Then make a GET request to http://localhost:3001/formBurner/{your-form-id} to get a PDF of your form with filled data burned in.

The example code and more information are available in the Accusoft prizmdoc-form-burner-example GitHub repository.

Enterprises leverage an abundance of documents in their operations, record-keeping, and analysis activities. From customer forms, to agreements, purchasing data, and internal reports, companies generate a lot of documentation. With companies generating so many pieces of documentation, it can be difficult for humans to derive information from the masses. Companies have to structure these documents and their contents into formats that provide the desired online viewing functionalities and data capture.

For this reason, enterprises leverage document processing and imaging software to allow document contents to be searched, edited, and annotated in web applications. These solutions provide intuitive viewing and collaboration functionality in content management systems, while also structuring data from documents into a format that can be used in analyses.

Processing Documents

Imaging solutions produce digital copies of hardcopy documents. Digitizing these documents allows them to be further viewed and edited. Optical character recognition then generates computer-recognizable records of their content. This allows the contents to be searched and for instances of text to be tagged and categorized as variables in quantitative analysis. Document imaging also allows businesses to produce forms with interactive fields that can be completed online. Data entered into these fields will already exist in digital form as strings of text, where it can be organized into records for datasets.

Accessing Content

Intuitive content management systems with collaborative access provide internal teams a means to reference data sources (the documents) and how information is organized in them. It is important for businesses to leverage these intuitive viewing and collaborative functionalities so individuals can easily locate needed information.

The viewing functionalities enabled by software like PrizmDoc Viewer allows firms to determine what information and fields should be included in the datasets they create and subsequently feed into an ERP system for reporting and analysis. These systems provide modules to report, track, and analyze data structured from documents and other sources in one central tool. The ease in viewing, annotating, and comparing documents through PrizmDoc Viewer adds to the ability to communicate reporting needs and database construction for the ERP system.

Keeping Records and Generating Insights

Businesses organize information from fields or text-based instances into tabular databases for easier record-keeping. For example, a company in the medical field may need to pull a patient’s name, birthdate, insurance, and visit details from documents completed by staff for digital record keeping or presentation to the patient. Storing document data in this format also enables it to be queried for statistical analysis. A financial services firm may want to record data from past transaction-related documents so it can run tests to determine the probability of closing certain types of deals, as well as forecast expected earnings.

To complete these data captures, Accusoft suites and SDKs can digitize hard copy documents into their underlying structured data. This software can also detect fields in digital forms that automatically extract the text entered on their behalf. Using these tools, businesses organize documents into content management systems and structure data for analysis and reporting.

Enterprise email reigns supreme. As noted by HR Dive, 95 percent of organizations still use email as their primary communications tool, creating a default collaboration environment that relies on the dual tracks of corporate email accounts and per-seat productivity applications. Cost-effective collaboration is key.

The challenge? This isn’t cheap. From the obvious costs of renting a seat at the SaaS table to dealing with email compliance and security breaches, current collaboration processes can both strain budgets and frustrate boardrooms. Let’s break down three key scenarios and solutions for cost-effective collaboration.

Take a Seat

What does collaboration really cost? If you’re considering traditional productivity apps such as Microsoft Office or AutoCad, you pay by the seat. Integrated document viewers and editors can often cut down on high licensing costs. For many companies, spending thousands to have entire departments trained doesn’t offer the same utility of viewing, collaboration, and editing on-demand.

Also problematic? These apps exist outside other workflows such as email or in-house software solutions, meaning lost productivity every time employees need to switch programs or open new apps. As noted by Business 2 Community, this is especially problematic for the emerging Gen Z workforce. These “digital natives” expect collaboration tools that empower constant feedback, recognition, and encourage self-starter problem solving.

Evolving APIs can help solve by-the-seat challenges by allowing enterprises to easily integrate document viewing, editing, and collaboration across their own websites or applications with no seat spending required.

What You See and What You Get

Collaboration is a blessing and a curse. Consider the document workflow using email. Managers must modify original documents and send them to all collaborating employees, creating confusion about who needs to do what and who has final say in the document lifecycle. If original documents are permanently altered or lost the recovery costs could be substantial.

Moving to app-based collaboration tools improves the document management through-line but highlights the problem of digital rights management (DRM). Who has permission to view documents? How is markup tracked? What information is available or redacted? In many cases, executives need to sign or approve files but don’t need the authority to make more substantial changes. In others, C-suite members want to keep track of project status or track revenue generation but don’t need full access to files.

Collaboration APIs that empower viewing, annotation, redaction, eSignatures, and document comparison can help drive improved productivity without increasing cost.

Shared Documents, Shared Risk?

According to the Digital Workplace Group, lack of training is one of the top five enemies of effective collaboration. Why? Because complex tools often push staff to opt for simple solutions such as sending private or sensitive documents via email or social networks.

Here, the cost of document management takes two forms. First are advanced training courses in solutions such as Office, Excel, or AutoCad, which often cost upwards of $1,000 per person. More concerning are potential compliance violations if employees accidentally share private or protected information. Consider GDPR, which governs the data privacy of anyone living or working in the European Union. If companies don’t have the ability to easily redact sensitive information and limit document sharing access, it’s possible to escalate minor fines to more serious data-handling sanctions.

A better alternative? Streamlining document workflow and collaboration with integrated API solutions that work within existing apps, allow granular permission setting and reduce the security risk of shared documents.

Managing the Costs of Collaboration

Collaboration is now the expectation — but often presents cost challenges across per-seat expenses, digital rights management, and staff training. Accusoft’s PrizmDoc Suite leverages powerful APIs to deliver in-app document management that both increases staff efficiency and reduces total spend.

When it comes to your company’s application landscape, there are a variety of tools you already use to streamline processes. But do these tools help you manage your workloads efficiently? Document management is essential to any business. Many companies try to buy a solution and integrate it into their current processes, or build one from the ground up themselves. However, assigning developers to build, test, and maintain your own software isn’t efficient, agile, or advisable.

The other option isn’t really ideal, either. You’ll spend more of your IT budget on applications which are bloated with functionality you don’t need now, and likely never will. That also means investing in applications that lack flexible workflow structure or possibly limiting features and functionalities like advanced search.

The Value of Integration

Business executives are constantly bombarded with new technology alternatives. But before spending your budget on that new, shiny gadget, make sure you consider the more cost-effective, efficient alternative. Did you know that you can integrate SDKs and APIs into your current application to create a better document management process?

Using purpose-built APIs or SDKs for document viewing, OCR, barcoding, data capture, and conversion helps a business achieve important goals for any organization. With these integrations you can:

• Meet compliance requirements
• Provide context to structured data
• Ensure that individuals have permission-based access to sensitive data
• Foster collaboration across departments, clients, partners and other stakeholders
• Make content discoverable through full-text search
• Enable file viewing within your own application without opening a third party software

When an end-user is working within a CRM application, they often need to access a document that relates to a campaign, a datasheet that provides crucial information, or a contract which needs to be renewed. APIs create efficiencies by allowing for documents to be accessed by a user without having to switch from screen to screen.

Work Smarter, Not Harder

Your development team or application consulting partner could likely build this sort of functionality over time, just like you could have walked to work every day this week. You get the picture. It would take hours of wasted time to create a functionality that is only half the solution available elsewhere.

Luckily there’s a way to get the document management functions you need, and price pales in comparison to a DIY build. This alternative is highly competitive with other solutions in the market, yet it’s available without the expensive price tag of a stand-alone SaaS solution.

Accusoft’s portfolio of APIs and SDKs support the kinds of .NET, Java, C/C++, Node.js, and more application languages. Products like PrizmDoc Viewer, ImageGear, and OnTask help you obtain the features and functionalities you really need without the price of the ones you don’t.

You can even test drive what you need for a few days before you invest in it. If your team could build, test, and maintain something that meets your needs more efficiently, at a lower cost, why wouldn’t you jump on it?

Need more information on integrating toolkits instead of building your own solution? Download our eGuide Document Management – The First Step to Digital Transformation today. You’ll be glad you did.

In government offices and data centers, document archives and data repositories are highly effective for organizing information which remains at rest. For those occasions when information workers simply need to read or review the contents of a file, repositories like SharePoint are ideal.  But reading or reviewing is not the whole range of government business processes.

Even repositories which are integrated with business applications which address business functions like human capital management, Freedom of Information (FoI) requests, or asset management are documents which rarely remain unmodified.

Yet when a public sector employee needs to modify, move, or manipulate a document to reflect an event which occurs in the real world, it requires a combination of workflow and analytics which exceed the capabilities of document filing and storage applications.

Document repositories provide limited value-add for government organizations which need to serve thousands of constituents, have annual budgets in the billions of dollars, and ongoing infrastructure projects which keep people and economies moving.

Custom development of these functions into your business applications demands significant time and technical resource investment. Pre-built supported APIs and SDKs reduce these overhead demands.

Here are five workflow functions which government organizations should add to the document management functionality of their business applications to get the best value from their historical and day-forward data.

1. Document Viewing, Annotation, and Redaction

Accusoft’s PrizmDoc Viewer enables users to view, annotate, and redact information without needing third-party applications like Word or Adobe Acrobat Reader. This enhances application security and facilitates project-related document collaborations.

Most businesses can draw a bright line between internal and external documents. Internal document permissions can usually be applied based on role and privileged access. As time passes, document viewers eliminate concerns over incompatible document versions.

Government organizations, however, have transparency requirements. Many documents need to be made public, but citizen privacy could be compromised in some cases, requiring sensitive info be redacted for those without proper clearances.

2. Document Lifecycle Management

Creating, editing, sharing, approving, and converting documents to searchable file types can take up a lot of time for government employees across departments including legal, operations, and public works. ImageGear simplifies these processes.

By standardizing these application-embedded document activities to a single interface, government organizations can accelerate workflow-related activities like eSignature approvals, annotations, and OCR of scanned files.

3. Enhanced Application-Based Document Routing and Approvals

Government organizations which use Citizen Management apps negotiate contracts with redlines and redactions, which is easier to do in one application. Documents won’t get lost in email chains, and alerts enable effortless digital signatures. Workflows are visually trackable, so if one approver isn’t available, a document can be rerouted. Workflows don’t get stuck in a big data bottleneck.

4. Barcoding for Images and Physical Records

In government facilities, physical records are often stored in folders or boxes before digital conversion, and damage to the record may come in the form of blurry text or ink blotches. There’s a better way to store the data. Barcodes can help businesses store and process this data in a better way, but building a custom barcode recognition for your business application is cumbersome and may cause frustration.

Accusoft’s Barcode Xpress SDK enables users to collect critical document information with ease. This barcode reader can detect even the most damaged or broken barcodes for a variety of industries and there’s even a mobile scanner available.

5. Government Forms Processing
Public sector organizations have vast amounts of forms to expedite the intake of data from their citizens. Court cases, license applications, and invoices are only a few examples of forms which have standardized fields which can aid in the conversion process. Accusoft’s FormSuite enables users to customize form field detection and process it into your application.

Are you looking for ways to increase the administrative productivity of your information workers? Want to increase the speed of document processing, discovery, and approval processes?

Accusoft offers a wide spectrum of document workflow solutions for government organizations which are proven, supported, and require minimal development effort to enhance your existing application ecosystem. Contact us to discuss your unique requirements today.