Interested: No need of any application form filling, just an email with a resume.

[email protected] [email protected]

Role Overview

We are looking for a Software Engineer – Web Automation & Browser Extensions to own the development, maintenance, and evolution of our browser extension and the web automation systems that power it.

This role will focus on building reliable browser-based workflows, interacting with energetic websites, automating user actions, extracting and processing web data, and creating a secure and intuitive browser extension experience.

The ideal candidate has strong experience with JavaScript/TypeScript, Chrome Extensions, browser APIs, DOM manipulation, web automation frameworks, APIs, and modern web applications.

Key ResponsibilitiesBrowser Extension Development

- Design, develop, maintain, and improve our Chrome/Chromium-based browser extension.
- Develop extension components including:
- Content scripts
- Background scripts/service workers
- Extension popup and user interface
- Options/settings pages
- Browser storage
- Messaging between extension components
- Work with Chrome Extension APIs and Manifest V3.
- Inject and execute functionality safely within supported websites.
- Detect page state, URLs, DOM elements, and user interactions.
- Maintain compatibility as third-party websites and browser APIs change.
- Optimize extension performance, startup time, and memory usage.

Web Automation
- Build automation workflows that interact with websites on behalf of users.
- Automate browser activities such as:
- Navigation
- Clicking buttons and links
- Completing forms
- Selecting dropdowns
- Reading page content
- Extracting structured information
- Monitoring page state
- Triggering workflows based on page events
- Develop reliable automation for dynamic and JavaScript-heavy websites.
- Handle asynchronous page loading, modals, popups, iframes, pagination, and dynamically generated DOM elements.
- Implement retries, timeout handling, validation, and failure recovery.
- Ensure automation behaves safely when websites change or expected elements are unavailable.

DOM & Web Application Integration
- Analyze webpage structure and identify reliable selectors and interaction points.
- Build resilient DOM detection and manipulation logic.
- Work with:
- HTML
- CSS
- Python
- JavaScript
- DOM APIs
- MutationObserver
- Browser events
- Local/session storage
- Cookies where appropriate
- Design automation to minimize dependence on fragile CSS selectors.
- Diagnose changes in third-party websites that affect extension functionality.

API & Backend Integration
- Integrate the browser extension with backend services and external APIs.
- Design and consume REST APIs and, where applicable, WebSocket-based services.
- Implement authentication and authorization flows.
- Send browser-generated data securely to backend systems.
- Retrieve instructions, configuration, workflow information, or application data from backend services.
- Implement appropriate error handling, retries, rate-limit handling, and request validation.





Automation Architecture
- Design reusable automation components rather than website-specific one-off scripts.
- Create configurable workflow logic that can support multiple websites and use cases.
- Separate:
- Website detection
- Element identification
- Automation actions
- Business rules
- Data extraction
- Error handling
- Build systems that make new automation workflows easier to add and maintain.
- Maintain clean interfaces between the browser extension, automation engine, and backend services.

Reliability & Error Handling
- Develop mechanisms for detecting when an automation workflow succeeds, fails, or becomes blocked.
- Implement logging and diagnostics to understand extension and automation failures.
- Build graceful recovery mechanisms when:
- Elements cannot be found
- Pages load slowly
- Websites change
- Network requests fail
- Authentication expires
- User sessions change
- Prevent duplicate actions or unintended repeated automation.
- Ensure workflows can safely stop when unexpected conditions occur.

Testing
- Build automated tests for browser extension and automation functionality.
- Test extension behavior across supported Chrome/Chromium browser versions.
- Create regression tests for critical automated workflows.
- Use browser automation/testing technologies such as:
- Playwright
- Puppeteer
- Selenium
- Chrome DevTools Protocol
- Test workflows against dynamic web applications.
- Reproduce and resolve automation failures reported by users.

Security & Privacy
- Follow browser-extension security best practices.
- Minimize extension permissions and website access wherever possible.
- Protect authentication tokens, session information, user data, and API credentials.
- Prevent unsafe script injection and cross-site vulnerabilities.
- Follow secure data storage and transmission practices.
- Ensure automated actions occur only within authorized workflows and websites.
- Review third-party dependencies for security and maintainability.

Performance & Scalability
- Optimize extension performance and reduce unnecessary browser resource consumption.
- Avoid excessive DOM scanning, polling, or network requests.
- Design efficient event-driven page detection where appropriate.
- Improve automation execution speed without sacrificing reliability.
- Build extension functionality that remains maintainable as the number of supported workflows and websites grows.

Monitoring & Troubleshooting
- Implement useful logging, telemetry, and error reporting.
- Diagnose production issues involving:
- Browser behavior
- Extension lifecycle
- Website changes
- DOM changes
- API failures
- Automation failures




- Identify recurring failures and improve automation resilience.
- Work with product/support teams to investigate user-reported issues.

Required Technical Skills
- Strong proficiency in JavaScript and/or TypeScript.
- Strong understanding of modern web development.
- Experience building Chrome or Chromium browser extensions.
- Experience with Chrome Extension Manifest V3.
- Strong understanding of browser APIs.
- Experience with DOM traversal and manipulation.
- Experience working with asynchronous JavaScript.
- Experience integrating REST APIs.
- Understanding of HTTP, browser requests, cookies, sessions, authentication, and web security.
- Experience building automation against dynamic web applications.
- Strong debugging skills using Chrome DevTools.
- Experience with Git and modern software development workflows.

Preferred Technical Skills Experience with one or more of:
- Playwright
- Puppeteer
- Selenium
- Chrome DevTools Protocol
- React
- Node.js
- TypeScript
- WebSockets
- REST APIs
- OAuth
- JWT authentication
- CI/CD
- Automated testing frameworks
- AWS, Azure, or GCP
- Observability/error-monitoring platforms

Experience with browser extension architecture, including:
- Content scripts
- Background service workers
- chrome.runtime
- chrome.tabs
- chrome.storage
- chrome.scripting
- Extension messaging
- Host permissions
- Cross-origin requests
- Browser lifecycle management

Engineering Expectations The engineer should be able to take a workflow such as: Detect website → understand page state → identify required elements → perform actions → validate results → capture relevant information → communicate with backend → handle errors and convert it into a reliable, maintainable production workflow.

The engineer should think beyond simply making an automation work once. The objective is to build automation that remains reliable despite differences in page loading times, user sessions, UI state, browser versions, and reasonable changes to third-party websites.

Ideal Candidate The ideal candidate enjoys working at the intersection of:

Browser Extensions + Web Applications + Automation + APIs + Product Engineering

They are comfortable investigating unfamiliar websites, understanding how those applications behave, and building robust integrations without relying on brittle assumptions.

They should have strong ownership skills and be comfortable troubleshooting issues where the root cause could exist in the extension, browser environment, external website, network layer, or backend service.

Success in This Role

Success will be measured by:

- Reliability of automated workflows
- Browser extension stability
- Reduction in automation failures
- Ability to support website/UI changes quickly
- Speed of developing new automated workflows
- Quality and maintainability of extension code
- Extension performance
- Security and privacy of user interactions
- Quality of monitoring and production diagnostics
- Overall user experience of automated browser workflows

📌 Software Engineer – Web Automation & Browser Extensions (India)
🏢 o1jobaid
📍 India