"So what do you actually do?" It's the question every engineer dreads at dinner parties, but it's become even harder to answer as engineering roles have multiplied and evolved. Are you a software engineer? A platform engineer? A DevOps engineer? An SRE? Sometimes it feels like we're making up job titles as we go.
After working across all these roles and hiring for teams in each discipline, I've learned that the boundaries are much blurrier than the job descriptions suggest. But there are real differences in daily work, career trajectories, and the problems you'll spend your time solving.
The Great Engineering Role Explosion
Ten years ago, most companies had two types of engineers: developers (who wrote application code) and system administrators (who kept servers running). Today's engineering organizations look more like a specialized medical practice, with roles for every possible intersection of code, infrastructure, and operations.
This specialization happened for good reasons:
- Software systems became massively distributed
- Infrastructure became programmable (and incredibly complex)
- Scale requirements exceeded what generalists could handle
- Business requirements for reliability and security intensified
But it also created confusion about responsibilities, career paths, and where exactly you fit in the engineering ecosystem.
Software Engineers: Building the Thing
Software engineers (also called application developers, software developers, or just "devs") build the features that users interact with. They're focused on solving business problems through code.
What They Actually Do
// Typical software engineer work
function processPayment(amount, paymentMethod) {
// Validate input
if (!isValidAmount(amount)) {
throw new Error('Invalid payment amount');
}
// Process payment through external service
const result = await paymentService.charge(amount, paymentMethod);
// Update user account
await updateUserBalance(result.userId, amount);
// Send confirmation
await notificationService.sendReceipt(result.transactionId);
return result;
}Daily activities:
- Writing application logic and business rules
- Building user interfaces and APIs
- Integrating with third-party services
- Writing tests and fixing bugs
- Participating in code reviews
- Collaborating with product managers and designers
Skills and Focus Areas
- Programming languages (JavaScript, Python, Java, Go, etc.)
- Frameworks and libraries (React, Django, Spring, etc.)
- Database design and query optimization
- API design and integration patterns
- Testing strategies (unit, integration, end-to-end)
- Business domain knowledge
Career Progression
- Junior Developer → Senior Developer → Staff Engineer → Principal Engineer
- Alternative path: Technical Lead → Engineering Manager → Director of Engineering
What They Don't Usually Do
- Configure infrastructure or deployment pipelines
- Set up monitoring and alerting systems
- Manage databases or server configurations
- Handle incident response and on-call rotations
- Design network architectures
The reality: In smaller companies, developers often wear multiple hats and do some platform/DevOps work. In larger organizations, they're more specialized.
Platform Engineers: Building the Foundation
Platform engineers build the internal systems that other engineers use to develop, deploy, and operate software. They're focused on developer productivity and infrastructure abstractions.
What They Actually Do
# Typical platform engineer work - creating developer self-service
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: team-api-production
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/company/team-api
targetRevision: main
path: k8s/production
destination:
server: https://kubernetes.default.svc
namespace: team-api-prod
syncPolicy:
automated:
prune: true
selfHeal: trueDaily activities:
- Building internal developer platforms (IDPs)
- Creating self-service tools and abstractions
- Designing CI/CD pipeline templates
- Implementing infrastructure as code patterns
- Building developer portals and documentation
- Automating environment provisioning
Skills and Focus Areas
- Infrastructure as Code (Terraform, Pulumi, CloudFormation)
- Container orchestration (Kubernetes, Docker)
- CI/CD systems (Jenkins, GitLab CI, GitHub Actions)
- Cloud platforms (AWS, GCP, Azure)
- Developer experience design
- API design for internal tools
- Documentation and developer advocacy
Career Progression
- Platform Engineer → Senior Platform Engineer → Staff Platform Engineer → Principal Platform Engineer
- Alternative paths: Platform Team Lead → Head of Platform → VP of Engineering
The Platform Engineering Philosophy
Platform engineers follow the principle: "Make the right thing the easy thing." They build guardrails and golden paths that let developers ship code quickly while maintaining security and reliability standards.
# What platform engineers enable
$ platform create service --name user-api --team backend
✅ Created Kubernetes namespace: user-api-prod
✅ Set up CI/CD pipeline: github.com/company/user-api
✅ Configured monitoring: grafana.company.com/user-api
✅ Created service mesh entry: user-api.internal.company.com
🚀 Your service is ready! Push code to deploy.DevOps Engineers: Bridging Development and Operations
DevOps engineers focus on the software delivery lifecycle—getting code from developers into production reliably and efficiently. They're the bridge between development teams and infrastructure.
What They Actually Do
# Typical DevOps engineer work - CI/CD pipeline
name: Deploy to Production
on:
push:
branches: [main]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run tests
run: |
npm install
npm run test
npm run lint
security-scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run security scan
run: |
npm audit
docker run --rm -v $PWD:/app securecodewarrior/scanner
deploy:
needs: [test, security-scan]
runs-on: ubuntu-latest
steps:
- name: Deploy to production
run: |
docker build -t myapp:${{ github.sha }} .
kubectl set image deployment/myapp myapp=myapp:${{ github.sha }}Daily activities:
- Building and maintaining CI/CD pipelines
- Automating deployment processes
- Managing infrastructure provisioning
- Implementing monitoring and logging
- Handling release management
- Troubleshooting deployment issues
- Collaborating with development teams
Skills and Focus Areas
- CI/CD tools (Jenkins, GitLab CI, GitHub Actions, CircleCI)
- Configuration management (Ansible, Chef, Puppet)
- Infrastructure automation (Terraform, CloudFormation)
- Containerization (Docker, Kubernetes)
- Monitoring tools (Prometheus, Grafana, ELK stack)
- Cloud platforms and services
- Scripting (Bash, Python, PowerShell)
Career Progression
- DevOps Engineer → Senior DevOps Engineer → Lead DevOps Engineer → DevOps Architect
- Alternative paths: Release Manager → Engineering Manager → Head of Engineering
The Evolution of DevOps
The DevOps role has evolved significantly:
- Early days (2010-2015): Jack-of-all-trades automation engineers
- Growth phase (2015-2020): Specialized in CI/CD and cloud adoption
- Current era (2020+): Increasingly overlapping with Platform Engineering
Many organizations are transitioning DevOps engineers into Platform Engineering roles as the focus shifts from "automate everything" to "build platforms that enable automation."
Site Reliability Engineers (SRE): Keeping Things Running
SREs focus on the reliability, performance, and scalability of production systems. They apply software engineering principles to operations problems.
What They Actually Do
# Typical SRE work - defining and monitoring SLOs
def calculate_error_budget():
"""Calculate remaining error budget for the month"""
slo_target = 0.999 # 99.9% availability SLO
# Get actual availability from monitoring
total_requests = get_total_requests_this_month()
failed_requests = get_failed_requests_this_month()
actual_availability = (total_requests - failed_requests) / total_requests
# Calculate error budget consumption
allowed_errors = total_requests * (1 - slo_target)
actual_errors = failed_requests
error_budget_consumed = actual_errors / allowed_errors
return {
'availability': actual_availability,
'error_budget_remaining': 1 - error_budget_consumed,
'recommended_action': get_recommendation(error_budget_consumed)
}
def get_recommendation(budget_consumed):
if budget_consumed > 0.8:
return "SLOW DOWN: Focus on reliability over new features"
elif budget_consumed < 0.2:
return "SPEED UP: Error budget healthy, can take more risks"
else:
return "MAINTAIN: Current pace is appropriate"Daily activities:
- Defining and monitoring Service Level Objectives (SLOs)
- Managing error budgets and reliability targets
- Conducting incident response and post-mortems
- Building automation to reduce operational toil
- Capacity planning and performance optimization
- Implementing chaos engineering practices
- On-call rotations and escalation procedures
Skills and Focus Areas
- Systems engineering and distributed systems knowledge
- Monitoring and observability (Prometheus, Grafana, Jaeger)
- Incident response and post-mortem analysis
- Statistical analysis and SLO/SLI design
- Programming (Python, Go, Java for automation)
- Performance engineering and capacity planning
- Chaos engineering and reliability testing
Career Progression
- SRE → Senior SRE → Staff SRE → Principal SRE
- Alternative paths: SRE Manager → Head of SRE → VP of Engineering
The SRE Philosophy
SREs follow Google's philosophy that reliability is a feature that should be engineered like any other product feature. They balance reliability with velocity using error budgets and data-driven decision making.
The Blurry Lines: Where Roles Overlap
In practice, these roles overlap significantly, and the boundaries depend heavily on company size and organizational structure.
Small Companies (< 50 engineers)
- Full-stack developers handle everything from frontend to deployment
- One "DevOps person" who does platform, operations, and SRE work
- Everyone participates in on-call rotations
Medium Companies (50-200 engineers)
- Dedicated platform team emerges
- DevOps engineers focus on CI/CD and deployment automation
- SRE practices are adopted but not necessarily dedicated SRE roles
- Clear separation between application development and infrastructure
Large Companies (200+ engineers)
- Specialized teams for each discipline
- Platform engineering becomes a major function
- Dedicated SRE teams with formal practices
- Clear interfaces between teams with defined responsibilities
Career Path Considerations
Choosing between these roles depends on your interests, skills, and career goals:
Choose Software Engineering If You:
- Love solving business problems through code
- Enjoy working closely with product and design teams
- Want to see direct user impact from your work
- Prefer working in specific programming languages/frameworks
- Like building features and user experiences
Choose Platform Engineering If You:
- Enjoy building tools that other engineers use
- Like solving infrastructure and scalability challenges
- Want to impact developer productivity across the organization
- Enjoy working with cloud technologies and automation
- Like designing systems and APIs
Choose DevOps Engineering If You:
- Enjoy automating manual processes
- Like working at the intersection of development and operations
- Want to focus on software delivery and deployment
- Enjoy troubleshooting and problem-solving
- Like working with a variety of tools and technologies
Choose SRE If You:
- Enjoy working with large-scale distributed systems
- Like analyzing data and metrics to drive decisions
- Want to focus on reliability and performance
- Enjoy incident response and problem-solving under pressure
- Like applying engineering principles to operational problems
The Skills Overlap
All these roles share some fundamental skills:
Common Skills Across All Roles
- Programming (though languages and focus areas differ)
- Systems thinking and distributed systems knowledge
- Debugging and troubleshooting skills
- Collaboration and communication
- Problem-solving and analytical thinking
Where They Diverge
- Software Engineers: Deep domain knowledge, user experience focus
- Platform Engineers: Infrastructure design, developer experience
- DevOps Engineers: Automation, deployment pipelines, tool integration
- SREs: Reliability engineering, statistical analysis, incident management
The Industry Evolution
These roles continue to evolve as technology and organizational needs change:
Current Trends
- Platform Engineering is becoming more prominent as organizations mature
- DevOps is evolving into more specialized platform and SRE roles
- Full-stack developers are expected to understand basic infrastructure
- SRE practices are being adopted even without dedicated SRE teams
Future Directions
- AI/ML Engineering emerging as a distinct discipline
- Security Engineering becoming more specialized
- Developer Experience Engineering as a specific focus area
- Sustainability Engineering for green computing initiatives
Making the Choice
The "best" role is the one that aligns with your interests, strengths, and career goals. Consider:
Day-to-Day Work
What kind of problems do you want to solve every day? Building user features, designing infrastructure, automating processes, or ensuring reliability?
Impact and Scope
Do you want direct user impact, developer productivity impact, or system reliability impact?
Learning and Growth
Which technologies and skills do you want to develop? Each role emphasizes different technical skills and career trajectories.
Work Environment
Do you prefer working closely with product teams, enabling other engineers, or diving deep into system internals?
The Verdict
There's no "wrong" choice among these engineering roles. Each addresses different aspects of building and operating software systems, and successful organizations need all of them.
The roles are also more fluid than job titles suggest. Great engineers often transition between these disciplines throughout their careers, and the skills you develop in one area often transfer to others.
My advice: Start with what interests you most, build strong foundational skills, and stay curious about adjacent areas. The engineering landscape will continue evolving, and the most successful engineers are those who can adapt and grow with it.
Remember: titles matter less than the problems you're solving and the value you're creating. Whether you're building features, platforms, automation, or reliability systems, you're contributing to the complex ecosystem that powers modern software.