Design (LLD) Web Crawler  - Machine Coding

Design (LLD) Web Crawler - Machine Coding

A web crawler is a program that is used to scan websites and analyze their content. Here is a high-level design (LLD) for a web crawler:

  1. URL Queue: The web crawler maintains a queue of URLs to be processed. It begins with a seed URL and adds new URLs to the queue as it discovers them.

  2. HTTP Client: The web crawler uses an HTTP client to send requests to websites and receive responses. The HTTP client is responsible for handling the details of making the request, such as formatting the request and parsing the response.

  3. Parser: The web crawler includes a parser that is used to extract relevant information from the HTML or other content returned by the HTTP client. This might include extracting links to other pages, extracting text content, or extracting metadata such as page titles or descriptions.

  4. Data Store: The web crawler stores the extracted information in a data store, such as a database or file system. This allows the information to be queried or analyzed later.

  5. Scheduler: The web crawler includes a scheduler that determines when to send requests for each URL in the queue. The scheduler might implement a delay between requests to avoid overwhelming the server, or it might prioritize certain URLs for faster processing.

  6. User Interface: The web crawler may include a user interface that allows users to control the crawl process and view the results. This might include a graphical user interface or a command-line interface.

Design Patterns Involved

  1. Singleton Pattern:

    • Reason: Ensures that only one instance of the URL queue exists, preventing duplication and ensuring consistency.
  2. Factory Pattern:

    • Reason: To create instances of HTTP clients and parsers, allowing flexibility in switching between different implementations.
  3. Strategy Pattern:

    • Reason: To define a family of algorithms (parsing strategies) and make them interchangeable, allowing the parser to handle different types of content.
  4. Observer Pattern:

    • Reason: To notify interested components (e.g., user interface) when a new URL is processed or when results are available.
  5. Command Pattern:

    • Reason: To encapsulate requests as objects, allowing for logging, queuing, and parameterization.

Algorithms Involved

  1. Breadth-First Search (BFS):

    • Reason: To ensure a broad exploration of the web, starting from the seed URL and gradually expanding.
  2. Politeness Policy Algorithm:

    • Reason: To avoid overwhelming the web server by implementing delays between requests.


Code (Java)

URLQueue (Singleton Pattern)

import java.util.LinkedList;
import java.util.Queue;

public class URLQueue {
    private static URLQueue instance;
    private Queue<String> queue;

    private URLQueue() {
        queue = new LinkedList<>();

    public static synchronized URLQueue getInstance() {
        if (instance == null) {
            instance = new URLQueue();
        return instance;

    public synchronized void enqueue(String url) {
        if (!queue.contains(url)) {

    public synchronized String dequeue() {
        return queue.poll();

    public synchronized boolean isEmpty() {
        return queue.isEmpty();

HTTPClientFactory (Factory Pattern)

public abstract class HTTPClient {
    public abstract String sendRequest(String url);

public class SimpleHTTPClient extends HTTPClient {
    public String sendRequest(String url) {
        // Simulated HTTP request and response
        return "<html><head><title>Sample Page</title></head><body><a href=\"\">Link</a></body></html>";

public class HTTPClientFactory {
    public static HTTPClient createHTTPClient() {
        return new SimpleHTTPClient();

Parser (Strategy Pattern)

import java.util.List;

public interface ParserStrategy {
    List<String> parse(String content);

public class HTMLParserStrategy implements ParserStrategy {
    public List<String> parse(String content) {
        // Simulated HTML parsing
        List<String> urls = new ArrayList<>();
        if (content.contains("")) {
        return urls;

CrawlerObserver (Observer Pattern)

public interface CrawlerObserver {
    void onNewURLProcessed(String url);

public class ConsoleObserver implements CrawlerObserver {
    public void onNewURLProcessed(String url) {
        System.out.println("Processed URL: " + url);

CrawlCommand (Command Pattern)

public class CrawlCommand {
    private String url;
    private HTTPClient httpClient;
    private ParserStrategy parser;
    private CrawlerObserver observer;

    public CrawlCommand(String url, HTTPClient httpClient, ParserStrategy parser, CrawlerObserver observer) {
        this.url = url;
        this.httpClient = httpClient;
        this.parser = parser; = observer;

    public void execute() {
        String content = httpClient.sendRequest(url);
        List<String> urls = parser.parse(content);
        URLQueue queue = URLQueue.getInstance();
        for (String newUrl : urls) {


import java.util.concurrent.TimeUnit;

public class WebCrawler {
    public static void main(String[] args) {
        URLQueue queue = URLQueue.getInstance();
        HTTPClient httpClient = HTTPClientFactory.createHTTPClient();
        ParserStrategy parser = new HTMLParserStrategy();
        CrawlerObserver observer = new ConsoleObserver();

        // Seed URL

        while (!queue.isEmpty()) {
            String url = queue.dequeue();
            if (url != null) {
                CrawlCommand command = new CrawlCommand(url, httpClient, parser, observer);

                // Politeness policy: wait for 1 second between requests
                try {
                } catch (InterruptedException e) {

Summary of Features Implemented

  • URL Queue: Implemented as a singleton to ensure a single queue instance.

  • HTTP Client: Created using the Factory Pattern for flexibility.

  • Parser: Strategy Pattern used to allow different parsing algorithms.

  • Observer: Implemented to notify when a new URL is processed.

  • Command: Encapsulates the crawling request, allowing for easy extension and logging.

  • Breadth-First Search (BFS): Ensures broad exploration from the seed URL.

  • Politeness Policy: Ensures a delay between requests to avoid server overload.

Issues in the Above Design

  1. Single-Threaded Execution:

    • Limitation: The web crawler operates in a single-threaded mode, which significantly limits its performance and speed, especially for large-scale web crawling tasks.

    • Issue: This design can lead to inefficient CPU utilization and increased crawling time.

  2. Politeness Policy:

    • Limitation: The current politeness policy is very basic, using a fixed delay of 1 second between requests. This might not be sufficient for crawling multiple domains with varying load capacities.

    • Issue: This could either overwhelm less robust servers or lead to inefficient crawling for more robust ones.

  3. URL Queue Management:

    • Limitation: The URL queue is implemented as an in-memory data structure, which can lead to memory issues if the queue grows too large.

    • Issue: For large-scale crawls, this could result in out-of-memory errors or crashes.

  4. URL Deduplication:

    • Limitation: The current URL queue checks for duplicates only within the queue itself, not across all processed URLs.

    • Issue: This could lead to redundant crawling of already visited URLs, wasting resources and time.

  5. Error Handling:

    • Limitation: Error handling in the HTTP client is minimal and does not account for various HTTP response codes (e.g., 301 redirects, 403 forbidden).

    • Issue: This can lead to incomplete or incorrect crawling results.

  6. Scalability:

    • Limitation: The design does not account for scaling across multiple machines or using distributed systems.

    • Issue: For very large web crawling tasks, the current design is insufficient as it cannot handle large-scale data and processing requirements.

  7. Storage and Data Management:

    • Limitation: The current implementation stores data in memory and does not use a persistent storage solution like a database.

    • Issue: This is impractical for large-scale crawls where data needs to be stored and queried efficiently.

  8. Parser Flexibility:

    • Limitation: The design uses a single parser strategy (HTMLParserStrategy), which might not be flexible enough to handle various content types like JSON or XML.

    • Issue: The crawler might fail to extract relevant information from non-HTML content.

  9. Ignoring Robots.txt:

    • Limitation: The design does not account for the handling of robots.txt directives, which is essential for respecting website policies and avoiding legal issues.

    • Issue: Ignoring robots.txt can lead to ethical concerns, potential legal repercussions, IP blocking, and increased server load on target websites.

Improvements in Design based on given issues (premium course)

We are covering this in our premium course

Soon will add YouTube video on this channel -

Did you find this article valuable?

Support Subhahu Jain by becoming a sponsor. Any amount is appreciated!