Automating weekly reporting is a transformative step for Customer Success teams. By reducing manual effort, you ensure consistency, save time, and free up resources to focus on meaningful customer interactions. Automated reports provide timely, actionable insights that help you proactively address customer needs, spot trends, and drive better outcomes for both your customers and your organization.

# Template for a week's customer activity data

# List of customer IDs
customers = ["C001", "C002", "C003", "C004", "C005"]

# Dictionary mapping customer ID to number of logins this week
logins = {
    "C001": 5,
    "C002": 0,
    "C003": 2,
    "C004": 7,
    "C005": 1
}

# List of support tickets: each ticket is a dict with customer ID and status
support_tickets = [
    {"customer_id": "C001", "status": "open"},
    {"customer_id": "C002", "status": "closed"},
    {"customer_id": "C003", "status": "open"},
    {"customer_id": "C003", "status": "closed"},
    {"customer_id": "C004", "status": "closed"}
]

# Dictionary mapping customer ID to survey response (True if responded, False if not)
survey_responses = {
    "C001": True,
    "C002": False,
    "C003": True,
    "C004": True,
    "C005": False
}


To automate your weekly Customer Success report, start by structuring your output into three clear sections: a summary of key metrics, a list of customers who need follow-up, and tailored recommendations. 

Begin by calculating totals—such as the sum of logins across all customers, the count of support tickets grouped by status, and the percentage of customers who responded to surveys. Next, identify customers who show signs of disengagement, such as low or zero logins or missing survey responses, and add them to a follow-up list. Finally, format your findings into a readable report that highlights both the metrics and recommended actions for your team. Automation ensures this process is repeatable and reliable each week.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.customers = ["C001", "C002", "C003", "C004", "C005"]
        self.logins = {
            "C001": 5,
            "C002": 0,
            "C003": 2,
            "C004": 7,
            "C005": 1
        }
        self.support_tickets = [
            {"customer_id": "C001", "status": "open"},
            {"customer_id": "C002", "status": "closed"},
            {"customer_id": "C003", "status": "open"},
            {"customer_id": "C003", "status": "closed"},
            {"customer_id": "C004", "status": "closed"}
        ]
        self.survey_responses = {
            "C001": True,
            "C002": False,
            "C003": True,
            "C004": True,
            "C005": False
        }
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code

    def test_total_logins_in_report(self):
        f = io.StringIO()
        with redirect_stdout(f):
            result = self.user_code.generate_weekly_report(self.customers, self.logins, self.support_tickets, self.survey_responses)
        output = normalize_text(result)
        _dynamic_test(
            self,
            "total logins: 15" in output,
            "Report includes correct total logins.",
            f"Expected 'total logins: 15' in report, got: {output}",
        )

    def test_support_tickets_by_status(self):
        f = io.StringIO()
        with redirect_stdout(f):
            result = self.user_code.generate_weekly_report(self.customers, self.logins, self.support_tickets, self.survey_responses)
        output = normalize_text(result)
        _dynamic_test(
            self,
            "support tickets - open: 2, closed: 3" in output,
            "Report includes correct support ticket status counts.",
            f"Expected 'support tickets - open: 2, closed: 3' in report, got: {output}",
        )

    def test_survey_response_rate(self):
        f = io.StringIO()
        with redirect_stdout(f):
            result = self.user_code.generate_weekly_report(self.customers, self.logins, self.support_tickets, self.survey_responses)
        output = normalize_text(result)
        _dynamic_test(
            self,
            "survey response rate: 60.0%" in output,
            "Report includes correct survey response rate.",
            f"Expected 'survey response rate: 60.0%' in report, got: {output}",
        )

    def test_follow_up_list_customers(self):
        f = io.StringIO()
        with redirect_stdout(f):
            result = self.user_code.generate_weekly_report(self.customers, self.logins, self.support_tickets, self.survey_responses)
        output = normalize_text(result)
        # Should include C002, C005 (no survey), and C002, C005 (low logins), C003 (not low logins but covered by survey response)
        _dynamic_test(
            self,
            "- c002" in output and "- c005" in output,
            "Report includes C002 and C005 in follow-up list.",
            f"Expected '- c002' and '- c005' in follow-up list, got: {output}",
        )

    def test_recommendations_section(self):
        f = io.StringIO()
        with redirect_stdout(f):
            result = self.user_code.generate_weekly_report(self.customers, self.logins, self.support_tickets, self.survey_responses)
        output = normalize_text(result)
        _dynamic_test(
            self,
            "follow up on all open support tickets." in output and "encourage more customers to complete the survey." in output and "reach out to customers with zero logins to re-engage them." in output,
            "Report includes all appropriate recommendations.",
            f"Expected recommendations in report, got: {output}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how to leverage Python to automate, analyze, and optimize tasks relevant to Customer Success Managers. This course focuses on practical applications of Python for customer data analysis, reporting, and workflow automation, tailored for professionals with basic Python knowledge.

Explore foundational techniques for analyzing customer data using Python. Learn to summarize, filter, and extract insights from customer datasets relevant to Customer Success Managers.

Delve into methods for assessing customer health and predicting churn using Python. Learn to build simple models and interpret their results for proactive Customer Success management.

Discover how Python can automate repetitive tasks and streamline workflows for Customer Success Managers, from reporting to customer outreach.

Challenge: Automate Weekly Customer Success Report

Oplossing