thanks! that is helpful information.  what do you do to apply variable compression?  I've never heard of this done before.  

We use an SDK script within Workflow to generate the PDF and attach it to the document; the code evaluates average page size, sets the compression value, generates the PDF, then adds it back to the entry as an electronic file.

I have another process that does something similar and deletes the pages after the PDF is rendered so all that remains is the revised PDF.

The following is the code I wrote for the PDF generation, deleting the pages is easy to add if all you want is a PDF

        protected override void Execute()
        {
            // Set variables for image size, text size, document size, and average bytes per page
            long imageSize = 0;
            long textSize = 0;
            long bytesPerPage = 0;
            int compression = 0;

            // Get and lock source document
            DocumentInfo doc = (DocumentInfo)this.BoundEntryInfo;
            doc.Lock(LockType.Exclusive);

            // Try to generate and attach PDF
            try{
                // Retrieve page count
                int pageCount = doc.PageCount;

                // Read values of each page
                PageInfoReader pageReader = doc.GetPageInfos();
                foreach (PageInfo page in pageReader){
                    // Track cumulative page and text sizes
                    // to determine what level of compression to apply
                    imageSize += page.ImageDataSize;
                    textSize += page.TextDataSize;
                }

                // Get average bytes per page
                bytesPerPage = imageSize/pageCount;

                // Initialize compression variables
                int minSize = 62500;
                int midSize = 250000;
                int maxSize = 1000000;

                // Evaluate average page size
                if (bytesPerPage < minSize){
                    // default for low-quality images
                    compression = 90;
                }
                else {
                    // low-to-medium quality images
                    if (bytesPerPage < midSize){
                        compression = 75;
                    }
                    else {
                        // medium-to-high quality images
                        if (bytesPerPage < maxSize){
                            compression = 50;
                        }
                        // high-quality images
                        else {
                            compression = 25;
                        }
                    }
                }

                // Build a list of watermarks and add tag watermarks associated with the document
                List<WatermarkSpecification> watermarks = new List<WatermarkSpecification>();
                foreach(TagWatermark w in doc.GetTagWatermarks()){
                    watermarks.Add(new WatermarkSpecification(w.WatermarkText,w.WatermarkTextSize,w.WatermarkRotation,w.WatermarkPosition,String.Empty,0,String.Empty,0,w.WatermarkIntensity));
                }

                // Initialize document exporter
                DocumentExporter dExp = new DocumentExporter();

                // Configure document exporter settings
                dExp.CompressionQuality = compression;
                dExp.IncludeAnnotations = true;
                dExp.BlackoutRedactions = true;
                dExp.PageFormat = DocumentPageFormat.Jpeg;
                dExp.Watermarks = watermarks;

                // Set PDF export options to flatten annotations and include searchable text
                PdfExportOptions ExportOptions = PdfExportOptions.RenderAnnotationsAsImage | PdfExportOptions.IncludeText;

                // Initialize memory stream and export PDF
                MemoryStream ms = new MemoryStream();
                dExp.ExportPdf(doc, doc.AllPages, ExportOptions, ms);

                // Write PDF to document
                using(Stream eDocStream = doc.WriteEdoc("application/pdf",ms.ToArray().LongLength)){
                    eDocStream.Write(ms.ToArray(),0,ms.ToArray().Length);
                }

                // Update document extension and save changes
                doc.Extension = ".pdf";

                // Save changes
                doc.Save();
            }

            // Ensure tokens are always updated and document is always unlocked
            finally{
                // Confirm eDoc attached and get eDoc Size
                SetTokenValue("eDoc",doc.IsElectronicDocument);
                SetTokenValue("eDocSize",doc.ElecDocumentSize);
                SetTokenValue("imageSize",imageSize);
                SetTokenValue("textSize",textSize);
                SetTokenValue("Quality",compression);

                // Release document
                doc.Unlock();
                doc.Dispose();
            }
        }

The script outputs several token values, which I use to determine whether or not the process succeeds, and to track how much compression was applied.

Also note that the lower the compression number, the higher the compression; this is because it is the compression quality % value.

Jason,  I may be wanting to borrow that SDK Script...  but can't figure out how to get it to work.  This is my very first SDK script to use in conjunction with a Laserfiche workflow, it spits out a bunch of syntax errors, and not as easy as copy and paste into the SDK Script activity.  Any pointers for getting it to work?

EDIT: forgot to switch it from vb to cs...    but still have an error, thoughts?

Looks like you have some extra brackets based on the screenshot. If you're copying and pasting into something with existing code, only copy lines 3-104.