How We Test Our Tools
Every tool on ToolsKit is tested with real files, in real browsers, before we call it ready.
Why testing matters for browser tools
Browser-based tools face a unique testing challenge. Unlike desktop software that runs in a controlled environment, our tools must work across dozens of browser versions, operating systems, screen sizes, and hardware configurations. A PDF merge that works perfectly in Chrome on a MacBook might fail with a specific file type in Firefox on Windows. A word counter that handles English text correctly might produce unexpected results with multilingual content. Thorough testing across these variables is the only way to catch these issues before users encounter them.
We also test with real user scenarios, not just synthetic test cases. Compressing a 5-page text document is different from compressing a 50-page scanned PDF. Merging two small files is different from merging twenty large ones. Our testing reflects how people actually use these tools.
Our testing process
Before a tool ships, it is tested manually in the browser. There is no automated test suite behind these tools — testing is done by hand, by the person who built the tool, using real files. The steps below describe what that looks like in practice:
1. Input validation testing
We test what happens when the tool receives unexpected input. What if someone uploads a corrupted PDF? What if they try to merge a 0-byte file? What if they paste an empty string into the word counter? What if they upload a file that is 500MB? Every tool needs to handle edge cases gracefully — show a clear error message, never crash, and never silently produce wrong results. We create a test matrix of invalid inputs for each tool and verify that every one is handled correctly.
Input validation also covers boundary conditions. We test with files at the minimum and maximum expected sizes, files with unusual character encodings, files with non-standard metadata, and files that push the limits of what the browser's APIs can handle. The goal is to ensure that no matter what a user uploads, the tool responds gracefully — either processing the file correctly or displaying a clear, helpful error message.
2. Cross-browser testing
Tools are tested primarily in Chromium-based browsers (Chrome, Edge, Brave) and in Firefox. Safari (WebKit) testing is done on a best-effort basis when a device is available, and results vary — some features rely on browser APIs that behave differently in WebKit. We do not maintain a formal browser support matrix or test a fixed set of minimum versions; the goal is that the tool works in current versions of the major browsers.
- The tool loads and initializes correctly
- File upload and drag-and-drop work
- The tool processes files without errors
- The output matches expected results
- Downloading output files works correctly
- The interface is usable at different viewport sizes
3. File compatibility testing
PDFs are notoriously inconsistent. Different PDF generators produce different file structures, and our tools need to handle them all. We test with:
- PDFs generated by Adobe Acrobat, LibreOffice, Google Docs, Microsoft Word, and web browsers
- PDFs with various encryption levels (unencrypted, password-protected, permissions-restricted)
- PDFs containing different content types (text-only, image-heavy, mixed, forms, annotations, bookmarks, embedded fonts)
- PDFs at extreme sizes (small invoices to large technical manuals)
- PDFs with non-standard metadata or unusual structure
For resume tools, we test with resumes formatted in Word, Google Docs, plain text, and PDF. We test with various resume formats (chronological, functional, combination) and content structures (single-column, multi-column, with and without tables).
4. Performance testing
Since all processing happens in the browser, performance depends on the user's device. Testing is done on whatever machines are available — typically a modern laptop and a phone — rather than a fixed device lab. We check:
- Processing time for typical files (small, medium, and large)
- Whether the browser stays responsive during processing
- That progress indicators, where present, actually reflect processing status
We do not maintain a formal device matrix (high-end desktop, budget Chromebook, and so on). If a tool feels slow on a mid-range device during manual testing, that is investigated before launch.
5. Security testing
Because our tools handle user files in the browser, security testing focuses on ensuring that no data leaks through unintended channels. We verify:
- No file data is transmitted to any server during processing (verified via network traffic inspection)
- No file data is stored in browser storage beyond the current session
- No file data is exposed through error messages, console logs, or debug output
- Third-party scripts loaded on the page cannot access file data
- Content Security Policy headers are checked when a header is actually configured — this site runs on static hosting, so we do not claim a CSP is enforced everywhere
We also verify that download mechanisms work correctly — that output files are generated as proper Blobs and downloaded via object URLs, without exposing file contents to the page's JavaScript context unnecessarily. While our threat model is limited (the tools run in your browser, not on a server), we take reasonable precautions to ensure file data stays private.
6. Accessibility testing
Tools are built with keyboard navigation and semantic HTML in mind, and interactive elements are checked for visible focus indicators and sensible tab order. Color contrast is checked against WCAG AA where practical. We do not run a formal accessibility audit with automated tooling or a standing screen-reader test process on every change — testing with real assistive technology (NVDA, VoiceOver) is done on a best-effort basis, not as a release gate.
7. Privacy verification
Since the core claim is client-side processing, that claim is verified by hand before launch: we open the browser's developer tools, run the tool on a real file, and watch the Network tab to confirm no file data is transmitted. We also check that no file data persists in browser storage after the session ends.
This verification is repeated when a tool's dependencies change or a new feature is added, since a new dependency could introduce an unexpected network request. It is a manual check, not an automated one.
8. Output verification
The final step is checking that the output is correct and usable. For PDF tools, we open the output file in a PDF reader and confirm:
- The file opens without errors
- Content from the source files is preserved
- Formatting (fonts, layout, images) is maintained
- File size changed in the direction we expect (for compression tools)
For resume and text tools, we compare the output against what we expect from the input, manually. There is no automated test suite or reference implementation behind these checks.
Ongoing testing
Once a tool is live, testing is reactive rather than scheduled:
- Browser updates: We do not have a formal re-test calendar tied to browser release cycles. When a user reports that a tool broke after a browser update, that report is investigated and the fix is verified.
- User reports: Bug reports that come through the contact form are read and, when reproducible, fixed. There is no automated regression suite to add cases to — the fix is verified by reproducing the original scenario by hand.
- Tool updates: Before a tool update goes live, the specific change is tested manually. We do not run a full regression pass across every tool on every deploy.
- Performance monitoring: We do not run server-side performance monitoring, since the tools run in the browser and there is no backend to monitor. Performance is assessed by using the tools.
What we do not test
Transparency requires acknowledging limitations. We do not:
- Test with malware-infected files
- Test with files that violate intellectual property laws
- Guarantee compatibility with every obscure PDF variant (we focus on the most common generators and structures)
- Test with browser extensions that modify page behavior (these can interfere with tool functionality)
We document known limitations on each tool's page so you can make informed decisions about whether the tool fits your specific use case. If you encounter a file type or scenario that we do not support, we want to hear about it — it helps us prioritize what to work on next.
How to report a bug
If you encounter a problem with any tool, please report it through our contact page. Include your browser name and version, operating system, what you were doing, and what you expected to happen versus what actually happened. We read every message and fix confirmed issues when we can get to them.