To build a simple search engine on Google Cloud, you can leverage various services provided by Google, like Cloud Storage for storing your documents and Cloud Functions for processing and searching. For indexing and searching, you might consider using Google’s Firestore or BigQuery. Here’s a high-level outline for setting up a basic search engine:

1. Set Up Google Cloud Project:

• Create a new Google Cloud project.
• Enable billing for the project.

1. Store Documents in Cloud Storage:

• Upload your documents (e.g., text files) to a Google Cloud Storage bucket.

1. Indexing Documents:

• Create a Cloud Function that triggers on the upload of new documents to the Cloud Storage bucket.
• This function processes the documents to create an index, which could be stored in Firestore (for a NoSQL approach) or BigQuery (for large-scale data).

1. Search Functionality:

• Implement another Cloud Function for handling search queries. This function would interact with your index in Firestore or BigQuery to find relevant documents.

1. User Interface:

• Create a simple web interface (using something like Flask or Django if you’re sticking with Python) hosted on Google App Engine or Cloud Run. This UI sends search queries to your search Cloud Function and displays results.

1. Optimization and Scaling:

• As your needs grow, you might need to optimize your indexing and search strategies, possibly incorporating more advanced algorithms or machine learning models.

Here’s a simplified Python pseudo-code snippet illustrating how a Cloud Function for indexing might look:

def index_document(event, context):
    """Triggered by a change to a Cloud Storage bucket.
    Args:
        event (dict): Event payload.
        context (google.cloud.functions.Context): Metadata for the event.
    """
    file_name = event['name']
    bucket_name = event['bucket']

    # Code to read the file from Cloud Storage
    # ...

    # Process the file to create an index
    # ...

    # Store the index in Firestore or BigQuery
    # ...

And for the search functionality:

def search_documents(request):
    """Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'query' in request_json:
        query = request_json['query']
    elif request_args and 'query' in request_args:
        query = request_args['query']
    else:
        return 'No query provided'

    # Code to search the index in Firestore or BigQuery
    # ...

    # Return the search results
    # ...

This is a basic framework. Real-world search engines have much more complexity, particularly in handling large data volumes efficiently, providing relevant search results, and scaling to handle high request loads. You can expand this basic model with more sophisticated indexing and querying algorithms, better error handling, and a more user-friendly interface.