Docgen & Signing Flow — Technical Architecture & Reference

A signer receives an email containing a signing link. Signer clicks the link, which routes through a Salesforce Site to PDFESigningScreen.page. The page decodes the link parameter and loads documentSigningScreen LWC. The LWC orchestrates the signing workflow: OTP verification (if enabled), form field population, document display in iframe (via PDFSigningScreen.page or AutoPopulatedSigningScreen.page or AutoPopulatedSigningScreenWord.page), field validation, signature capture, and final PKCS7 digital signing. On success, the LWC displays status confirmation and optionally downloads the signing certificate. The signing flow is the final user-facing layer that bridges OTP → Document Viewing → Signing → Workflow Completion.

Five Visualforce pages orchestrate signing:

Architecture.

┌──────────────────────────────────────────────────┐
│   Signer clicks email link                       │
│   (Document_Workflow_Item__c.Signer_URL_New__c) │
└────────────────────┬─────────────────────────────┘
                     │
          Via Salesforce Site
                     │
                     ▼
        ┌────────────────────────┐
        │ PDFESigningScreen.page │
        │  (public VF wrapper)   │
        │                        │
        │ Parse URL params:      │
        │ ?sign=encoded_link     │
        └────────────┬───────────┘
                     │
        Load documentSigningScreen LWC
        (into #LightningComponent div)
                     │
        ┌────────────▼───────────────┐
        │ documentSigningScreen LWC  │
        │  (orchestrator)            │
        │                            │
        │ • Decode urlParam          │
        │ • Check OTP requirements   │
        │ • Query workflow state     │
        │ • Verify signer status     │
        └────────────┬───────────────┘
                     │
        ┌────────────▼───────────────┐
        │  OTP Verification?         │
        └────────┬──────────┬────────┘
                 │ (yes)    │ (no)
                 ▼          ▼
           c-document-  Load Signing
           signing-o-t-p-  Page Iframe
           screen          │
                 │          │
        User enters OTP     ▼
                 │     ┌─────────────────────┐
                 │     │ PDFSigningScreen.page│
                 │     │ OR                   │
                 │     │ AutoPopulated...page │
                 │     │                      │
                 │     │ Nutrient Web SDK     │
                 │     │ renders PDF          │
                 │     │ + form fields        │
                 │     │                      │
                 │     │ User fills/signs     │
                 │     │ invokeSignatureService│
                 │     │ → PKCS7 hash         │
                 │     │ → ContentVersion     │
                 │     │ → Status update      │
                 │     └─────────┬────────────┘
                 │               │
                 └───────┬───────┘
                         │
         documentSigningScreen receives
            signing result from iframe
                     │
        ┌────────────▼───────────────┐
        │  Show Status Screen        │
        │  • Success / Declined      │
        │  • Error / Verification    │
        │  • Certificate download    │
        │  • Redirect (if configured)│
        └────────────────────────────┘

Signing starts via a public link (unauthenticated Salesforce Site). PDFESigningScreen.page acts as a router: it parses the URL-encoded signing link parameter, then loads documentSigningScreen LWC into a Lightning container. The LWC decodes the link, queries the Document_Workflow__c and Document_Workflow_Item__c to verify signer status, check OTP requirements, and determine the signing method (PDF vs Word, auto-populated vs manual). Based on configuration, the LWC either:

1. Shows OTP verification screen (c-document-signing-o-t-p-screen child component)

2. Directly loads a VF page (PDFSigningScreen or AutoPopulatedSigningScreen) in an iframe

After OTP (if required), the iframe loads PDFSigningScreen.page (or variant), which calls its Apex controller to fetch field config and PDF blob. The user fills form fields and signs. The VF page calls invokeSignatureService(), which PKCS7-signs server-side, then posts the result back to the LWC via postMessage. The LWC receives the signing result and displays the final status screen (success, declined, error, etc.). This architecture allows guest link sharing (unauthenticated) + OTP gating + flexible signing methods (PDF/Word, auto-populated/manual) + certificate management.

public with sharing (Salesforce Site accessible). Entry point for all signing links. No Apex controller. Uses Lightning Out to load LWC components.

Query Parameter Routing:

Orchestrator component. Receives @api urlParam (URL-encoded signing link). Handles OTP verification, document status checking, iframe routing, and final status display.

Tracked state

Key functions

Child Components

Controller: SigningScreenController. Hosts Nutrient Web SDK iframe for PDF signing. Loaded inside documentSigningScreen LWC iframe.

Key VF Properties:

Controller: AutoPopulatedSigningScreenController. Alternative signing page where form fields are auto-populated from template mappings and workflow configuration. User signs without manually filling fields.

Controller: AutoPopulatedSigningScreenController (same). Used for Word document (.docx) signing instead of PDF. Processes Word field merges before signing.

public with sharing. Backs PDFSigningScreen and AutoPopulatedSigningScreen VF pages. Handles signing workflow invocation.

Helper class for signing operations.

Web service integration classes. Handle e-signature service callouts (DocuSign, Adobe Sign, or eOriginal vaulting).

1. Signer receives email with Document_Workflow_Item__c.Signer_URL_New__c link.

2. Signer clicks link. Redirects via Salesforce Site (public).

3. Salesforce Site routes to PDFESigningScreen.page with ?sign=URLEncodedLink param.

4. PDFESigningScreen.page loads documentSigningScreen LWC via Lightning Out.

5. documentSigningScreen LWC connectedCallback() executes.

6. Calls UtilityClass.encodeDecodeURLString(urlParam, 'decode') → decodes link.

7. Queries Document_Workflow_Item__c by decoded link.

8. Queries linked Document_Workflow__c.

9. Calls SigningScreenController.checkifUserAlreadySigned() → if already signed, sets alreadySigned=true, shows status screen. Return.

10. Calls SigningScreenController.getWorkflowStatus() → checks expiry, status, etc. If expired, shows expiry screen. Return.

11. Calls SigningScreenController.getOtpFailCount() → retrieves OTP attempt count.

12. Queries Document_Template__c to check OTP requirement (Enable_OTP_On_Signing__c, OTP_Methods__c).

13. If OTP required: calls SigningScreenController.getTemplateConfigs() → retrieves OTP methods. Populates otpMethods array. Sets showOTPScreen=true.

14. Renders c-document-signing-o-t-p-screen child component.

15. Signer enters OTP. c-document-signing-o-t-p-screen calls UtilityClass.verifyOTP() (server-side). On success: fires userVerified event. On fail: fires verificationFailed event + increments OTP attempt counter.

16. documentSigningScreen LWC receives userVerified event.

17. Sets showOTPScreen=false, documentGenerated=true.

18. Calls loadSigningFrame().

19. Determines signing page: if PDF → PDFSigningScreen.page. If Word → AutoPopulatedSigningScreenWord.page. If auto-populate → AutoPopulatedSigningScreen.page. (Check Document_Template__c.Is_Document_PDF__c and Disable_Form_Field_Editing__c).

20. Constructs URL: /apex/PDFSigningScreen?workflowId={workflowId} (or similar).

21. Sets generatedDocumentURL. HTML renders <iframe src="{generatedDocumentURL}" />.

22. Iframe loads PDFSigningScreen.page.

23. PDFSigningScreen.page controller calls getTemplateData() getter.

24. Reads page param workflowId. Queries workflow + signer + template.

25. Calls DocumentGenerationService.getFormData() → returns dataMap, readOnlyFields, requiredFields, dateFields, picklistMap, base64String (PDF).

26. Sets VF properties.

27. VF page renders. JavaScript calls loadConfigurations() → builds Maps.

28. JavaScript calls loadPDF() → NutrientViewer.load(base64String, licensekey).

29. Nutrient renders PDF + form fields in container.

30. JavaScript calls configureFormFields() → sets read-only on readOnlyFields, applies date formatting, populates picklists.

31. Signer views PDF + form fields.

32. Signer fills fields + adds signature via Nutrient signature widget.

33. Signer clicks "Sign" button.

34. JavaScript calls signDocument().

35. validateMissingFields() → checks all requiredFields filled. If any null: applyFieldBorder() highlights red, blocks sign.

36. If all filled: signatureProcess().

37. Validates at least one signature field has ink/image/text.

38. Calls instance.exportPDF() → captures PDF with form values + user signatures.

39. Encodes PDF as base64.

40. Calls generatePKCS7() → prepares PKCS7 structure.

41. POSTs to callSigningMethod (apex:actionFunction) with base64 digest + workflowId.

42. SigningScreenController.invokeSignatureService(digest, workflowId) executes server-side.

43. Calls SigningService.signDocument(digest, workflowId).

44. SigningService generates PKCS7 hash using org certificate.

45. Creates ContentVersion with signed PDF.

46. Updates Document_Workflow__c status → Signature Completed.

47. Creates Document_Workflow_Item__c event (Document Signed) with Digitally_Signed_Timestamp__c.

48. Checks if last signer. If yes: updates Document_Workflow__c status → Workflow Completed.

49. Returns { Success: true, signedHash (PKCS7 hex), signatureTimeStamps (JSON array) }.

50. JavaScript receives response via oncomplete callback of apex:actionFunction.

51. Calls window.parent.postMessage({ type: 'SigningResult', payload: { Success, signedHash, ... } }, vfOrigin).

52. documentSigningScreen LWC (in parent) receives postMessage.

53. Calls handleSigningResult(event).

54. If Success: calls saveDocument() (if needed). Calls SigningScreenController.recordSignerConsent() (if consent required).

55. Checks if bAutoDownloadCertificate. If yes: calls downloadSigningCertificate() → auto-downloads .pfx or .cer.

56. Sets statusConfig = { type: 'success', message: 'Document signed successfully!', icon: success_image, buttons: [Download, Close/Redirect] }.

57. Sets documentGenerated=true, showSpinner=false.

58. Renders c-status-screen child component (displays status).

59. Signer clicks Download Certificate (or auto-downloaded).

60. SigningScreenController.downloadSigningCertificate() returns blob.

61. Browser downloads certificate file.

62. Signer clicks Close or page auto-redirects (if bRedirectionRequired and redirectionUrl set).

63. Sends confirmation email to signer + next signer (if exists) or document owner.