Setting Up a Production CI/CD Pipeline for a Python/Django App
9 mentions of SSH-related security and modernization efforts were tracked today, with a trend score of 51. Slack’s data platform eliminated 700+ SSH-based jobs by migrating to REST APIs. A Python plugin (hermes-ssh) enables SSH command execution in managed environments. Render supports SSH keys for private package access during deployments. The trend shows acceleration in security-driven SSH deprecation, with a momentum stage of emerging
Slack migrated 700+ production data jobs from SSH to REST APIs to reduce attack surface and enable modernization
The hermes-ssh plugin allows secure, tracked remote command execution in Python-based agent environments
Render uses SSH keys to access private packages during deployment, showing continued practical use in CI/CD workflows
Security concerns around direct SSH access to compute clusters are a primary driver for migration efforts
A growing number of organizations are moving away from SSH in production environments due to security risks. Recent shifts, including GitHub's post-quantum SSH upgrades, signal a focus on future-proofing remote access protocols
The news
Recent developments in infrastructure security are prompting a reevaluation of SSH usage in production environments. A key trend is the shift away from direct SSH access in favor of more secure, auditable alternatives. Slack’s 2024 data platform modernization serves as a case study: it had 700+ SSH-based operators managing critical data pipelines across AWS EMR clusters. These included daily search indexing and business intelligence jobs, all relying on direct SSH access to compute nodes. The platform cited a massive attack surface as a core concern, leading to a full migration to a REST-based architecture with zero downtime. This demonstrates that even large-scale systems are rethinking SSH due to its inherent security risks.
In parallel, tools like hermes-ssh are emerging as plugins that integrate SSH execution into broader monitoring and operations platforms. Hermes Agent’s SSH plugin allows running commands on remote servers, tracking sessions, and reusing connections—all within a centralized agent framework. It supports synchronous and background execution, with configurable timeouts and output truncation. While useful for operational tasks, such tools do not eliminate the underlying security concerns tied to persistent SSH access.
Security is also being addressed at the protocol level. GitHub recently announced post-quantum security upgrades for SSH access, signaling a move toward future-proofing cryptographic standards. This update reflects growing awareness that traditional SSH key exchange methods may become vulnerable to quantum computing threats. However, the evidence remains limited on how widely these upgrades are being adopted or integrated into CI/CD workflows.
In deployment contexts, SSH keys are still used for private package management. Render, for example, enables SSH keys to access private GitHub repositories during deployment. This allows developers to install dependencies using pip install or similar tools, with the SSH key embedded in environment groups for shared access. While effective for package access, this approach relies on secure key management and does not replace the need for broader architectural changes.
The data shows a recent spike in mentions—reaching 9 in a single day—though velocity remains flat. The trend score has fluctuated between 47 and 72 over the past week, with a notable acceleration of 50% on July 11. Source diversity is moderate, with contributions from GitHub, Slack Engineering, and Render. Despite this, no new CI/CD pipeline best practices or architectural patterns have been introduced in the research pack.
A key takeaway: SSH remains in use, but its role is being redefined. It is no longer seen as a default for secure remote execution. Instead, it is increasingly treated as a temporary or operational tool, with long-term migration to secure, auditable alternatives being a priority. The absence of new pipeline configurations or security benchmarks in the data suggests that while awareness is rising, concrete implementation guidance remains limited.
We had a massive security surface, and we couldn’t move forward on any infrastructure modernization. Not ideal. We needed to eliminate SSH entirely.
Commands run through bash -c with pipefail, so pipelines work correctly.
We’re going to walk you through the steps to encode your SSH key into a variable within an environment group so multiple projects can share the key.
The current evidence does not support a clear shift in CI/CD pipeline design toward SSH replacement. Instead, it reflects a cautious coexistence—SSH is still used for access, but its risks are being acknowledged and mitigated through architectural changes and protocol upgrades.
What happened
The shift away from SSH in production environments has been driven by growing security concerns, particularly around direct access to compute clusters. Slack’s 2024 data platform, for example, relied on 700+ SSH-based operators to manage critical data pipelines across AWS EMR clusters. These operators executed tasks like Spark jobs and AWS CLI commands directly on cluster nodes, creating a large attack surface. The platform concluded that maintaining this model hindered infrastructure modernization and introduced unacceptable security risks. As a result, Slack migrated all operations to a REST-based architecture, eliminating SSH entirely across eight data regions with zero downtime.
In parallel, some tools have emerged to manage SSH use more securely and efficiently. The hermes-ssh plugin, for instance, enables remote command execution within the Hermes Agent framework. It supports synchronous and background command execution, with configurable timeouts and output truncation. It allows teams to run commands like df -h or tail -f /var/log/syslog on remote machines while maintaining session tracking and connection reuse. However, this tool does not eliminate the inherent risks of SSH—it simply provides a structured way to manage it.
In deployment workflows, SSH keys are still used for access to private repositories. Render, for example, supports SSH key authentication for private package management in Python apps. Developers can encode SSH keys into environment variables within environment groups so multiple projects can share access. This approach is preferred over tokens in some cases due to broader compatibility with package managers like pip, which do not universally support authentication tokens in dependency files.
Despite these uses, the trend signals a broader movement toward reducing direct SSH access. GitHub recently announced post-quantum security upgrades for SSH access, indicating a strategic effort to future-proof cryptographic protocols. This aligns with industry efforts to reduce attack surfaces and improve auditability.
Recent metrics show a fluctuating trend in mentions: the trend score rose to 67 on July 14, 2026, after a sharp drop from 72 on July 11. The acceleration of 50.0 suggests a growing interest in the topic, though velocity remains stagnant at 0.0. Source diversity is moderate at 15, with contributions from Hacker News, the GitHub blog, and engineering-focused RSS feeds.
While SSH remains functional in certain deployment and package management contexts, its role in production pipelines is increasingly being questioned. The Slack case demonstrates that even large-scale systems can transition away from SSH when security and maintainability become priorities. The evidence suggests a measurable shift—not a complete abandonment—but a reevaluation of when and how SSH is used.
We had a massive security surface, and we couldn’t move forward on any infrastructure modernization. Not ideal. We needed to eliminate SSH entirely.
Commands run through bash -c with pipefail, so pipelines work correctly.
We’re going to walk you through the steps to encode your SSH key into a variable within an environment group so multiple projects can share the key.
The data shows that SSH is not disappearing, but its use is being recontextualized—tightly controlled, documented, and often replaced by more secure, auditable alternatives where possible.
Why the spike
The spike in discussions around SSH in the context of Python/Django CI/CD pipelines is not driven by new technology, but by a growing recognition of its security limitations in production environments. Recent shifts in infrastructure security—such as GitHub’s post-quantum SSH upgrades—highlight the need to future-proof access protocols. While SSH remains widely used for remote execution, its persistent presence in deployment workflows introduces significant attack surfaces. As seen in Slack’s case, 700+ production jobs relying on SSH to orchestrate data pipelines created a massive security footprint, with direct access to EMR clusters enabling potential breaches. This pattern is not isolated; similar architectures in Django apps often use SSH for package installation, environment setup, or remote command execution, especially when integrating with private repositories.
A key factor in the spike is the increasing use of SSH keys for private package management. Platforms like Render require SSH keys to access private packages during deployment, particularly when using pip install with private Git repositories. This creates a dependency on secure key handling and proper key rotation. However, the reliance on SSH for such tasks introduces risks: if a key is compromised or misconfigured, it can grant unauthorized access to sensitive code or dependencies. This is especially problematic in CI/CD pipelines where credentials are exposed in logs or scripts.
The trend also reflects a broader industry move away from direct SSH access. Slack’s migration to REST-based APIs for all data pipeline operations eliminated 700+ SSH-based jobs with zero downtime, demonstrating a scalable, secure alternative. While such a migration is not yet common in Django apps, the momentum is building. Tools like hermes-ssh offer a middle ground—enabling SSH command execution within a monitored agent framework—allowing teams to retain some SSH functionality while improving session tracking and connection reuse. However, these tools do not resolve the underlying security concerns.
The velocity of mentions has spiked sharply in recent days, with a 200% growth on July 11 and a 50-point acceleration in trend score, suggesting a growing awareness of SSH’s risks. Despite only nine total mentions, the sources are diverse—spanning engineering blogs, security discussions, and infrastructure updates—indicating a cross-functional interest. The spike is not driven by a single event, but by a convergence of security concerns, cryptographic updates, and real-world failures in remote access models.
Direct SSH access to compute clusters increases the potential attack surface. We needed to eliminate SSH entirely. The solution? Migrate all 700+ jobs to a REST-based architecture.
The evidence points to a clear shift: SSH is no longer a default or acceptable tool in secure production pipelines. For Python/Django apps, this means that while SSH may still appear in deployment scripts, its use should be carefully evaluated, restricted, and eventually replaced with secure, auditable alternatives such as API-based access or tokenized authentication.
Background
Setting up a production CI/CD pipeline for a Python/Django app involves integrating automated testing, deployment, and infrastructure management. A key component of this process is secure remote access, often achieved through SSH. While SSH has long been a standard for executing commands on remote servers, recent trends highlight growing concerns around its security posture—particularly in production environments where direct access to compute nodes increases attack surface. Slack’s 2024 data platform, for instance, relied on 700+ SSH-based operators to manage critical data pipelines across AWS EMR clusters. This scale introduced significant security risks, including unauthorized access and lateral movement, prompting a full migration to REST-based architectures with zero downtime.
Security improvements are now being prioritized in SSH usage. GitHub recently announced post-quantum security upgrades for SSH access, signaling a shift toward future-proofing cryptographic protocols against emerging threats. This development reflects broader industry efforts to modernize infrastructure access methods. However, SSH remains widely used in deployment workflows—especially in tools like Render, where SSH keys are required to access private packages during deployment. Render enables teams to encode SSH keys into environment variables, allowing shared access across projects while maintaining secure authentication for private repositories.
Tools like hermes-ssh offer enhanced capabilities for managing SSH operations within agent-based environments. The plugin allows execution of remote commands, session tracking, and connection reuse—all from within a centralized agent platform. Features include synchronous and background command execution, timeouts, and output truncation, making it suitable for both simple monitoring and complex deployments. However, such tools do not eliminate the inherent risks of SSH, such as key exposure or brute-force attacks.
Despite these tools and upgrades, SSH is increasingly seen as a transitional technology. Slack’s migration from SSH to REST-based pipelines demonstrates that direct SSH access can be a bottleneck for security and scalability. While it remains functional, its long-term viability in production CI/CD pipelines is being questioned. The trend score for "Setting Up a Production CI/CD Pipeline for a Python/Django App" has risen to 67, with a momentum stage of emerging, indicating growing interest in secure, modern alternatives.
Date
Score
Mentions
Growth
Velocity
2026-07-14
67
9
0.0
0.0
2026-07-13
51
9
0.0
-50.0
2026-07-12
47
9
50.0
-150.0
2026-07-11
72
6
200.0
200.0
We had a massive security surface, and we couldn’t move forward on any infrastructure modernization. Not ideal. We needed to eliminate SSH entirely. — Slack Engineering, From SSH to REST: A Security-Driven Modernization of Slack’s EMR Data Pipelines
Commands run through bash -c with pipefail, so pipelines work correctly. — hermes-ssh plugin documentation
The evidence suggests that while SSH remains embedded in current CI/CD workflows, its role is evolving toward secure, limited use—often as a temporary bridge until more robust, token-based or API-driven systems are adopted.
Evidence and quotes
Evidence and quotes
The research indicates a growing focus on SSH in production infrastructure, particularly in the context of security and operational modernization. A key fact from Slack’s engineering blog reveals that by 2024, their data platform relied on 700+ SSH-based operators to manage critical data pipelines across AWS EMR clusters. These jobs included Spark submissions, AWS CLI commands, and custom Python scripts—all requiring direct SSH access to production nodes. The platform cited this as a major security risk due to the expanded attack surface and lack of auditability. Slack’s solution was to migrate entirely to a REST-based architecture, eliminating SSH access across eight data regions with zero downtime.
In contrast, some tools continue to integrate SSH for remote execution. The hermes-ssh plugin for the Hermes Agent enables secure command execution on remote servers, supporting both synchronous and background sessions with configurable timeouts. It allows users to run commands like df -h or tail -f /var/log/syslog, with output truncation at 50,000 characters by default. The plugin supports deployment via script, manual symlink, or pip installation, though code changes require a Hermes restart to take effect.
SSH keys are also used in private package management workflows. Render, for example, uses SSH keys to authenticate access to private Git repositories during deployment. This approach allows developers to install dependencies using pip install or similar tools, with the SSH key embedded in environment variables. This method is preferred over tokens in cases where package managers do not support environment-based authentication.
Security trends show a shift toward post-quantum cryptographic upgrades in SSH protocols. GitHub recently announced post-quantum security enhancements for SSH access, signaling a move toward future-proofing remote infrastructure. However, the evidence remains limited in scope—only nine mentions were tracked in the current period, with a trend score of 51 and a momentum stage classified as emerging.
Date
Score
Mentions
Growth
Velocity
2026-07-14
67
9
0.0
0.0
2026-07-13
51
9
0.0
-50.0
2026-07-12
47
9
50.0
-150.0
2026-07-11
72
6
200.0
200.0
“We had a massive security surface, and we couldn’t move forward on any infrastructure modernization. Not ideal. We needed to eliminate SSH entirely.” — Slack Engineering Blog, From SSH to REST
“Run commands on remote servers, track sessions, reuse connections — all from inside Hermes.” — hermes-ssh project description
“We’re going to walk you through the steps to encode your SSH key into a variable within an environment group so multiple projects can share the key.” — Render Blog, Using SSH keys for private package management
Implications
Setting up a production CI/CD pipeline for a Python/Django app introduces new operational dependencies, particularly around secure remote access. While SSH remains a common tool for executing commands in deployment environments, its use in production pipelines carries inherent security risks. As noted in Slack’s data platform modernization, over 700 SSH-based operators were managing critical data pipelines in production, each representing a direct access point to compute clusters. This creates a large attack surface, especially when commands are executed without strict auditing or access controls.
The trend toward reducing SSH usage in favor of secure, protocol-based alternatives—such as REST APIs or authenticated service calls—is gaining momentum. Slack’s migration from SSH to REST-based workflows eliminated direct access to EMR clusters, enabling infrastructure modernization with zero downtime. This suggests that even in high-volume environments, SSH can be a liability when used for routine operations.
In the context of CI/CD, SSH is still used for specific tasks, such as installing private packages. Render, for example, supports SSH keys to authenticate access to private Git repositories during deployment. However, this approach relies on secure key management and is not universally supported across all package managers. Alternatives like environment variables for tokens are more widely adopted, but SSH remains a fallback when token-based authentication fails.
Feature
SSH Use Case
Security Risk
Remote command execution
Deploy scripts, package installs
Direct access to nodes increases attack surface
Private package access
pip install from private repos
Key exposure if mismanaged
Session tracking
Hermes Agent plugin
Session logs can be exploited if not encrypted
A key implication is that any CI/CD pipeline using SSH must include strict access controls, session logging, and key rotation policies. GitHub’s recent post-quantum SSH security upgrades indicate a shift toward future-proofing cryptographic standards, but this does not eliminate the need for architectural redesign. The evidence suggests that SSH should be used sparingly and only when no secure alternative exists.
