Stop building customer emails from scratch (Sponsor)

Every product needs effective customer messaging, but creating it means reusing old templates, rewriting copy, fixing formatting, validating logic, and hoping nothing breaks when it ships.

Knock’s agent helps you generate polished, on-brand messages with a prompt, using your team’s approved layouts, components, and styles.

Ask it to create:

• Product launch emails

• Onboarding and re-engagement flows

• In-app tooltips, paywalls, and nudges

• Lifecycle and activation campaigns

• Event invites and reminders

The result: ready-to-review, on-brand messaging that targets the right users at the right time.

Try Knock for your next email →

For years, software security focused on protecting production environments. Teams invested heavily in firewalls, endpoint security, cloud monitoring, and runtime defenses. Yet attackers have increasingly discovered a more efficient path: compromise the systems that build and deploy software instead of attacking the software itself.

This shift has turned CI/CD pipelines into one of the most attractive targets in modern infrastructure.

Every commit, pull request, build, test run, deployment, secret injection, and artifact publication passes through a chain of trusted systems. Organizations often assume these systems are secure because they exist behind developer workflows. In reality, they frequently possess higher privileges than the applications they deploy.

A compromised developer account may provide access to source code. A compromised CI/CD pipeline can provide access to everything.

Why CI/CD Became a Prime Target

Modern software delivery depends on a series of interconnected systems:

• Source Code Management (SCM) platforms like GitHub, GitLab, and Bitbucket

• Build systems such as Jenkins, GitHub Actions, CircleCI, and Azure DevOps

• Artifact registries and package repositories

• Deployment platforms like Argo CD, AWS CodeDeploy, and Kubernetes

Each component trusts the next.

→ A developer pushes code.

→ The repository triggers a build.

→ The build accesses secrets.

→ The deployment system receives artifacts.

→ Production receives updates.

The problem is that attackers only need to compromise one trusted point in that chain.

→ If they gain access to your repository, they may be able to alter workflow files.

→ If they can alter workflow files, they may access secrets.

→ If they access secrets, they can move into cloud environments.

→ If they access cloud environments, they can reach production.

The attack path becomes frighteningly short.

The New Attack Surface: “Pipeline-as-Code”

One of the biggest changes in software delivery is the rise of Infrastructure-as-Code and Pipeline-as-Code.

Files like:

.github/workflows/deploy.yml
.gitlab-ci.yml
Jenkinsfile

are now treated as ordinary source code.

Developers review them in pull requests. They live in repositories and are version controlled.

But unlike regular application code, these files determine what infrastructure does.

A single malicious change may:

• Execute arbitrary commands

• Read environment variables

• Export secrets

• Push code to protected branches

• Modify production deployments

• Alter future pipeline behavior

In other words, attackers don’t need a production exploit if they can modify the automation that controls production.

Real-World Lessons From Supply Chain Attacks

The industry has already seen multiple examples of attackers exploiting software delivery systems.