Jenkins Pipeline Tutorial: Declarative vs Scripted (With Real Examples)

If you're diving into Jenkins and wondering "what’s the deal with Declarative vs Scripted Pipelines?", you're not alone.

When I first got into CI/CD, I kept seeing two totally different ways to write Jenkins pipelines—and I wasn’t sure which one to use or why.

So let’s break it down in simple terms, with real examples, key differences, and when you should use one over the other.

🤖 What Is a Jenkins Pipeline?

A Jenkins Pipeline is a way to define your entire CI/CD process as code using a file called Jenkinsfile.

It automates steps like:

• Cloning your code
• Running tests
• Building artifacts (like Docker images or JARs)
• Deploying to staging or production

There are two types of pipeline syntax in Jenkins:

• Declarative Pipeline (newer, structured)
• Scripted Pipeline (older, Groovy-style code)

🧾 Declarative Pipeline

The Declarative syntax is the recommended approach. It's clean, structured, and built for simplicity.

✅ Example:

pipeline { agent any stages { stage('Build') { steps { echo 'Building the project...' } } stage('Test') { steps { echo 'Running tests...' } } stage('Deploy') { steps { echo 'Deploying to production...' } } } } 

🟢 Pros:
Easier to read and maintain

Built-in error handling (post section)

Enforces structure (helps new users)

🔴 Cons:
Less flexible than scripted

Not everything Groovy supports is allowed here

🔧 Scripted Pipeline
The Scripted syntax is more powerful but also more complex. It's written entirely in Groovy, so it's like writing code, not config.

⚙️ Example:

node { stage('Build') { echo 'Building the project...' } stage('Test') { echo 'Running tests...' } stage('Deploy') { echo 'Deploying to production...' } } 

🟢 Pros:
Full control and flexibility (it's just Groovy!)

Good for complex logic or loops

🔴 Cons:
Harder to read and maintain

Easy to mess up with no structure or guidance

Not beginner-friendly

💡 So... Which One Should You Use?
✅ Use Declarative if you're:

New to Jenkins

Writing simple to medium-complexity pipelines

Wanting cleaner code with better readability

🔧 Use Scripted if you're:

Comfortable with Groovy

Need dynamic behavior, custom conditions, or advanced loops

📦 Bonus Tip: Combine Both!
You can use Scripted blocks inside a Declarative pipeline using script { ... }. Example:

pipeline { agent any stages { stage('Mixed') { steps { script { def items = ['A', 'B', 'C'] items.each { item -> echo "Processing ${item}" } } } } } } 

This gives you the structure of Declarative with the power of Scripted — best of both worlds!

🚀 Final Thoughts
Whether you choose Declarative or Scripted, Jenkins Pipelines make CI/CD much more powerful and scalable. Start with Declarative, then reach for Scripted only if you truly need it.

💬 Got questions? Drop a comment below and let's talk DevOps!

If this helped you, consider following me here on Dev.to and subscribing to my YouTube channel https://www.youtube.com/@DataEnthusiastEra for more DevOps tutorials! 🙌