craftmypdf.com

You can cut most images to a fraction of their original file size without any visible quality loss by doing three things in the right order: resize the image to the dimensions it will actually display at, pick the right format for the content, then apply compression at a quality level that survives a side-by-side check. The single biggest mistake is skipping step one — an oversized image compressed at maximum quality is still far heavier than a correctly sized one.

Why file size and quality are a trade-off, not a fixed setting

Every compressed image is a negotiation between three variables: how many pixels you keep, how precisely each pixel is described, and how much the format is allowed to guess.

• Dimensions decide how many pixels exist at all. Halving width and height removes 75% of the pixel data before any compression happens.
• Quality level decides how aggressively the encoder discards detail it thinks you won't notice.
• Format decides the kind of discarding allowed — some formats throw away color precision, others only remove redundancy.

Because these interact, "quality 80" means something different on a 4000px photo than on a 600px thumbnail. Tune dimensions first, then quality.

Pick the format before you touch the quality slider

Practical rule: photos → JPEG or lossy WEBP; flat graphics and transparency → PNG or lossless WEBP; anything vector → SVG.

The four levers, in the order you should pull them

1. Resize to display size (biggest win, zero quality cost)

If your layout renders an image at 800px wide, serving a 2400px original wastes roughly 89% of the pixels. Resize to the largest size it will ever be displayed at, and add a 2× version only if you need retina sharpness.

2. Choose the format

Match the format to the content type using the table above. Converting a photographic PNG to JPEG or WEBP alone can shrink it by 80% or more.

3. Set the quality level

For JPEG and lossy WEBP, most photographs hold up well between quality 70 and 85. Below ~60, banding appears in skies and blur around text. Above ~90, file size climbs steeply for gains nobody can see.

4. Strip metadata

EXIF data, camera info, and embedded thumbnails can add tens of kilobytes. Remove them unless you specifically need copyright or orientation data — and note that stripping orientation can rotate an image, so verify after export.

When lossy compression is fine, and when it isn't

Lossy is acceptable when:

• The image is a photograph or has natural texture.
• It's decorative or below the fold.
• Slight softening won't be noticed at final display size.

Use lossless or vector instead when:

• The image contains text, UI elements, or thin lines (lossy creates ringing artifacts).
• It's a logo, icon, or diagram — SVG or PNG keeps edges clean.
• It will be edited again later; repeated lossy saves compound degradation.
• It's a screenshot of code or a chart where color accuracy matters.

Compressing vs. resizing: don't confuse them

Compressing reduces the bytes needed to describe the same pixels. Resizing reduces the number of pixels. They're independent, and resizing usually delivers the larger saving. A 3000×2000 photo at quality 95 might be 2 MB; the same photo resized to 1200×800 at quality 80 might be 180 KB. Doing only the quality reduction gets you maybe 40% off; doing both gets you over 90%.

A repeatable workflow

1. Determine the maximum display width in your layout (inspect the element or check your CSS).
2. Export at that width (plus a 2× variant if needed).
3. Convert to the right format — WEBP as a modern default, JPEG as a fallback, PNG/SVG for graphics.
4. Apply quality 75–85 for lossy formats and compare against the original.
5. Strip metadata and re-check orientation.
6. Verify before publishing (see below).
7. Serve the right file with srcset so small screens don't download the large variant.

How to verify quality before you publish

• View at 100% at final display size, not zoomed in — artifacts you can't see at real size don't matter.
• Toggle between original and compressed in a viewer or an online compressor's before/after preview.
• Check the worst-case areas: skies, smooth gradients, sharp edges, and any text.
• Compare file sizes and ask whether the extra kilobytes buy visible improvement. If not, go smaller.
• Test on a mid-range phone, where banding and blur are often more obvious than on a desktop monitor.

Common mistakes

• Compressing a full-resolution image and calling it optimized.
• Using PNG for photographs.
• Setting quality to 100 "to be safe" — it inflates size with no visible benefit.
• Re-saving a JPEG repeatedly, stacking artifacts each time.
• Forgetting that GIF animations are usually better as WEBP or video.
• Ignoring metadata, which can silently add weight.

Quick reference

The order matters more than any single setting: resize, then choose format, then tune quality, then strip metadata, then verify at real display size. Follow that sequence and you'll routinely land at 10–20% of the original file size with no quality your visitors can detect.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

CraftMyPDF has a free plan and does not require a credit card to start, so you can build a template and test the generation workflow before paying anything. For actual plan prices and usage limits, the site points to its own Pricing page — those numbers are not published in the material available here, so treat the pricing page as the only authoritative source. The free entry point is best suited to evaluating whether the template editor, integrations, and output quality fit your workflow; it is not a statement about how far a free tier will stretch in production.

What the free entry actually gets you

The site's own call to action is "Start Free" with the note "No Credit-card Required!" and a "Free plan" is listed alongside the automation features. That tells you two things you can rely on:

• You can create an account and begin without entering payment details.
• You can run through the core three-step workflow — design a template, send data, receive a PDF — before committing to a paid tier.

What it does not tell you is the volume ceiling, watermark policy, or feature gating on the free tier. Those are exactly the details that decide whether "free" is enough for a real workload, so check them on the Pricing page rather than assuming.

The three-step workflow you are evaluating

The free trial is really a test of this loop:

1. Design template — drag text, images, tables, QR codes, barcodes, shapes, and charts into the visual editor.
2. Send data — POST JSON to the API, or push data through an integration such as Zapier, Make, n8n, or Bubble.
3. PDF is ready — the generated document matches the template layout, produced in seconds.

A sample request looks like this:

POST /v1/create-pdf
{
  "template_id": "1ae3d73fb42ce",
  "data": {
    "name": "Dylan Louise",
    "order_id": 3487,
    "ship_date": "2026-08-19",
    "items": [ ... ]
  }
}

The practical test during a free trial: build one template that resembles your real document (an invoice, packing list, certificate, or label), send a realistic payload including a list or table, and confirm the output is something you would actually send to a customer. If the free tier lets you complete that once, you have validated the workflow; the remaining question is volume and price.

What to check on the Pricing page before you commit

Because plan prices and quotas are not in the source material, evaluate them against your own usage profile. The dimensions that matter:

A sensible decision path

• If you are still evaluating: start free, no card needed. Build one template that mirrors your real document and generate it once end to end.
• If the trial output is good and volume is low: the free plan may be sufficient — but confirm the cap first.
• If you generate recurring business documents at volume, or need a specific integration or regional endpoint: go to the Pricing page, match the tiers against your monthly generation count and required integrations, and only then decide.
• If data residency or compliance is a hard requirement: verify that the region you need (US, EU, Singapore, Australia) is included in the tier you are considering, since endpoint availability can differ by plan.

The one thing you cannot skip is the Pricing page itself. Everything above tells you what to test and what to compare; the actual cost depends on the tier you pick and the volume you run.

A PDF invoice in legal billing is a fixed-format document that presents the fees and costs owed on a matter in a layout that looks the same on every device. It is the digital equivalent of a printed bill: readable, portable, and easy to attach to an email or upload to a client portal. Its main limitation is that it is not machine-readable in the way a LEDES file is, so a client's e-billing system cannot automatically ingest it. PDF works best for flat-fee matters, small or one-off engagements, and clients who do not run an automated billing platform.

What "PDF" means in a legal billing context

When a billing tool offers to send an invoice "in PDF," it is generating a rendered document rather than a structured data file. The distinction matters:

• PDF is a presentation format. A human reads it. Line items, totals, and matter details appear as text and tables on a page.
• LEDES (Legal Electronic Data Exchange Standard) is a structured, delimited text format. An e-billing system parses it, validates it against outside counsel guidelines, and routes it for review.
• Email delivery is a transport method, not a format. You can email a PDF, email a LEDES file, or email a link to an online invoice.

These three are often confused because a single invoice can combine them: a LEDES file delivered by email, or a PDF attached to an email. The format is what the client's systems can read; the delivery method is how it arrives.

When a PDF invoice is the right choice

PDF is usually appropriate when the client does not require electronic submission through a billing platform. Common scenarios:

• Flat-fee and fixed-price matters. When the invoice is one or two lines, a structured file adds no value.
• Small businesses and individuals. Clients without an accounts payable system can open a PDF and pay from it.
• Retainers and replenishment requests. A simple statement of the retainer balance is easy to read as a PDF.
• Pro bono or courtesy bills. Where no formal e-billing review applies.
• Backup documentation. Even when a LEDES file is submitted, a PDF is often attached for the reviewer's convenience.

If the client has outside counsel guidelines requiring LEDES submission, a PDF alone will typically be rejected or returned for manual entry. Check the client's billing requirements before choosing the format.

PDF versus LEDES versus emailed invoice: a quick comparison

Core elements of a compliant legal PDF invoice

A PDF invoice should stand on its own. If a client's AP department picks it up with no context, it should still answer who, what, when, and how much.

Firm and client identification

• Firm name, address, and contact details
• Tax or VAT identification number where applicable
• Client name and billing contact
• Invoice number and invoice date
• Client matter number or reference

Matter and timekeeper detail

• Matter name and description
• For each timekeeper: name, initials, and billing rate
• Time entries with date, narrative description, and time recorded in tenths of an hour
• Clear separation of fee earners if rates differ

Fees, expenses, and totals

• Fees subtotal
• Disbursements and expenses, itemized with dates
• Taxes applied
• Prior payments, credits, or trust retainer applied
• Total amount due and currency

Payment terms

• Due date and payment window
• Accepted payment methods
• Remittance details or a payment link
• Late-payment terms if the engagement letter specifies them

A useful test: hand the PDF to someone who has never seen the matter and ask them to confirm the amount due and the period covered. If they hesitate, the invoice is missing something.

Practical limitations to plan around

PDF invoices shift work to the recipient. Someone at the client has to read the document and key the data into their system, which introduces delay and transcription errors. PDFs also cannot be validated against billing guidelines automatically, so a reviewer may reject a line item that a LEDES rule would have caught before submission.

Two habits reduce the friction:

1. Send a consistent template. Clients learn where to find the total, the matter number, and the payment terms.
2. Keep a LEDES version in reserve. If a client later adopts an e-billing platform, you can convert rather than rebuild.

Choosing between PDF, LEDES, and email delivery

Work from the client's requirements backward:

• Does the client mandate LEDES submission? If yes, PDF is a supplement, not a substitute.
• Is the matter flat-fee or very small? PDF is usually sufficient.
• Does the client have no billing system? PDF delivered by email or portal is the simplest path.
• Is the invoice complex with many timekeepers and expenses? A structured format reduces disputes, even if the client accepts PDF.

When in doubt, ask the client's billing contact which format they prefer and whether a PDF attachment is acceptable alongside any required file. That one question prevents most rejected invoices.

Easy Legal Billing supports sending or scheduling invoices in LEDES, email, or PDF formats, which lets you match the format to each client's requirements rather than forcing one approach across every matter.

CraftMyPDF states that it is SOC 2 Type II audited and that it supports regional PDF generation and storage in the US, EU, Singapore, and Australia. Those two facts are the core of its security and compliance story for business use. If your main requirement is a documented audit plus control over where document data is processed and stored, CraftMyPDF is built to address that. If you need certifications or contractual guarantees beyond what the site states, you will have to confirm them directly, because the public page only names SOC 2 Type II and the regional endpoints.

What CraftMyPDF says about its security posture

The site highlights SOC 2 Type II as the trust signal for security and compliance. SOC 2 Type II is an audit report covering how a service organization manages customer data over a period of time, typically against the Trust Services Criteria (security, availability, confidentiality, and so on). For a buyer, the practical meaning is that an independent auditor has examined the controls, not just the marketing claims.

What the page does not state: the exact audit scope, the report date, which Trust Services Criteria were included, or whether the report is available under NDA. Those are the details a security review usually asks for, and they are not on the page, so treat them as items to request.

Regional endpoints and data residency

CraftMyPDF says you can generate and store PDFs closer to your users with regional endpoints, and lists four regions:

The stated purpose is to support data residency requirements. In practice, this matters when a customer, regulator, or internal policy requires that document data — names, order IDs, addresses, line items — stays within a given jurisdiction.

Two things to verify before relying on this:

• Whether the region applies to both generation and storage, or only one of them. The page groups them together, but confirm per-region behavior.
• Whether your automation tool (Zapier, Make, n8n, Bubble) introduces its own data routing outside your chosen region. The endpoint choice governs CraftMyPDF, not necessarily the tools calling it.

How the workflow handles your data

The documented flow is three steps, and it tells you what data actually moves:

1. Design template — you drag components (text, images, tables, QR codes, charts) into the editor. The template holds placeholders like {{ name }}.
2. Send data — you POST JSON to the API, or connect an automation tool. The example payload includes template_id and a data object with fields such as name, order_id, ship_date, and an items array.
3. PDF is ready — the finished document is generated, and the API returns a success response (the example shows 200 OK).

So the sensitive content is the JSON you send and the resulting PDF. That is the data whose location and handling the regional endpoints and SOC 2 audit are meant to cover.

Who this fits, and who should dig deeper

Reasonable fit if:

• You need an audited vendor signal (SOC 2 Type II) plus a choice of processing region.
• Your documents are standard business outputs — invoices, certificates, labels, reports, packing lists.
• You are comfortable with a no-code or API-driven workflow and can pick a region that matches your policy.

Dig deeper first if:

• You need certifications the page does not mention (for example, ISO 27001, HIPAA, GDPR-specific contractual terms). Only SOC 2 Type II and the four regions are stated.
• You require a signed DPA, subprocessor list, or the actual audit report — request these; they are not published on the page.
• Your compliance obligation depends on the automation platform's data path, not just CraftMyPDF's.

Practical checklist before you commit

• Confirm which region you will use and that it satisfies your residency rule.
• Ask for the SOC 2 Type II report and its scope and date.
• Check whether storage (not just generation) stays in your region.
• Map where your automation tool sends data, since it sits between your system and CraftMyPDF.
• Test with a non-sensitive template first to see the full data path end to end.

The page gives you two concrete, checkable claims — SOC 2 Type II and regional endpoints in the US, EU, Singapore, and Australia. Everything beyond that is a question for their team, not an assumption to build on.