Technical FAQs

Question

Why are the fonts in my CAD files showing up garbled/unrecognizable/not as expected?

Answer

Some CAD/DWG files may include fonts that are not included in PrizmDoc Viewer’s default font set. PrizmDoc will choose the most appropriate substitute font to use in its place. The substitution process isn’t always perfect, and as a result, you will see garbled/unrecognizable characters in the Viewer.

In order to provide additional .SHX fonts for PrizmDoc to pull from, you can copy the necessary .SHX font files into the cad-fonts folder, located at:

Windows: ‪C:\Prizm\modules\cad-fonts
Linux: /usr/share/prizm/modules/cad-fonts

Alternatively, if you want to use fonts from that are located in a different directory, you can add the environment variable, ACAD, to explicitly specify the filepath of these fonts. his variable can be added under System Properties > Advanced > Environment Variables > System Variables > New... > ACAD. For the variable’s Value, specify a folder path that contains additional CAD font files for PrizmDoc to pull from.

* It is important to note that the Linux filesystem is case-senstive, so when adding custom CAD fonts on Linux, make sure that the fonts are named with case-sensitivity in mind. If you still see unexpected output after adding the fonts to the cad-fonts folder, try renaming the fonts to all lowercase.

** Note that the cad-fonts folder was added in PrizmDoc 13.20, so to add custom cad fonts on earlier versions of Prizm, use the environmental variable approach.

Question

What is the absolute bare minimum I need to use PrizmDoc Cloud?

Answer

This will allow you to load a document via a URL using PrizmDoc Cloud. Just include your PrizmDoc Cloud API key in the POST request headers.

Please note: This is purely intended as a proof-of-concept. You should never include your API key in your client-side Javascript.

<!DOCTYPE html>

<html lang="en">
<head>
    <!-- Metadata -->
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="description" content="" />

    <!-- Title -->
    <title>AccuSample</title>

    <!-- Libraries -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css">

    <!-- PrizmDoc CSS -->
    <link rel="stylesheet" href="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/css/viewercontrol.css">
    <link rel="stylesheet" href="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/css/viewer.css">

    <!-- Inline Stylesheet -->
    <style></style>

</head>
<body>

    <!-- #viewer -->
    <div id="viewer" class="pccv pcc-full-screen"></div>

    <!-- Libraries -->
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/jquery-3.4.1.min.js"></script>
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/jquery.hotkeys.min.js"></script>
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/underscore.min.js"></script>

    <!-- PrizmDoc JS -->
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/viewercontrol.js"></script>
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/viewer.js"></script>
    <script src="https://raw.githack.com/Accusoft/hello-prizmdoc-viewer-with-nodejs-and-html/master/public/viewer-assets/js/viewerCustomizations.js"></script>

    <!-- Inline Script -->
    <script>

        let viewingSessionId;
        let viewerControl;

        $(document).ready(function() {
            $.ajax({
                "type": "POST",
                "url": "https://api.accusoft.com/prizmdoc/ViewingSession",
                "headers": {
                    "acs-api-key": "4lTamQVZmrkqZhH8cZhdu7L0xyhUa3gorcaCFQpA_zmuowZs4zoF39V4IckpnVW_"
                },
                "data": JSON.stringify({
                    "source": {
                        "type": "url",
                        "url": "https://www.usability.gov/sites/default/files/creating-wireframes.pdf"
                    }
                })
            }).done(function(response) {
                PCCViewer.Ajax.setHeaders({
                    "acs-api-key": "4lTamQVZmrkqZhH8cZhdu7L0xyhUa3gorcaCFQpA_zmuowZs4zoF39V4IckpnVW_"
                });

                viewingSessionId = response["viewingSessionId"];

                // Initialize viewer
                viewerControl = $("#viewer").pccViewer({ 
                    "documentID": viewingSessionId,
                    "imageHandlerUrl": "https://api.accusoft.com/prizmdoc",
                    "language": viewerCustomizations.languages["en-US"],
                    "template": viewerCustomizations.template,
                    "icons": viewerCustomizations.icons,
                    "annotationsMode": "LayeredAnnotations"
                }).viewerControl;

                viewerControl.on("ViewerReady", function() {
                    console.log("Ready!");
                });
            });
        });

    </script>

</body>
</html>

PrizmDoc Cells requires a connection to an instance of PrizmDoc Viewer with Microsoft Office conversion enabled in order to display most embedded objects. You will find instructions on how to configure a connection to PrizmDoc Viewer server here.

Question

How can I make significant changes to the UI of a PrizmDoc sample?

Answer

While jQuery can be used to make some small changes to the samples UI, it does not always make sense to make your changes programmatically on the front-end.

In this case, you will want to make your UI changes to the HTML templates used to compile the template that is passed in during viewer initialization.

To make changes and recompile the templates, you can utilize the following GitHub repository:

https://github.com/Accusoft/prizmdoc-viewer

Many organizations utilize spreadsheets to track data and perform complex calculations. Since spreadsheets offer substantial flexibility, it’s not uncommon for a single organization to use them in a variety of ways. For instance, one department might use them for budgeting while another deploys them for risk assessment. Although they can handle complex calculations, spreadsheets are relatively easy to set up and don’t require the same programming knowledge as more specialized solutions. That accessibility has led many organizations to simply convert Excel to web applications using API integrations rather than building new functionality from scratch.

Why You Should Convert Excel Files to Web Applications

Consumers often turn to financial and insurance companies looking for simple answers to simple questions: 

  • How many payments will it take to eliminate my debt?
  • Will adding another person to my insurance policy change my rate?
  • What will the monthly payments on my loan cost based on different interest rates?

To answer questions like these, someone in the organization typically enters the customer’s data into a premade spreadsheet, applies a few conditions using preset formulas, and shares the result. This process could be significantly streamlined by making these calculations readily available as a web application to anyone who visits the firm’s website, allowing both prospective and current customers to get answers quickly while also freeing up time for employees to work on more high-value tasks.

Unfortunately, building a secure, functional web application takes up valuable development resources. A developer could easily spend weeks converting complex spreadsheet formulas into a fully-functional application that integrates into the website or larger platform seamlessly. Even worse, if anything about those formulas were to change (as is often the case with financial and insurance formulas), more development resources will need to be pulled away from existing projects to make the updates.

By converting Excel files to web applications, firms can avoid these problems and provide clients with ready access to the calculations they need. FinTech and InsurTech developers can accommodate this need by building integrations into their solutions that allow users to easily upload and share spreadsheets entirely within an application and without any Microsoft Word dependencies. This bypasses the time-consuming build process and makes it much easier to update the formulas as needed.

Keeping Your Spreadsheets Secure

Of course, making spreadsheets readily available as web applications presents a few important security challenges. Many of the calculations running inside an organization’s spreadsheets are proprietary or contain hidden data that needs to remain private for various confidentiality reasons. That’s why companies are hesitant to simply send copies of their internal spreadsheets to customers or vendors. If those Excel files are made accessible online, there’s an obvious risk that someone could download a copy for themselves or access valuable private intellectual property.

Incidentally, this is also the reason why many firms struggle with sharing spreadsheets even in a collaborative environment. Not only are .XLSX files among the most commonly used file extensions by malware, but granting cloud providers or email servers access to spreadsheets represents too great a security risk for companies in heavily regulated industries.

By converting Excel to web applications, however, organizations can maintain strict access and visibility controls over their spreadsheet files. A good spreadsheet viewer integration will allow users to determine what people see when they use the application and also what information they can access. Formulas and calculations that contain vital intellectual property can be hidden completely. Visitors can be restricted to only editing cells that apply to their information, allowing them to use the spreadsheet without breaking or altering its functionality.

Sharing controls can also restrict what can be downloaded locally. A visitor may need to download or print a copy of their calculations, but they don’t need to download a fully functional copy of the spreadsheet file. Even in a collaborative environment, allowing people to download and edit copies of a spreadsheet can introduce significant version confusion. By keeping everything safely within the confines of the organization’s larger web application, essential data remains as secure and up-to-date as possible.

Other Reasons to Convert Excel to Web Applications

The versatility of spreadsheets allows people to adapt them to a variety of uses. In addition to more traditional budgeting and adjustment tasks, they can also be used for things like calculating survey results, analyzing resource usage, or estimating server uptime. Adding customizable calculators that provide quick results to a website experience can provide customers with important information and keep them engaged. 

Rather than building a specialized app or plug-in for every one of these calculators, organizations can simply use a spreadsheet viewer integration to quickly create one without any specialized coding or development knowledge. When the integration is set up within their solution, they can even customize it to match their branding and make it look more like a designed application than a simple spreadsheet.

Explore the Potential of Spreadsheet Integration with PrizmDoc Cells

Accusoft’s PrizmDoc Cells was originally designed to help our clients securely view and share XLSX files without any third party dependencies, but it’s increasingly being used to help improve customer experiences across a variety of applications. Get a hands-on experience with this API-driven integration to explore the potential of converting your Excel files to web applications. For a more detailed overview of what you can do with PrizmDoc Cells, sign up for a free trial.

Question

When I click on the download button a ‘download options’ pane appears to the left of the Viewer.

Is there a way I can modify the client code such that clicking the download button skips this step and just downloads the document as a PDF, burning in all the marks/redactions/e-signatures?

Answer

To clear the event listener for the download button and attach your own, you can add this in your client-side JavaScript after the Viewer has been initialized:

$("button.pcc-icon.pcc-icon-download").off("click");

$("button.pcc-icon.pcc-icon-download").on("click", function (event) {
    $("div.pcc-select-download div.pcc-label").html("PDF");
    $("div[data-pcc-checkbox=\"burnMarks\"]").addClass("pcc-checked");
    $("button[data-pcc-download=\"download\"]").click();
});

This will add a new click listener to the download button. In the example above, the click listener sets download parameters (type is set to “PDF”, and marks/redactions/esignatures are included), and then immediately calls the click event on the “download” button that would normally be in the download pane. This should make it so that when the user clicks the download button, the notification dialog immediately appears instead of the download pane, as shown below:

From here the user can click the “save” button to download the resultant document.

top coding trends

The software development industry is changing more rapidly than ever before. With new technology hitting the market on a regular basis, software vendors need to become flexible enough to adapt to the top coding trends if they want to remain competitive.

After a tumultuous 2020, the industry has seen a number of key trends emerge in the first half of 2021. Here are some of the top coding trends worth watching in the second half of the year.

Top 5 Coding Trends of 2021 (So Far)

1. Open-Source Evolution

Developers have been turning to open-source solutions for some time now as a quick way to integrate new features into their applications. While there are a lot of great benefits to using open-source code, it’s not always the simple solution that it appears to be. Substantial work may need to be done to implement the specific features an application requires. More importantly, open-source solutions rarely offer much in the way of support or security updates, and there can also be complicated intellectual property issues to consider when incorporating open source code into a proprietary application.

That’s why many innovative developers are using stable open-source solutions as a foundation for creating more feature-rich software SDKs. For teams building new applications, it’s often much easier to implement one of these integrations because it will require far less configurations and additional coding to get up and running. They can also get the benefits of dedicated support and not have to worry about whether their new integration will create any legal issues down the road.

2. UX Design

With the proliferation of Software as a Service (SaaS) platforms and the widespread use of open source development resources, it’s becoming easier for organizations to find the applications that suit their business needs. What they can’t always find, however, is a solution that’s easy for their employees and customers to use. That’s why the quality of an application’s user experience (UX) is quickly becoming a key differentiator in the software market.

Rather than implementing UX features at a later stage of the coding process, developers need to consider how users will interact with their solution from the very beginning. Software needs to be intuitive and easy to implement out-of-the-box. This applies equally to end-user products and developer-focused SDK integrations. No one has time to struggle with software that’s difficult to use. If a solution proves too cumbersome and hard to implement, customers will likely turn to a competing product that offers a better user experience. The more time developers spend considering their software’s UX, the better they’ll be able to adapt it to customer needs in the future.

3. Responsive Mobile Support

For many years, there was a somewhat artificial distinction between mobile software development and desktop development. But in a world where half of all internet activity comes from mobile devices, no developer working on web-based applications can afford to consider their software “just” for desktops. Just as website designers have been building pages that respond dynamically to different screen sizes and control interfaces, developers must also account for the unique characteristics of mobile devices.

The unique characteristics of mobile screens present specific challenges regarding the application’s user interface (UI). Simply providing standard desktop controls is bound to result in a frustrating mobile experience. Mobile responsive applications can accommodate touch-specific controls (such as pinch-to-zoom) without compromising the desktop experience at the same time. Developers must think about what kinds of devices their software solutions will be used on if they’re to build features and tools that will truly benefit their customers.

4. API Integrations

Today’s developers no longer need to build every feature their application might require from scratch. Thanks to a new generation of web API technology, it’s easier than ever to find software integrations that can quickly and easily add vital features without having to dedicate weeks of development time to building them. Understanding which web application features can be incorporated via a REST API helps development teams to focus their limited resources and time on the truly unique features that will help set them apart from the competition.

Utilizing web API technologies can streamline sprints and shorten development time significantly. That’s because much of the “trial and error” work of building a new feature is eliminated. Rather than designing and testing new capabilities for months, developers can simply implement a tested and proven web API integration within a matter of days. That helps to keep budgets under control and development schedules on track to make targeted launch days.

5. Remote Work

When the COVID-19 pandemic struck the world in early 2020, many software developers transitioned to a remote workplace arrangement. As other industries begin to tentatively return to the office, tech workers seem to have become quite accustomed to working remotely. According to a late 2020 survey conducted by Indeed, nearly half of participants reported that they now have the option to work remotely on a permanent basis, with 95 percent of them planning to do so. Perhaps even more telling, however, was the finding that 60 percent of tech workers are willing to take a pay cut in order to keep working from home.

Software vendors will have to accommodate these expectations if they hope to remain competitive when it comes to finding and retaining talent. Project managers should not expect work patterns to go back to the way they were before the pandemic. They will be better served focusing on how to organize remote work efficiently and how to provide the resources developers need to be productive while working from home. Transitioning to a more remote workforce is also allowing organizations to tap into a much broader pool of talent, which will help to bring more diverse voices and experiences into the development process.

Keeping an Eye on Future Trends

The software development teams at Accusoft are always looking ahead to see where today’s coding trends are leading the industry. That’s why we’ve been building easy-to-implement, lightweight SDKs like the free-to-use Accusoft PDF Viewer alongside our stable of versatile API solutions like PrizmDoc Viewer. We also continue to make ongoing improvements to our products to provide a better user experience for customers.

Our collection of software integrations can help development teams keep up with today’s top coding trends. Whether you’re looking to quickly integrate new features into an existing application or are looking for the right tools to support your next project, we have the API and SDK resources to keep you on-budget and on-time. Check out the Accusoft Resource Center to learn more.

excel spreadsheet formulas

Document management solutions are well-equipped to handle common file types like DOCX and PDF format. When developers are building software to manage workflows and make files accessible through web-based applications, they can typically turn to HTML5 viewers and document processing integrations to provide the document features their customers require. 

When it comes to Microsoft Excel spreadsheets, however, there are some additional considerations that often create difficulties. One aspect of XLSX workbooks that deserves special attention is how applications manage, secure, and control spreadsheet formulas.

Securing Proprietary Formulas

Many financial services and insurance organizations depend upon proprietary information like specialized, unique formulas to provide their customers with beneficial insights. Insurance underwriters, for example, may have a special calculation they use when setting their rates, while an investment firm likely has a risk formula that helps them to identify best opportunities for clients.

Such formulas are often the product of many years of work and experience in the industry and are inexorably linked to a firm’s service offerings. If customers or competitors were able to access those formulas directly, they may be able to adapt them for use elsewhere without the original firm’s permission.

Spreadsheets pose a unique challenge in this regard because the typical workbook contains many formulas, some of which may contain proprietary information. This may not be much of a problem for internal use within an organization, but it could become a problem the moment those spreadsheets are shared with someone outside the organization or with someone who lacks the proper authorization. While cells in an Excel spreadsheet can be hidden or password protected, these protections can potentially be breached by someone familiar with Microsoft security features once they’ve downloaded the file.

Maintaining Spreadsheet Control

Anyone who has accidentally deleted or changed some portion of a spreadsheet formula in a single cell and wrecked calculations throughout a workbook knows how important it is to keep those formulas locked from unnecessary editing. If the workbook is being shared with multiple users, the odds are good that someone will make a mistake somewhere, potentially altering important calculations and providing a misleading portrayal of the available data.

The challenges are even greater when spreadsheets are shared online. A public facing Excel spreadsheet used to make financial calculations, for instance, could be rendered useless if someone were to alter (knowingly or unknowingly) the formula information in a cell. And if the workbook is downloadable, undetected formula changes could be passed on with the file, making it difficult to know which copies of the workbook are accurate and which ones contain errors. 

Protecting Spreadsheet Formulas with PrizmDoc Cells

Developers have long faced two choices when it comes to managing spreadsheets within their applications. One option is to manage the XLSX files themselves while depending upon Microsoft Excel to actually open and view the spreadsheet. While this approach maintains the full functionality of Excel, it creates serious control issues as the user is required to download the file from the secure application environment. If they make changes, they can then upload the file again, creating a potential for version confusion.

The other option is to keep the spreadsheet in application storage, but render it as a print preview in an HTML5 viewer. While this approach certainly protects spreadsheet formulas, it’s also little more than a static view of a spreadsheet, which is only useful if an existing spreadsheet needs to be reviewed and not interacted with in any way.

Accusoft’s PrizmDoc Cells is an API-based integration that allows developers to securely embed XLSX files within their web-based applications while retaining the ability to edit and interact with them. A financial planning workbook, for instance, could be embedded within the browser to provide much of the basic functionality users are familiar with from Excel. This makes it ideal for applications that require a balance of usability and security, such as a digital vault that keeps vital financial data within a secure environment.

When uploading an XLSX file for display using PrizmDoc Cells, there are a few options that make it easy to protect valuable spreadsheet formulas.

Formula View/Edit Settings

There are two formula options that developers can easily adjust based on the needs of the application or the use case of the customer. The “canView” setting determines whether or not formulas are even sent to the browser for viewing. If set to “false,” any formulas within the spreadsheet will be automatically hidden. The “canEdit” setting either gives or denies users permission to edit or enter formulas. Hiding formulas is ideal for situations involving proprietary information, while editing restrictions are more suitable for internal workflows designed to reduce human error.

Value-Only Upload

When an XLSX file is uploaded, all cell values and formulas are normally preserved. This allows the workbook to retain the same basic functionality it has in Excel. For situations where the spreadsheet’s values need to be shared, but no changes are being made to the formulas, PrizmDoc Cells can upload workbooks as “values-only,” which removes all formulas from the embedded version. After being uploaded in this way, the spreadsheet can then have individual cells redacted as needed to further enhance security. Text can be placed in redacted cells to indicate why values were removed.

Enhance Your Application’s Spreadsheet Functionality

As an API integration, PrizmDoc Cells integrates smoothly into any web-based application. It also interfaces seamlessly with PrizmDoc Viewer to provide a broader range of viewing features when it comes to spreadsheets. Whitelabeling features allow developers to customize and rebrand the UI as part of their own software solution.

Find out how easy PrizmDoc Cells makes it to manage spreadsheets within your application by downloading a free trial. It’s the best way to get a close up view of how this powerful integration performs within your dev environment.

Question

How can I annotate or redact search results within PrizmDoc? What annotation or redaction types are supported? How can I change the properties of the created marks?

Answer

You can annotate or redact search results using the addMarkFromSearchResult() function from ViewerControl. This function creates a new mark of a specific type and adds it to the location where the specified search result is.

The addMarkFromSearchResult() supports mark types: TextSelectionRedaction, HighlightAnnotation, StrikethroughAnnotation and TextHyperlinkAnnotation.

The addMarkFromSearchResult() function takes two arguments: searchResult and markType. The searchResult is the search result that you want to annotate/redact and markType is the type of mark that will be created.

To perform a search and redact the search results, use the following example:

var requestObject = PCCViewer.search('Con');
 var marks = [];
 var mark;
 requestObject.on(PCCViewer.EventType.SearchCompleted, function (event) {
     var searchResults = event.completedSearchResults;
     for (var i = 0; i < searchResults.length; i++) {
         mark = viewer.viewerControl.addMarkFromSearchResult(searchResults[i], PCCViewer.Mark.Type.TextSelectionRedaction);
         marks.push(mark);
     }
 });

To create a different annotation type from a search result you would change the second argument to the different type. For example, if you wanted a textHyperLinkAnnotation you could do the following:

mark = viewer.viewerControl.addMarkFromSearchResult(result, PCCViewer.Mark.Type.TextHyperlinkAnnotation);

Changing the properties of the mark is fairly straightforward. To set the fill color and the URL string in the TextHyperlinkAnnotation, you would add this after creating the mark:

mark.setHref("https://www.accusoft.com");
mark.setFillColor("#FF0000");

More information on mark types and their properties can be found in our documentation here.

Question

I know the coordinates and dimensions of the content I would like to highlight, but the highlight annotation only works on text. Is there a way to create an annotation that highlights a specific area of a document?

Answer

The best way to do this would be to create a yellow rectangle annotation with 50% opacity (these are the same default values used by the text highlight annotation). The code below demonstrates how to do this in the viewer:

//Create a new rectangle annotation
var rectangleMark = viewer.viewerControl.addMark(1,  PCCViewer.Mark.Type.RectangleAnnotation);
//Set the coordinates and dimensions of the annotation
rectangleMark.setRectangle({x: 100, y:  100,  width : 200, height: 200});
//Set fillcolor to yellow
rectangleMark.setFillColor("#FFFF00");
//Remove the border
rectangleMark.setBorderColor("transparent");
//Set opacity to 50%
rectangleMark.setOpacity(127);

Long resistant to technological change, the insurance industry has made great strides over the last decade to implement innovative InsurTech solutions that upend longstanding market practices. As insurance providers explore new strategies for attracting a new generation of customers, they continue to rely heavily upon InsurTech developers to build the solutions that help them expand their customer base.

The Insurance Industry’s “Protection Gap”

Today’s insurance companies are offering more products and services than ever before, and yet at the same time, most people are carrying less insurance they need to protect themselves from risk. This “protection gap” is at least partially the result of large amounts of friction when it comes to purchasing insurance. People are either choosing to not buy insurance products, or they don’t know what options are available to them.

Part of this problem is the result of outdated models many organizations use to sell insurance. There’s an old adage that insurance is something that is “sold” rather than something that is “bought.” In this model, customers are expected to interact with an insurance agent who actively sells them a particular coverage.

Unfortunately, this model is becoming less and less effective in an increasingly digitized world, especially when it comes to younger generations of customers who expect the same level of frictionless convenience from insurers that they now get from many financial services (especially those powered by FinTech solutions).

What Is Embedded Insurance?

One potential solution to this challenge is a new strategy known as embedded insurance. This approach first identifies purchases or situations where insurance is required or would present clear added value. Some examples could include the purchase of an automobile, a vacation package, or even a potentially hazardous activity like skiing. An appropriately risk-adjusted insurance package is then offered to customers at the point of sale, or “embedded” within the customer experience.

There are tremendous advantages to this strategy. In the first place, it allows insurers to offer their products to customers who need them most at the precise point when they need them. Rather than having to go through the laborious process of contacting an insurance agent to get a quote for a new automotive policy after someone buys a new car, they can simply update their plan or add insurance services at the same time they’re purchasing the car itself. Customers are less likely to put off getting insurance (and then often forgetting to do so later), and the insurance provider has an opportunity to offer services to the people most likely to purchase them. For the provider, it’s a much more efficient approach than relying on outdated cold calling techniques to sell policies that may or may not meet the current needs of a customer.

Technical Challenges of Embedded Insurance

In order to embed insurance offerings effectively, however, providers first need to overcome a few technology challenges. From improved data capture tools that allow them to conduct faster, more customized underwriting to integrations that connect their applications to partner ecosystems, a new generation of InsurTech solutions will be needed to remake insurance business models.

Better Data Capture

Having accurate information is essential to insurance underwriting. This is even more important when it comes to embedded insurance because rates need to be calculated quickly so they can be provided along with other purchases. In many cases, form information may need to be processed quickly to obtain key data on the customer and the details of their purchase. When InsurTech applications are equipped with automated forms processing tools, they can quickly extract key information and use it to make faster, more data-driven decisions.

Versatile Viewing Capabilities

Whether an InsurTech application stands on its own or is integrated into another service offering, customers will often need to view information about their policy options in order to make an informed decision. On the firm’s end, insurance agents may need to review application details or bring up other resources to review when finalizing rates. By building viewing capabilities into their InsurTech applications with integrations like an HTML5 viewer, developers can ensure that their customers will never be caught depending upon external platforms for document viewing or sharing.

Expanded Contract Automation

Many insurance policies still require some form of contract, even if digital signature technology allows these forms to exist entirely in electronic format. Having the ability to rapidly assemble a contract as part of an embedded insurance solution can further enhance the streamlined customer experience. InsurTech developers can integrate automated document assembly tools to rapidly build contracts from pre-existing templates and quickly fill in the necessary details or add additional clauses.

Accusoft InsurTech Solutions for Embedded Insurance

Accusoft’s collection of SDK and API integrations give InsurTech developers the tools they need to enhance the flexibility of their applications. Our software solutions provide proven, market-ready viewing and processing features so development teams can keep their focus on refining their platform’s innovative core functionality. Whether it’s the versatile forms processing features of FormSuite, the powerful HTML5 viewing capabilities of PrizmDoc Viewer, or the automated document assembly tools of PrizmDoc Editor, Accusoft integrations can help InsurTech developers get their applications to market faster and explore the possibilities of embedded insurance.

We’ve been working hard to design software integrations that meet the needs of the insurance industry and InsurTech developers. Download our InsurTech solutions fact sheet to see how our constantly evolving family of SDKs and APIs can improve your application’s capabilities and performance.

As speed and efficiency have become increasingly vital for business success, it’s hardly a surprise that organizations across many industries have turned to white labeling as a way of retaining their competitive edge. While white labeling can be found in every industry, it’s proved to be incredibly important in the technology sector, where many independent software vendors rely upon white label software to build better applications and solutions.

How Does White Labeling Work?

In many instances, organizations need to launch a product quickly and may not have expertise in some aspect of their business. A software developer that specializes in FinTech solutions for processing loan applications, for example, may have the machine learning tools to sift through documents quickly but lack the viewing and editing features that would allow users to collaborate securely and effectively.

White labeling is a process where one company purchases a product from another company and then rebrands it for their own use. For physical products, this usually means repackaging and reselling something, but with digital products, the rebranding typically involves customizing the user experience (UI) to incorporate it into an existing application. 

In the previous example, the FinTech developer might turn to a product like PrizmDoc Viewer to integrate secure viewing capabilities into their platform. Using PrizmDoc Viewer’s white label software features, the company could rebrand the UI with its own logo and terminology. The average user, then, would never know that some aspects of their FinTech solution incorporates products made by another software manufacturer.

4 Benefits of Using White Label Software

Companies of all sizes turn to white label solutions when building their applications. Here are some of the reasons why they they choose this option instead of building everything they need from scratch:

1. Rapid Deployment

One of the obvious advantages to adopting a white label software solution is the speed of deployment. Building new features within an application takes both time and developer resources. If everything needs to be coded and deployed from scratch, production timelines can quickly extend indefinitely. As deadlines are pushed back, developers may even be pulled away from working on more innovative software features to build basic functionality into their applications. This vicious cycle makes it bring a product to market in time to capitalize on opportunities.

With easy-to-integrate white label software, companies can rapidly integrate the functionality they need into their applications and dedicate more resources to the novel features that will set them apart in a crowded marketplace. The ability to deploy core capabilities quickly means that teams can get to a minimum viable product faster and bring their software to market. Since white labeling allows them to rebrand and customize their integration to match the rest of the application interface, end users still enjoy a seamless experience.

2. Proven Functionality

When production deadlines are tight, it usually doesn’t make sense to have developers spending their time building a solution that already exists as a ready-made integration. Although open-source tools can be quite attractive, they don’t always provide the robust features expected of modern applications. In many cases, development teams have to spend valuable time building upon open-source solutions just to get them to work properly within an application framework.

White label software provides proven functionality right out of the box, allowing developers to quickly integrate the features they need and get back to working on other priorities. They also offer a more specialized approach to application needs. Rather than trying to build something new or adapt a similar solution, developers can select the exact features they need, implement them, and know that they’ll work as promised. Since they’re supported products, white label software also provides more peace of mind when it comes to updates and patching vulnerabilities. 

3. Budget Friendly

Developing new software features is an expensive undertaking. It requires companies to hire developers with the right expertise, dedicate hardware and processing capabilities, and multiple rounds of testing just to get to a viable state, but the costs don’t stop there. Once new functionality is built, it will require ongoing maintenance and support to ensure that it continues to work as intended and stays secure against potential threats. Those additional costs can quickly become burdensome for a software company that simply wants to incorporate common features into their application.

With white label software, companies can have all the benefits of third party support without compromising their user experience. White label API solutions integrate seamlessly into an application and the company can turn to the vendor for support when something goes wrong or when new features are needed. Eliminating ongoing maintenance from the budget means that teams can spend more of their resources on delivering a better overall product to their customers. 

4. Flexible Scalability

Software applications often change significantly throughout their lifecycle. What begins as a small program with only a few features can scale very quickly into an enterprise-grade workhorse that must meet the needs of multiple departments. Having a solution in place that can grow and change along with business needs is vital for organizations looking to retain their flexibility.

Customizable white label software makes it easy for companies to grow their applications along with their business. They can begin with a modest feature set and then implement additional tools as needed as user needs change over time. This versatility also frees up developers to build innovative solutions that may require features that are not being used in an existing application, but could easily be enabled when the time comes. Having flexible, scalable white-label technology built into a platform early on opens up a wide range of possibilities for future development.

The Behind-the-Scenes Ingredient to Your Application’s Success

As a software manufacturer specializing in API technologies for document processing, conversion, and automation, Accusoft has spent many years building solutions that work “under the hood” to enhance our customers’ applications. That’s why the PrizmDoc Suite of products incorporates white label software features to help them blend seamlessly into your existing platform. Whether you’re looking to add new capabilities or need to incorporate functionality quickly to get your products to market faster, our flexible integrations can help solve your document management challenges on your terms. Talk to our team today to find out which solution is right for you.