Cloud & Network AutomationLab-first · Mentored · Portfolio-backed

Cloud & Network Automation Internship

Fuse your Cloud Computing, Python and DevOps courses into one deployable skill — infrastructure that builds, validates and heals itself from a Git repo.

8 modules24 labs3 formatsCredit-mappable

Overview

What this internship makes you able to do.

Indian B.Tech curricula now teach Cloud Computing, Python and DevOps as three separate subjects — and students graduate unable to combine them into the one skill the industry is actually hiring for: automation. A 2026 network or cloud team does not want an engineer who types configuration into a terminal; it wants one who writes the code that generates, tests and deploys that configuration through a pipeline. That discipline — NetDevOps, or fabric-as-code — is what this internship teaches, end to end, on real tooling.

The arc is deliberately progressive. You start where every automation engineer starts: Python scripts driving live network devices with Netmiko and NAPALM. Then you go structured — NETCONF/RESTCONF and YANG models instead of screen-scraping, with a first look at gNMI streaming. Ansible turns your scripts into idempotent, inventory-driven playbooks. Git and CI (GitHub Actions) turn your playbooks into a reviewed, tested change process with pre-change validation gates. Terraform extends the same as-code discipline to cloud infrastructure — you build a real AWS VPC with subnets, route tables and security groups from a plan/apply workflow — and Docker plus an introduction to Kubernetes networking shows you where the workloads actually live. You finish with observability-as-code and a first closed-loop remediation, then a defended capstone: a pipeline that builds and validates an entire network from a Git push.

The internship is built for the Indian academic calendar and the AICTE/NEP internship mandate. Take it as a 4-week winter sprint, an 8-week summer internship, or a 6-month final-semester capstone that maps to your project/internship credits. Every track ends the same way: a graded capstone pipeline, a public GitHub portfolio a hiring manager can read commit by commit, an RKR completion certificate, and — for the strongest interns — a direct bridge into the RKR Certified DataCenter Automation (RCDA) certification and the hiring pipeline behind it.

Built on your syllabus

The courses this internship extends.

You've already studied these. Here's how each one becomes a deployable skill.

Cloud ComputingCSE · IT · AI&ML
AICTE model CC / Anna Univ CCS335 / VTU 21CS72 / JNTU CC

Virtualisation, IaaS and cloud service models stop being definitions — you build a real AWS VPC with subnets, route tables and security groups from Terraform and destroy/rebuild it on demand.

Python ProgrammingCSE · IT · AI&ML · ECE
AICTE model / Anna Univ GE3151 / first-year Programming

The Python you wrote for assignments becomes production tooling — Netmiko/NAPALM device drivers, Jinja2 config templates, and pytest-based validation that gates a real change pipeline.

DevOps / Software EngineeringCSE · IT
AICTE model SE / Anna Univ CCS342 (DevOps) / VTU 21CS42

SDLC, version control and CI/CD taught as process diagrams becomes a working pipeline: branch, pull request, automated lint + test, peer review, and a gated deploy to lab infrastructure.

Computer NetworksCSE · IT · AI&ML
AICTE model CN / Anna Univ CS3591 / VTU 21CS52 / JNTU CN

Routing, subnetting and protocols from the syllabus become the thing your code manages — you cannot automate a network you don't understand, so every pipeline you build is validated against live routing state.

Choose your format

Matched to the Indian academic calendar.

Winter Internship
4 weeks
20 hrs / week · Virtual — live evening mentoring + 24×7 cloud lab

Credit: Fits a 2–4 week AICTE winter/vacation internship; certificate + logbook for internal credit

Best for: Pre-final year students wanting a fast, intense first exposure to NetDevOps

Summer Internship
8 weeks
25 hrs / week · Hybrid — live mentoring, cloud lab, weekly code reviews

Credit: Maps to the standard 6–8 week AICTE summer internship required between 3rd and 4th year

Best for: The core track — 3rd-year students building a GitHub portfolio before placements

Semester Capstone Internship
24 weeks
18 hrs / week · Hybrid — sustained project work with a dedicated mentor

Credit: Maps to the NEP 2020 full-semester / final-year internship-project credits (often 12–20 credits)

Best for: Final-semester students doing internship-in-lieu-of-project

The curriculum

8 modules. 24 labs. Week by week.

This is the full plan for the 8-week track (the winter and semester formats compress or extend the same arc). Every week ends in a deliverable your mentor reviews.

Week 1

Python for networking: from scripts to device drivers

Re-anchor your Python on a real problem: driving live network devices. By Friday your code logs into a multi-vendor containerlab topology, pulls state and pushes configuration.

You'll do
  • Cloud-lab onboarding; spin up a 4-node containerlab topology and connect with Netmiko (send_command / send_config_set)
  • Refactor raw Netmiko calls into NAPALM getters (get_facts, get_interfaces, get_bgp_neighbors) and diff structured output
  • Render interface and VLAN configuration from Jinja2 templates fed by a YAML inventory, then push and verify
Deliverable: Python repo that inventories, templates and configures a 4-node lab, with structured-state output committed as evidence
Week 2

Model-driven config: NETCONF, RESTCONF, YANG & gNMI

Stop screen-scraping. Talk to devices through structured APIs and data models — the interface every modern NOS and controller exposes.

You'll do
  • Explore a device's YANG models with pyang; walk openconfig-interfaces and map leaves to CLI equivalents
  • Configure interfaces and BGP over NETCONF (ncclient) with candidate datastore, validate and commit-confirmed rollback
  • Query and patch operational state over RESTCONF with Python requests; take a first gNMI subscription for interface counters
Deliverable: Model-driven config toolkit: one change executed three ways (CLI, NETCONF, RESTCONF) with a written comparison of failure behaviour
Week 3

Ansible network automation & idempotency

Turn scripts into declarative, inventory-driven playbooks. The test of this week is idempotency: running your playbook twice must change nothing the second time.

You'll do
  • Build an Ansible inventory with group_vars/host_vars for the lab fabric; run first plays with cisco.ios / arista.eos collections
  • Write roles for base config, VLANs and OSPF; prove idempotency with --check and changed=0 on re-run
  • Handle secrets properly with ansible-vault and add assert/validate tasks that fail the play when post-change state is wrong
Deliverable: Ansible repo (roles + inventory + vault) that converges the whole lab from blank config, with a recorded idempotent second run
Week 4

Git, config-as-code & CI with pre-change validation

Wrap the automation in a real change process: every network change is a pull request that must pass linting, rendering and pre-change tests before a human can even review it.

You'll do
  • Restructure the repo around a Git branching workflow; enforce PR review and protected main branch
  • Build a GitHub Actions pipeline: yamllint + ansible-lint, Jinja2 render check, then a dry-run (--check --diff) against the lab
  • Write pytest-based pre/post validation (BGP neighbours up, expected routes present, ping matrix) and gate the deploy job on it
Deliverable: CI/CD pipeline where a merged PR deploys a validated network change end-to-end, with a failed-gate example documented
Week 5

Infrastructure-as-Code: Terraform & AWS cloud networking

Extend as-code discipline from device config to whole infrastructure. You design and build real AWS network primitives from Terraform and learn to read a plan like a change request.

You'll do
  • Terraform fundamentals on AWS free tier / LocalStack: providers, state, plan/apply/destroy; build a VPC with public and private subnets across two AZs
  • Add route tables, an internet gateway, NAT and security groups; justify every rule, then verify reachability from a test EC2 instance
  • Refactor into reusable modules with variables/outputs, add remote state, and run terraform plan as a CI check on pull requests
Deliverable: Terraform module set that builds a two-tier VPC (public/private subnets, routing, security groups) from a single apply, plan output archived in CI
Week 6

Containers & Kubernetes networking

Meet the workloads your networks exist to serve. Build and network containers by hand, then see how Kubernetes abstracts the same problems at scale.

You'll do
  • Containerise a small Flask network-inventory API with a Dockerfile; wire multi-container networking with docker compose and inspect bridge/veth plumbing
  • Stand up a kind/minikube cluster; deploy the API and trace ClusterIP Services, kube-proxy rules and DNS resolution between pods
  • Expose the app through a NodePort and an Ingress; apply a NetworkPolicy and prove which flows it blocks
Deliverable: Containerised app deployed to Kubernetes with a written packet-walk of pod-to-pod and ingress traffic paths
Week 7

Observability-as-code & the first closed loop

Automation you can't observe is automation you can't trust. Deploy the monitoring stack itself as code, then close the loop: detection triggers automated, validated remediation.

You'll do
  • Deploy Prometheus + Grafana with docker compose from your repo; scrape lab devices via SNMP/gNMI exporters and provision dashboards as JSON in Git
  • Define alert rules as code (interface down, BGP session drop) and route them through Alertmanager to a webhook receiver
  • Build a closed-loop demo: the webhook triggers an Ansible remediation playbook that fixes the fault, re-validates state and posts evidence
Deliverable: Observability stack fully defined in Git + a recorded closed-loop run: injected fault → alert → automated fix → validated recovery
Week 8

Capstone: the pipeline that builds the network

A fresh written brief, a blank repo, and one requirement: a pipeline that builds, validates and monitors a complete environment from a Git push — then defend it live.

You'll do
  • Design and implement the full pipeline: Terraform for cloud networking, Ansible for fabric config, CI gates with pre/post validation
  • Run a live change drill: an injected bad change must be caught by the pipeline gates, not by a human
  • Present and defend the architecture, code and failure evidence to a mentor panel in a recorded review
Deliverable: Capstone monorepo + architecture document + recorded pipeline runs and defence
Tools & tech you'll use
Python 3 · Netmiko · NAPALMNETCONF / RESTCONF · YANG · gNMI (intro)Ansible (network modules)Git · GitHub Actions CITerraformAWS (free tier) / LocalStack — VPC, subnets, security groupsDocker · Kubernetes networking (intro)containerlab lab topologiespytest · pyATS-style validation

The capstone

Fabric-as-Code: A Pipeline That Builds and Validates a Network

You receive a written brief for a company standing up a new environment: a cloud VPC for its applications, a lab network fabric connecting sites, monitoring, and a strict no-manual-changes policy. Starting from an empty repository, you must deliver a pipeline where a Git push builds the infrastructure, configures the fabric, validates every claim automatically and alerts on drift — then defend the design and a live change drill in front of a mentor panel.

Terraform-built AWS VPC with public/private subnets, route tables and least-privilege security groups, planned and applied through CI
Ansible-driven fabric configuration (interfaces, VLANs, routing) proven idempotent on re-run
A CI pipeline with lint, render, dry-run and pytest pre/post validation gates on every pull request
A demonstrated failure case: a deliberately bad change caught and blocked by the pipeline, not a human
Observability defined as code (Prometheus/Grafana/alert rules) with at least one closed-loop remediation
An architecture document justifying tool choices, pipeline stages and rollback strategy
How it's graded: Graded against a published rubric on pipeline correctness, idempotency, validation depth, failure handling and the live defence. A pass earns the RKR Cloud & Network Automation certificate; a distinction earns a fast-track referral into the RCDA certification and the RKR hiring pipeline.

Measurable outcomes

Walk out able to do this — on record.

Automate multi-vendor network devices with Python (Netmiko/NAPALM) and structured APIs (NETCONF/RESTCONF/YANG), choosing the right interface for the change

Build idempotent, inventory-driven Ansible roles that converge a network fabric from blank config and prove changed=0 on re-run

Operate a Git-based change workflow with CI gates — lint, render, dry-run and pytest pre/post validation — on every network change

Design and deploy AWS cloud networking (VPC, subnets, route tables, security groups) as reusable Terraform modules with plan-reviewed changes

Containerise an application and explain Kubernetes networking — Services, kube-proxy, Ingress and NetworkPolicy — with a traced packet walk

Deploy an observability stack as code and demonstrate a closed-loop remediation from alert to validated recovery

What you keep

Your portfolio artifacts.

NetDevOps portfolio (GitHub)

Every repo from the internship — Python tooling, Ansible roles, Terraform modules, CI workflows — public, commit-by-commit evidence a hiring manager can actually read.

CI/CD network-change pipeline

A working GitHub Actions pipeline with linting, rendering, dry-run and pre/post validation gates — the exact artefact NetDevOps interviews ask you to walk through.

Terraform cloud-networking module set

Reusable modules that build a two-tier AWS VPC (subnets, routing, security groups) from one apply, with archived plan output as change evidence.

Closed-loop automation demo

A recorded run of fault injection → alert → automated Ansible remediation → validated recovery, with the whole stack defined as code.

RKR completion certificate

Verifiable certificate stating the graded outcome and hours — mappable to your AICTE/NEP internship credit.

Mentorship
  • Assigned mentor who is a working automation/DevOps engineer, not a content narrator
  • Weekly live code review of your repos, playbooks and pipeline runs — PR-style, with written feedback
  • Async help channel with 1-business-day response on blockers
  • Interview-prep session: how to walk a panel through your pipeline like an engineer
Evaluation & certificate

Continuous assessment on weekly deliverables (60%) plus a graded, defended capstone (40%). Every intern receives a verifiable RKR completion certificate with the graded outcome and logged hours, formatted for AICTE/NEP internship-credit submission. Distinction-grade interns receive a letter of recommendation and priority access to the RKR hiring pipeline and RCDA certification fast-track.

Career plan

Where this internship takes you.

This internship targets the fastest-growing job family in Indian infrastructure: engineers who code against networks and clouds instead of clicking through them. Entry-level manual IT roles are shrinking under automation — the leverage has moved to the people who write that automation. A public pipeline portfolio plus a defended capstone is the strongest possible answer to 'show me what you've built', and strong interns bridge directly into the RCDA certification and the datacenter-automation roles behind it.

Roles unlocked
NetDevOps / Network Automation Engineer (Associate)DevOps Engineer (Junior)Cloud Engineer — AWS (Associate)Site Reliability / Platform Engineer (Trainee)Infrastructure Automation Developer
Entry band (post)
Rs 4.5–8 LPA entry, with a credible 10–18 LPA step within 2–3 years on the automation-specialist track
Stipend
Merit stipend during the internship for distinction-track interns; performance-based project stipend on the semester capstone

Conversion: Distinction-grade interns are referred into the RKR hiring-partner pipeline and fast-tracked into the RCDA certification that unlocks the AI-datacenter automation premium.

Rung 1 · 0-1 yr
Automation / Junior DevOps Engineer
Rs 4.5-7 LPA
Rung 2 · 1-3 yrs
NetDevOps / Cloud Engineer
Rs 8-15 LPA
Rung 3 · 3-6 yrs
Senior Automation / Platform Engineer
Rs 15-28 LPA
Rung 4 · 6+ yrs
Infrastructure Automation Architect
Rs 25-45 LPA
Demand signal

Entry-level manual IT roles are down 20–25% under automation (EY, 2025) while ~132,000 new GCC jobs are expected in 2026 with AI-first roles over 30% of demand — and India's datacenter build-out ($60–70bn announced over 5 years, capacity scaling 1.7 GW toward 5–6.5 GW) is projected to create ~100,000 datacenter jobs by 2030, with niche AI-infrastructure automation specialists commanding a 1.7x pay premium.

Other tracks

Explore the rest of the catalog.

Network Engineering Internship

Turn your Computer Networks course into a deployable skill — configure, route and troubleshoot a real enterprise network on live gear, not a slide deck.

8 modules 22 labs

AI Datacenter Infrastructure Internship

Build the spine-leaf fabric India's AI datacenters actually run on — eBGP underlay, EVPN-VXLAN overlay, and lossless RoCEv2 for GPU clusters — on real NX-OS and Junos.

8 modules 24 labs

Cybersecurity & Network Defense Internship

Turn your Cryptography & Network Security course into a defensible network — deploy PKI, firewalls, VPNs and a live SIEM, then run an incident from alert to report.

8 modules 24 labs

Wireless, IoT & Private 5G Internship

Turn your Wireless Communication course into RF engineering you can defend — design, survey and secure a real Wi-Fi 6E network, then connect IoT sensors and a private-5G slice on top of it.

8 modules 24 labs

8 modules. 24 labs. One credit-mappable certificate.

Build it on real gear, defend a capstone, and walk into placements with proof.

Apply for Cloud & Network Automation Internship Compare all internships