Skip to content
Available for new opportunities

Sibasish Panigrahi

I'm a reliability-focused DevOps Engineer with 2+ years of production experience designing, automating, and operating highly available AWS infrastructure. My day-to-day lives at the intersection of Infrastructure as Code, CI/CD, container orchestration, and observability — the disciplines that turn 'it works on my machine' into 'it works, on every machine, at 3am, without anyone getting paged unnecessarily.'

Bhubaneswar, Odisha, India
topology — live
trafficLBnode-01node-02node-03us-east-1

0%

Deployment time reduced

0%

Provisioning automated

0%

Infrastructure availability

0+

Production systems shipped

01 — About

From getting paged to designing the pager.

I got into infrastructure the way most reliability engineers do — by getting paged. Somewhere between debugging a misconfigured security group at midnight and watching a Terraform plan finally apply cleanly, I realized the systems behind the product were more interesting to me than the product itself.

That instinct turned into a working philosophy: infrastructure should be boring. Not in the sense of being uninteresting to build, but in the sense that once it's live, nobody should have to think about it. Deployments should be routine. Scaling should be a config change, not a fire drill. Incidents should be rare, well-understood, and followed by a runbook update, not a repeat.

Over the past two years at AAS International, I've built that philosophy into practice — architecting CI/CD pipelines that cut deployment time by nearly 80%, writing reusable Terraform modules that took infrastructure provisioning from days to hours, and standing up an observability stack that catches problems before customers do. I containerize what should be portable, automate what should be repeatable, and document what should be understood by someone other than me.

I'm currently deepening my Kubernetes practice — moving from operating clusters to designing for them from day one — and I stay close to the fundamentals: Linux internals, networking, and the kind of systems thinking that makes the difference between infrastructure that survives a bad day and infrastructure that causes one.

Education

  1. Master of Science (M.Sc.) — Geoinformatics

    Utkal University, Vani Vihar, Bhubaneswar

    October 2021 — September 2023

  2. Bachelor of Science (B.Sc.) — Mathematics

    Panchayat Prahallad Degree College, Cuttack (Utkal University)

    July 2018 — August 2021

02 — Toolbox

The stack, categorized like an architecture diagram.

Not a wall of logos — the tools grouped by the job they do in production.

Cloud Platform

Where the infrastructure actually lives.

AWS EC2AWS IAMAWS S3AWS VPCRoute53Elastic Load BalancerCloudWatchNAT / Internet GatewayDigitalOcean

Containers & Orchestration

Packaging workloads so they run the same everywhere.

DockerDocker ComposeKubernetesPods & DeploymentsServices & DiscoveryWorkload Scaling

Infrastructure as Code

Infrastructure defined, versioned, and reviewed like software.

TerraformTerraform ModulesTerraform State MgmtCloudFormationAnsible

CI/CD & Release Engineering

Shipping code without holding your breath.

JenkinsGitHub ActionsPipeline DesignBuild AutomationRelease ManagementGit / GitHub

Observability & Monitoring

Knowing something broke before a customer tells you.

PrometheusGrafanaLokiAlert ManagementCentralized LoggingIncident Response

Linux, Scripting & Web Serving

The layer everything else sits on top of.

Linux Administration (Ubuntu)Bash / Shell ScriptingNginx Reverse ProxyProcess ManagementCron Jobs

Security & Networking

Locking things down without locking people out.

IAM — Least PrivilegeSSL/TLSCertbotCloudflareSecurity GroupsDNSVPC Subnetting

03 — Proficiency

Depth, mapped honestly.

Expertise labeled the way I'd label it in a 1:1 — not a marketing slide.

AWS Cloud Infrastructure

Advanced

EC2, IAM, VPC, S3, Route53, ELB — daily driver.

Terraform / IaC

Advanced

Reusable modules, remote state, multi-env provisioning.

CI/CD (Jenkins, GitHub Actions)

Advanced

Pipeline design cut deploy time ~80%.

Docker & Containerization

Advanced

Consistent builds across dev, test, and prod.

Linux Administration

Advanced

Ubuntu tuning, hardening, capacity planning.

Kubernetes

Professional

Pods, Deployments, Services, scaling, discovery.

Ansible

Professional

Configuration management across environments.

Observability (Prometheus/Grafana/Loki)

Professional

Dashboards + proactive alerting.

Nginx & Reverse Proxy

Professional

Traffic routing, SSL termination, load balancing.

Cloud Security (IAM, TLS, Cloudflare)

Professional

Least-privilege by default.

CloudFormation

Intermediate

Comfortable alongside Terraform-first workflows.

Kubernetes-native design patterns

Learning

Moving from operating to architecting.

04 — Experience

Where the theory met production.

DevOps Engineer

AAS International Pvt. Ltd.

December 2024 — Present Bhubaneswar, Odisha
  • Architected and maintained end-to-end CI/CD pipelines in Jenkins and GitHub Actions, cutting deployment time by nearly 80% through pipeline automation and continuous integration.
  • Own core AWS infrastructure — EC2, IAM, S3, VPC, Route53, load balancers, and security groups — supporting production workloads with a focus on availability, security, and cost efficiency.
  • Engineered reusable Terraform modules to provision production-ready AWS environments as code, reducing infrastructure provisioning time by approximately 70%.
  • Automated provisioning and configuration management with Terraform and Ansible for faster, repeatable, and consistent deployments across environments.
  • Designed and managed AWS networking — VPC, public/private subnets, route tables, Internet Gateway, and NAT Gateway — for secure, highly available application delivery.
  • Containerized production applications with Docker to ensure consistent behavior across development, testing, and production.
  • Operate and troubleshoot Kubernetes clusters (Pods, Deployments, Services), supporting workload scaling and service discovery.
  • Built and maintained a production-grade observability stack (Prometheus, Grafana, Loki) with centralized logging and dashboards, reducing time to detection.
  • Implemented proactive alerting workflows that surface failures before they reach the business.
  • Perform root cause analysis on production incidents and infrastructure failures, driving fixes that improve system resilience.
  • Hardened cloud security posture — least-privilege IAM, SSL/TLS via Certbot, and Cloudflare-based network protections.
  • Improved infrastructure resilience through automated backups, server snapshots, and disaster recovery planning.
  • Tuned Linux servers for resource utilization, performance, and security, supporting capacity planning for growing workloads.
  • Managed application traffic and load balancing through Nginx reverse proxy configurations.
  • Partnered with development, QA, and infrastructure teams to streamline release cycles and improve deployment reliability.
  • Authored and maintained runbooks and technical documentation covering deployment, architecture, and operations.

05 — Projects

Infrastructure work, end to end.

Each of these shipped to production. Expand for the problem, the approach, and what came out of it.

Problem

The platform needed infrastructure that could handle unpredictable traffic spikes, ship releases without downtime, and give the team visibility into what was actually happening in production.

Solution

Designed and deployed scalable, highly available AWS infrastructure, then wired up Jenkins and GitHub Actions pipelines so releases became routine instead of risky. Services were containerized with Docker for portable, consistent deployments, and Prometheus/Grafana were layered on top for real-time visibility.

Challenges

Balancing availability against cost meant right-sizing infrastructure rather than over-provisioning by default, and building pipelines that were fast without skipping safety checks.

Tech Stack

AWSJenkinsGitHub ActionsDockerPrometheusGrafana

Key Features

  • Highly available AWS infrastructure sized for production traffic
  • Automated CI/CD pipelines for faster, safer releases
  • Containerized services for portable, consistent deployments
  • Real-time monitoring dashboards for app and infra health

Impact & Results

Releases moved from manual, occasional events to a routine, automated process backed by real-time visibility into system health.

  • Faster, safer release cycles
  • Real-time application and infrastructure visibility
  • Currently extending toward Kubernetes-based orchestration

Lessons Learned

Monitoring is only useful if someone actually looks at it — dashboards need to be paired with alerting people trust, or they become wallpaper.

06 — Infrastructure Expertise

How the pieces actually connect.

Simplified views of the patterns I build and operate day to day.

Push to deploy, with tests and rollback built in.

git pushGitHubBuildJenkins / ActionsTestAutomated checksDeployDocker → AWSRollbackon failure

07 — Certifications

On the roadmap.

Hands-on experience first, badges to back it up next — these are actively in progress.

AWS Certification

Amazon Web Services

In progress

Terraform Associate

HashiCorp

In progress

Certified Kubernetes Administrator

CNCF

In progress

08 — Timeline

The path here, briefly.

  1. 2018

    Started B.Sc. in Mathematics

    Panchayat Prahallad Degree College, Cuttack

  2. 2021

    Began M.Sc. in Geoinformatics

    Utkal University, Vani Vihar

  3. 2023

    Completed M.Sc.

    Utkal University, Vani Vihar

  4. 2024

    Joined AAS International as DevOps Engineer

    Bhubaneswar, Odisha

  5. Now

    Deepening Kubernetes & platform engineering practice

    Designing for containers, not just operating them

09 — Philosophy

What I actually believe about infrastructure.

Boring is the goal

The best infrastructure is invisible. If nobody has to think about it, it's working.

Automate the second time

Do it manually once to understand it. If you do it twice, script it.

Observability before optimism

Assume it will break. Build the dashboards and alerts before you need them, not after.

Least privilege, always

Access is a liability until it's needed. Grant narrowly, review often.

10 — A Typical Day

Daily DevOps workflow.

Morning

Check dashboards & overnight alerts

Grafana + CloudWatch review before anything else.

Midday

Pipeline & infra work

Terraform changes, CI/CD improvements, code review.

Afternoon

Cross-team sync

Coordinate releases with dev, QA, and infra.

Ongoing

Incident response, if needed

Root cause first, permanent fix second, runbook update always.

11 — Beyond the Job

What I reach for, and where I'm headed.

Daily toolbox

TerraformAnsibleDockerKubernetesJenkinsGitHub ActionsPrometheusGrafanaLokiNginxAWS CLIBash

Currently learning

  • Kubernetes-native application design
  • Service mesh fundamentals (Istio/Linkerd)
  • Cost-optimization patterns for multi-account AWS

Future goals

  • Earn AWS and Kubernetes certifications to formalize hands-on experience
  • Move from operating Kubernetes clusters to designing platform-level abstractions on top of them
  • Contribute to open-source Infrastructure as Code tooling

Favorite practices

  • Immutable infrastructure over manual patching
  • Everything in version control — including the pipeline that deploys it
  • Alert on symptoms, not causes
  • Runbooks written before the incident, not during it

Pre-deploy production checklist

  • Rollback plan defined before deploy
  • Alerts and dashboards in place for new services
  • Least-privilege IAM applied
  • Backups and disaster recovery verified
  • Runbook updated with anything learned

12 — Console

Try the terminal.

A UI-only shell — a small nod to where I actually spend my day.

sibasish@portfolio: ~
Welcome to sibasish@portfolio:~$ — type 'help' to get started.
$
Hope is not a strategy.SRE proverbYou build it, you run it.Operations principleAutomate everything that happens more than once.Working philosophyHope is not a strategy.SRE proverbYou build it, you run it.Operations principleAutomate everything that happens more than once.Working philosophy

13 — Contact

Let's talk infrastructure.

Open to DevOps, SRE, and Platform Engineering roles. The fastest way to reach me is email.