Recommended Free Tools
Short answer: first decide where Chromium will run. A dedicated AWS Lambda function and an AWS Amplify Hosting SSR application are different execution targets with different packaging rules. The chrome-aws-lambda README shows a Lambda-oriented launch pattern, but its 10.1 line maps to Chromium 92.0.4512.0, while current Amplify SSR documentation lists Node.js 20, 22, and 24. The available documentation does not prove that this old package/browser combination works in today’s Amplify SSR runtime. Treat the setup below as a compatibility investigation, validate it on your exact deployment, and do not assume a Lambda layer recipe can be copied into Amplify SSR.
Choose the execution target before installing anything
“On AWS Amplify” can mean either of these architectures:
| Target | What runs | Packaging contract | Limits and cautions |
|---|---|---|---|
| Separate AWS Lambda function | A Lambda handler launches Chromium and is called by your Amplify application or another service. | Deploy a ZIP containing the handler and dependencies, or attach a Lambda layer. Keep the Chromium binary and native libraries in that deployment. | The package documentation recommends at least 512 MB Lambda memory and 1,600 MB or more. Confirm timeout, architecture, permissions, extraction path and deployment size for your chosen runtime. |
| Amplify Hosting SSR compute | Request-time server code in an Amplify-hosted SSR application. | The framework adapter must emit a self-contained Node.js HTTP-server bundle. The entry point must start a server on port 3000. | Amplify documents Node.js 20, 22 and 24 for SSR. Each compute resource has 512 MB ephemeral storage, a 15-minute maximum execution time and a 220 MB uncompressed bundle limit. These are not Lambda memory figures. |
If browser work is lengthy, bursty or independent of page requests, a separate Lambda is usually easier to isolate. If it is a small part of an SSR request, it may belong in the SSR bundle—but only after you verify that the binary, libraries and bundle size fit Amplify’s compute contract.
What chrome-aws-lambda actually documents
The project README instructs you to install chrome-aws-lambda together with a matching puppeteer-core or puppeteer release. Its launch example uses the package’s arguments, viewport, executable path and headless setting:
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →#1 Best Overall
const chromium = require('chrome-aws-lambda');
exports.handler = async (event) => {
let browser;
try {
browser = await chromium.puppeteer.launch({
args: chromium.args,
defaultViewport: chromium.defaultViewport,
executablePath: await chromium.executablePath,
headless: chromium.headless,
});
const page = await browser.newPage();
await page.goto(event.url || 'https://example.com');
return await page.title();
} finally {
if (browser) await browser.close();
}
};This is the package’s Lambda example, not a verified Amplify deployment recipe. The finally block matters: without it, failed navigations can leave Chromium processes behind and exhaust a warm execution environment.
Version pairing is not optional
The README’s version table lists the 10.1 line with Chromium 92.0.4512.0. Amplify’s current SSR support is documented for Node.js 20, 22 and 24, and Amplify blocks SSR deployments using Node.js 14, 16 or 18 effective September 15, 2025. No cited source verifies chrome-aws-lambda 10.1 with those current runtimes. Before deployment, identify the exact package release, bundled browser revision, Puppeteer major version and Node.js major version, then test that set on the real target.
Deploying the pattern as a separate Lambda
1. Create a minimal project
Install the package and the matching Puppeteer release specified by its README. Do not mix an arbitrary Puppeteer version with the bundled Chromium revision. Keep your handler and package.json in a clean deployment directory.
2. Package dependencies for Lambda
Lambda accepts a ZIP containing your function and its dependencies, or a Lambda layer. Include the browser package, Puppeteer dependency and all transitive modules in the ZIP or layer actually attached to the function. A layer guide written for Lambda does not automatically apply to Amplify SSR.
Free tools Windows power users keep installed
One-click scans. No signup required.
3. Configure runtime resources
- Select a Node.js runtime that your chosen package and Puppeteer release support; verify it rather than inferring compatibility from Amplify’s list.
- Set memory based on the package guidance: at least 512 MB, with 1,600 MB or more recommended by the project documentation.
- Set a timeout long enough for cold start, browser launch and navigation, while keeping your application’s latency budget in mind.
- Confirm CPU architecture and that the packaged Chromium binary matches it.
- Ensure the process can execute the extracted binary and write to the temporary directory used by the package.
4. Make navigation bounded and observable
Pass a URL only from a trusted or validated source, set a navigation timeout appropriate to your workload, and return structured errors rather than exposing stack traces. Always close the browser in finally. Log the runtime, package versions, URL host, elapsed time and failure category so a cold-start problem can be distinguished from a target-site timeout.
Using Puppeteer inside Amplify SSR compute
Amplify Hosting supports SSR applications when the framework adapter emits the expected output structure. Amplify’s deployment specification requires a self-contained Node.js HTTP server listening on port 3000. That requirement is materially different from a Lambda handler export.
Build and runtime versions
Amplify lets you select the Node.js version used during the build. Its AL2023 build image documentation lists Node.js 20, 22 and 24, with 22 described as the default in that guide. For a Next.js compute application, Amplify says the deployed Node.js major version matches the major version used to build the app. Keep the build version and deployed version intentionally aligned, but remember that alignment does not prove a native Chromium binary is compatible.
Bundle and storage checks
- The compute bundle must be self-contained and no larger than 220 MB uncompressed.
- Each compute resource has 512 MB of ephemeral storage.
- Execution is limited to 15 minutes.
- The process must listen on port 3000 through the generated server entry point.
Chromium plus native libraries can consume significant space. Measure the uncompressed artifact produced by your adapter; do not compare that number with Lambda’s memory recommendation. They are different resources.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #3
A safe SSR validation sequence
- Create a separate branch for the experiment. Amplify recommends testing Node.js upgrades on a new branch.
- Pin the build Node.js major version in your package/build configuration.
- Build the framework adapter and inspect the generated compute directory. Verify that Chromium, Puppeteer and required native libraries are inside the self-contained output.
- Check the uncompressed size against 220 MB and confirm writable temporary storage behavior.
- Deploy the branch and exercise a route that launches and closes Chromium. Capture logs for launch, navigation and cleanup.
- Only then put browser work on a production request path; otherwise move it to a separate Lambda.
Common failures and fixes
“Executable doesn’t exist” or launch rejects the path
The binary may have been omitted from the artifact, extracted to a different temporary path, or built for another architecture. Inspect the deployed files, print the resolved await chromium.executablePath, and verify ZIP/layer contents. For SSR, confirm the adapter copied the binary into the self-contained compute bundle.
“Browser was not found” after installing Puppeteer
puppeteer-core does not download a browser. The chrome-aws-lambda package supplies its own Chromium path, so use the package’s launch properties and a matching Puppeteer version. Do not silently fall back to a locally installed browser that is absent in production.
Works locally, fails in Amplify
Local Chrome, libraries and filesystem permissions differ from Amplify. Reproduce with the same Node.js major version, production build output and deployment architecture. A successful local run is not compatibility evidence for Amplify SSR.
Bundle exceeds 220 MB
Measure uncompressed output, remove development dependencies and confirm that only one browser distribution is present. If the result still cannot fit, move browser automation to Lambda or another separately packaged worker rather than forcing it into SSR.
Timeouts, blank pages or stuck invocations
Set explicit navigation and overall timeouts, avoid launching multiple browsers per request, and close every browser. Check target-site bot checks, DNS/TLS failures and cold-start duration. Do not increase limits beyond the target’s documented maximum; Amplify SSR has a 15-minute execution ceiling.
Memory and storage confusion
The package’s “at least 512 MB” and “1,600 MB or more” statements describe Lambda memory guidance. Amplify’s 512 MB figure is ephemeral storage. Increasing one does not increase the other.
Performance, reliability and architecture decisions
- Cold starts: Chromium startup and binary extraction add latency. Reuse a browser only when you can control lifecycle and cleanup; otherwise launch per invocation and budget for the cost.
- Concurrency: Multiple pages or browsers multiply memory and temporary-file usage. Bound concurrency and queue work when screenshots are not user-request critical.
- Request paths: A slow third-party page can consume an SSR request slot. Prefer asynchronous Lambda work for reports, crawls or bulk captures.
- Releases: Pin package versions and test every Node.js or framework upgrade on the deployment target. The old Chromium 92 mapping should be treated as a compatibility risk, not a promise of current support.
- Security: Validate user-supplied URLs, restrict internal addresses if your service accepts arbitrary input, and avoid logging cookies, authorization headers or page contents.
Or skip the browser setup
ScreenshotNeo provides a website screenshot API and MCP server when you want a capture without packaging Chromium yourself. One GET request returns PNG, JPEG, WebP or PDF. Before capture it accepts cookie/consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets; each step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers report the page verdict and billing status. Its MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients.
See the ScreenshotNeo documentation for all options and authentication.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);The free plan includes 1,000 screenshots a month with no card. Paid plans start at $5 for 3,000 shots, and every feature is on every plan. Create a free ScreenshotNeo account to try it.
Best Value
Frequently Asked Questions
Is chrome-aws-lambda officially supported by Amplify SSR?
The cited documentation does not establish that. The package documents a Lambda-oriented Chromium bundle, while Amplify SSR has its own Node.js compute and packaging contract; validate the exact versions and artifact on your deployment.
Can I attach a Lambda layer to an Amplify SSR application?
No assumption is safe. Lambda layers are a Lambda packaging feature; Amplify SSR requires a self-contained compute bundle produced by the framework adapter.
Which Node.js version should I choose?
Amplify SSR currently lists Node.js 20, 22 and 24. Choose one your Puppeteer and Chromium combination supports, pin the build version, and test the deployed result.
The Bottom Line
Use the documented chrome-aws-lambda launch pattern as a Lambda experiment, not as proof of Amplify SSR compatibility. Separate the execution targets, match browser and Puppeteer versions, package for the correct contract, and validate size, storage, memory and time limits on the actual deployment.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
