Getting Started with Python in RevOps

Some of the Expert Series posts are extremely nerdy.

Let’s take a step back from the geeky edge for a second and build a baseline. By the end of this article you are going to be EXCITED about the super powers Python provides for RevOps.

The modern Revenue Operations team sits at the nexus of sales, marketing, and customer success, tasked with optimizing the entire customer lifecycle. Even though WE sit at the nexus… our revenue engine data lives everywhere.

While Salesforce is the undisputed king of Customer Relationship Management, its out-of-the-box capabilities, powerful as they are, can sometimes fall short of the complex, data-driven demands of a truly optimized revenue engine. Even if Salesforce was built for multi-object reporting (it isn’t), Salesforce doesn’t natively bidirectionally sync to your ERP, SEP, accounting software and other key components of the revenue engine.

Problems on problems.

This is where the dynamic duo of Python and a notebook environment like Google Colab comes into play, transforming RevOps from a reactive function to a proactive, data-powered force. The core idea is to use Python to extend Salesforce's capabilities, enabling sophisticated analysis, automation, and cross-functional workflows that are simply not possible within the confines of the standard CRM interface.

p.s. if you are screaming: “set up a real data warehouse, don’t produce analytic products in a notebook environment!” - you are MY kind of nerd — check this out:

Remember, we are trying to set a baseline here to get EVERYBODY on board.

To get started, instead of immediately diving into complex scripts and scheduled cron jobs, the smart approach begins with an iterative, exploratory phase within a Jupyter Notebook (or Google Colab). This provides a sandbox for experimentation, allowing RevOps professionals to connect to Salesforce (and all other business systems), pull data, test modifications, and develop complex logic in a controlled environment. This notebook-first approach is crucial for ensuring that the eventual automated scripts are robust, efficient, and aligned with the specific needs of the business.

The journey starts with establishing a connection. Salesforce, like many modern SaaS platforms, offers a robust API (Application Programming Interface) that allows external applications to interact with its data and functionality. Python, with its rich ecosystem of libraries, makes connecting to this API surprisingly straightforward. While the requests library is a powerful general-purpose tool for making HTTP requests, for Salesforce, it's often more efficient to leverage a dedicated library like simple-salesforce. This library abstracts away many of the low-level complexities of the Salesforce API, providing a more Pythonic and user-friendly interface.

To establish a connection using simple-salesforce, you'll need your Salesforce username, password, and security token. It's strongly recommended to store these credentials securely, perhaps using environment variables or a dedicated secrets management system, rather than hardcoding them directly into your script.

Once you have these credentials, the connection process is remarkably easy.

Python

pip install simple_Salesforce
from simple_salesforce import Salesforce

sf = Salesforce(username='your_username@example.com',
                password='your_password',
                security_token='your_security_token')

print("Connection to Salesforce established successfully!")

With this simple block of code, you've opened a gateway to your Salesforce data. The sf object now represents your connection, and you can use it to interact with various Salesforce objects.

The next step is to retrieve the data you need. This is where the power of SOQL (Salesforce Object Query Language) comes into play. SOQL is similar to SQL, but it's specifically designed for querying data within Salesforce. simple-salesforce provides a convenient way to execute SOQL queries and retrieve the results as Python dictionaries. These dictionaries can then be easily loaded into pandas DataFrames, the workhorse of data analysis in Python.

Let's say you want to retrieve all Accounts with their associated Opportunities AND Contacts. This is a classic example of a multi-object query, something that can be cumbersome to construct within the standard Salesforce reporting interface. With Python and SOQL, it becomes much more manageable.

import pandas as pd

query = """
SELECT
    Account.Name,
    Account.Industry,
    (SELECT Amount, CloseDate, StageName FROM Opportunities),
    (SELECT FirstName, LastName, Email FROM Contacts)
FROM Account
WHERE Account.Industry = 'Technology'
"""

result = sf.query_all(query)
records = result['records']

# Convert the records to a pandas DataFrame (this requires some restructuring)
account_data = []
for account in records:
    account_info = {
        'AccountName': account['Name'],
        'Industry': account['Industry']
    }
    #Handle Opportunities
    if account.get('Opportunities') != None:
        for opp in account['Opportunities']['records']:
            account_info_copy = account_info.copy()
            account_info_copy['OpportunityAmount'] = opp.get('Amount')
            account_info_copy['OpportunityCloseDate'] = opp.get('CloseDate')
            account_info_copy['OpportunityStageName'] = opp.get('StageName')
            account_info_copy['ContactFirstName'] = None
            account_info_copy['ContactLastName'] = None
            account_info_copy['ContactEmail'] = None
            account_data.append(account_info_copy)
    #Handle Contacts
    if account.get('Contacts') != None:
            for cont in account['Contacts']['records']:
                account_info_copy = account_info.copy()
                account_info_copy['OpportunityAmount'] = None
                account_info_copy['OpportunityCloseDate'] = None
                account_info_copy['OpportunityStageName'] = None
                account_info_copy['ContactFirstName'] = cont.get('FirstName')
                account_info_copy['ContactLastName'] = cont.get('LastName')
                account_info_copy['ContactEmail'] = cont.get('Email')
                account_data.append(account_info_copy)
    #Handle no related records
    if account.get('Contacts') == None and account.get('Opportunities') == None:
        account_info['OpportunityAmount'] = None
        account_info['OpportunityCloseDate'] = None
        account_info['OpportunityStageName'] = None
        account_info['ContactFirstName'] = None
        account_info['ContactLastName'] = None
        account_info['ContactEmail'] = None
        account_data.append(account_info)
df = pd.DataFrame(account_data)
print(df.head())

This code retrieves the data, handles the nested structure of related Opportunities and Contacts and converts it all into a pandas DataFrame.

Pandas is incredble, we’ve geeked out about it before. It’s Excel on steroids and it allows you to create windows (the DataFrames) that can be powerfully calibrated to build incredible analytic tools, or perform very detailed file operations. Within the DataFrame, you can now perform advanced data manipulations: calculate win rates by industry, analyze the average deal size, identify accounts with no recent activity, and much more. This level of granular analysis, combining data from multiple objects, is often difficult or impossible to achieve within the standard Salesforce reporting interface.

Before unleashing complex automation, it's crucial to perform a sanity check. This involves writing a test record back to Salesforce to ensure that your connection has the necessary permissions and that your data manipulation logic is sound. This is a small but vital step that can prevent major headaches down the line.

For instance, let's create a new test Account:

Python

try:
    result = sf.Account.create({'Name': 'Python Test Account', 'Industry': 'Technology'})
    print(f"Test Account created successfully! ID: {result['id']}")
except Exception as e:
    print(f"Error creating test account: {e}")

This simple code snippet attempts to create a new Account. If it succeeds, it prints the ID of the newly created Account. If it fails, it prints an error message. This confirms that your authentication is working correctly and that you have the necessary permissions to create records. You can similarly test updates and deletions using the sf.Account.update() and sf.Account.delete() methods, respectively.

Now, the real magic begins. With the connection established, data retrieval tested, and write capabilities confirmed, you can start building the truly powerful automation and analysis workflows that set Python apart.

Consider these examples to get your brain juices flowing:

• Automated Lead Scoring: Instead of relying on Salesforce's built-in lead scoring, you can create a custom scoring model using Python's machine learning libraries (like scikit-learn). You can pull historical lead data, train a model to predict conversion probability, and then use that model to score new leads in real-time, updating a custom field in Salesforce.

• Cross-Object Data Synchronization: Imagine you have custom objects in Salesforce that need to be synchronized with data in an external system (e.g., a marketing automation platform or a product database). Python can act as the bridge, pulling data from both systems, performing the necessary transformations, and ensuring data consistency.

• Proactive Churn Prediction: You can analyze customer usage data, support ticket history, and other relevant factors to build a churn prediction model. Python can then automatically identify at-risk customers and trigger proactive interventions, such as assigning them to a dedicated customer success manager or offering them a special discount.

• Automated Report Generation: Instead of manually creating reports in Salesforce, you can use Python to generate custom reports on a schedule, pulling data from multiple objects, performing complex calculations, and even sending the reports via email to relevant stakeholders.

• Opportunity Stage Progression Analysis: Identify bottlenecks. Use the Opportunity History object, which is typically hard to report on within Salesforce directly, to calculate how long opportunities spend in each stage. Then, you can pinpoint stages where deals tend to stall and take corrective action.

These are just a few examples, and the possibilities are virtually limitless.

The key is to combine the power of Salesforce's data with Python's flexibility and extensibility. This synergistic approach empowers RevOps teams to move beyond the limitations of the standard CRM, creating a truly data-driven and automated revenue engine.

The iterative, notebook-driven development workflow ensures that these powerful solutions are built, tested, and refined in a controlled environment, leading to robust and reliable automation that drives real business results. It's the marriage of data engineering principles and RevOps strategy, all facilitated by the versatility of Python.

👋 Thank you for reading Mastering Revenue Operations.

To help continue our growth, please Like, Comment and Share this post.

I started this in November 2023 because revenue technology and revenue operations methodologies started evolving so rapidly I needed a focal point to coalesce ideas, outline revenue system blueprints, discuss go-to-market strategy amplified by operational alignment and logistical support, and all topics related to revenue operations.

Mastering Revenue Operations is a central hub for the intersection of strategy, technology and revenue operations. Our audience includes Fortune 500 Executives, RevOps Leaders, Venture Capitalists and Entrepreneurs.