A path, not a bootcamp
A 12-week path to a DevOps or SRE job in Canada.
You read a manual written at principal engineer depth.
You execute 33 production-shaped tickets in real cloud environments.
AWS, Azure, and GCP — all three, not just one.
120 interview questions drilled at three seniority levels.
Two live group sessions every week.
Personal resume rebuild with Rohith.
Day before each real interview: a tailored mock, one-on-one.
Price
$1,500 CAD — one-time, everything included
Access
6 months of full access from your start date
Support
Continues free until you land an offer
Guarantee
Complete and not ready → rejoin the next cohort free
Inspect the work
Read the actual material before you decide.
Three real artifacts from the program.
One chapter from the manual.
One ticket you'd execute.
One interview question with answers at three levels.
Artifact 1 of 3 — A chapter from the manual
Sharding the Ledger
Data Stores · Scalability
One-line definition
Splitting account and transaction data across multiple database nodes so no single node holds more than its capacity, while preserving the invariant that every debit has a matching credit.
What it does
Partitions ledger data so each Postgres node holds a known subset of accounts.
Routes every read and write to the correct shard via a deterministic shard map.
Coordinates cross-shard transfers without using two-phase commit.
Failure shapes (excerpt — full chapter has 7)
F1 — Hot shard from a celebrity tenant
One shard's QPS is 5–40× the median. That shard's p99 query latency rises above 100ms. Remaining shards continue at normal load.
F4 — Monotonic key hot tail
Writes concentrate on the lexicographically last shard because account IDs are monotonically increasing. That one shard runs at 100% write IO while peers run at 5%.
The full chapter has 11 sections: detection signatures, runbooks, traps to avoid. Every chapter follows this shape — 88 chapters across 11 layers and 8 concerns.
Artifact 2 of 3 — A ticket you'd execute
VIRO-T05 — Walk through CI/CD for payment-service
Walk-through · 2–3 hrs
Objective
Understand and document how payment-service deployment works end to end.
Prove understanding by writing it back in your own words.
Deliverables (in your fork at docs/ticket-05.md)
Architecture diagram of the pipeline — hand-drawn or Excalidraw.
Step-by-step: PR opened → image in production. Every step named.
Every secret used and where it is stored.
Three concrete failure modes if image-scanning were removed.
One improvement you'd make — and the tradeoff it introduces.
Acceptance criteria
All 5 deliverables present.
Failure modes are specific — not "things would break".
Improvement names a concrete tradeoff — not just "more tests".
Submitted as a GitHub Issue using the walk-through template.
Artifact 3 of 3 — Interview question, three levels of answers
Question 47 — System Design
Module 4 · Services
"Walk me through how you'd design a multi-region active-active Postgres setup. Scale is 100K writes per second at peak."
Junior answer
"I'd set up Postgres in two regions with replication between them. Use a load balancer to route traffic. If one region goes down, the other takes over. We'd need to handle conflicts somehow."
Senior answer
"For active-active across regions you have to pick a conflict resolution strategy — last-write-wins, CRDTs, or application-level reconciliation. Streaming replication doesn't give you active-active. You need logical replication with conflict handlers (BDR, pglogical) or application-sharded routing where each region owns specific account ranges. At 100K writes/sec sustained, we're past what a single Postgres primary can handle even in one region."
Principal answer
"Active-active Postgres at 100K writes/sec is fighting the tool. Before I design it, I want to understand what you're actually trying to achieve — because the right answer is probably not active-active Postgres.
When the goal is regional latency: you want sharded writes with regional affinity.
When the goal is RPO=0 disaster recovery: you want synchronous replication to a hot standby.
When the goal is global consistency at this scale: you want Spanner, CockroachDB, or YugabyteDB. They were built for this.
What is the underlying constraint — let me show you why active-active Postgres is the wrong primitive for it."
The manual covers 120 questions like this with answers at three levels. You internalize the patterns — you don't memorize the answers.
What you'll build
33 tickets. One complete service. End to end.
Walk-throughs: study real code, write back understanding.
Builds: fork repos, ship your own service.
Incidents: we inject failures, you diagnose and fix live.
Each ticket maps to specific manual chapters.
Phase 1
Foundation
Get access. Verify your environment.
T01Set up your local environment — kubectl, helm, terraform, cloud CLIs
T02Walk through the four-repo architecture and how they connect
T03Get cluster read access and verify by listing pods in the reference namespace
Phase 2
Platform — study how it's wired
Walk through cluster, CI/CD, GitOps, secrets, networking, observability, IAM, Postgres.
T04Walk through how the cluster is provisioned with Terraform
T05Walk through CI/CD for payment-service, end to end
T06Walk through Helm + Kustomize + ArgoCD interaction
T07Walk through how secrets are managed and rotated
T08Walk through cluster IAM and pod-level RBAC
T09Walk through networking — ingress, NetworkPolicies, DNS
T10Walk through how Postgres is provisioned, backed up, and recovered
T11Walk through observability — metrics, logs, traces, alerts
Phase 3
Build a service
Fork. Scaffold. Containerize. Ship to the registry. Deploy to your namespace.
T12Fork viro-services and viro-tooling. Add a new service to your fork.
T13Containerize your service with a multi-stage Dockerfile
T14Configure CI: lint, test, build, scan, sign, push to registry
T15Write a Helm chart for your service in your viro-tooling fork
T16Add ArgoCD application manifest and watch your service deploy
Phase 4
Persistence and state
Provision a database. Connect it. Manage secrets properly.
T17Provision your own RDS Postgres in your AWS Free Tier with Terraform
T18Connect your service to your database, run a migration
T19Manage database credentials via External Secrets, not env vars
Phase 5
Make it production-shaped
Health checks. Graceful shutdown. Observability. Scaling.
T20Implement liveness, readiness, startup probes correctly
T21Add Prometheus instrumentation with the standard RED metrics
T22Build a Grafana dashboard showing your service's health
T23Configure HPA, run k6 load against your service, watch it scale
Phase 6
Safe, cost-aware, and auditable
The senior-level work that separates you from a junior.
T24Add NetworkPolicy and ServiceAccount with least-privilege IAM
T25Define SLOs and configure SLO-based alerting rules
T26Add timeout, retry with backoff, and circuit breaker for downstream calls
T27Implement idempotency for critical writes
T28Right-size your service using AWS Cost Explorer; justify resource requests with data
T29Write a runbook — investigation steps, failure modes, recovery
T30Configure audit logging and demonstrate a "who accessed what" query
Phase 7
Survive incidents
Real failures injected during live sessions. Diagnose. Fix. Postmortem.
T31INCIDENT — pod evictions in your namespace under memory pressure
T32INCIDENT — downstream service starts failing, your service cascades
Phase 8
Multi-cloud capstone
Prove your service is portable across cloud providers.
T33Port your service to Azure (AKS) or GCP (GKE) and document the deltas
At graduation: 33 production-shaped tickets shipped across three real cloud environments.
Your GitHub history is the proof. Inspectable by any hiring manager.
The repos
Three repos. Same separation real teams use.
Services build into container images.
Infrastructure provisions clusters.
GitOps tooling deploys images into clusters.
You fork two. You read one.
yarova/viro-services
YOU FORK THISApplication source code for four sample services.
Dockerfiles and CI workflows included.
CI builds and pushes container images to the registry.
yarova/viro-infra
YOU READ THISTerraform modules for EKS, AKS, GKE, RDS, networking, IAM.
Bootstrap scripts included.
You study this and write back understanding as your ticket deliverable.
yarova/viro-tooling
YOU FORK THISHelm charts, Kustomize overlays, ArgoCD applications.
NetworkPolicies and observability configs included.
ArgoCD watches this repo as the source of truth for what is deployed.
Tickets are GitHub Issues opened from templates in your forks. Your closed issues become your visible portfolio.
How it actually works
Ten stages. Discovery to Day 90.
Every stage is structured. You always know where you are and what comes next.
Discovery call
30 minutes with Rohith.
We talk: your background, your timeline, your goals.
When yes: you proceed to enrollment.
When not yet: you get specific feedback on what to build first.
Enrollment + welcome bundle
$1,500 paid via Stripe.
Within minutes: one WhatsApp message with everything.
Manual access, GitHub team invite, kubeconfig script, session calendar, support number.
Read the manual
First pass: fast skim to learn the territory.
Second pass: deep reading by module.
Third pass: compression before interviews.
The book is the foundation. Everything else builds on it.
Weekly group sessions
Two sessions per week, same time every week.
Rohith walks through manual chapters live.
Lab walkthroughs of the reference setup.
Live mock-interview pressure blocks.
Set up, fork, ship
Set up local environment and free-tier cloud accounts.
Fork viro-services and viro-tooling.
Execute 33 tickets across 8 phases.
Your GitHub history becomes a real, inspectable portfolio.
Resume + LinkedIn
60-minute one-on-one with Rohith when you're ready.
Resume rebuilt to be ATS-friendly and pass the 7-second recruiter scan.
LinkedIn rewritten with the same lens.
Portfolio page goes live.
Pre-interview prep
Every real interview you book: connect the day before.
Tailored 60-minute mock matched to that specific company.
When calendar is full: WhatsApp directly — always accommodated.
Offer + negotiation
You get an offer. Share it on WhatsApp.
We go through it together: compensation, equity, start date.
We celebrate.
Day 1 in your new role
Free 30-minute prep call before you start.
What to expect in your first week.
WhatsApp check-in on Day 1 itself.
Day 90 follow-up
Free 60-minute call at three months in.
Help with anything that is hard.
Honest feedback on what Viro should have prepared you better for.
The loop closes.
Who this is for
Three honest profiles.
About 70% of applicants fit one of three profiles. The rest have requirements the program can't address — that's what the discovery call is for.
In Canada and the runway is short.
Already here. Time to land a technical role is shorter than you'd like.
Generic certificates are not moving the needle.
You need a structured path that produces inspectable artifacts on your GitHub.
Switching into IT from a non-technical career.
Your degree or current role is not in tech.
You want into DevOps or SRE specifically.
You've watched enough YouTube to know structure beats more videos.
You need someone who has shipped at scale to walk you through the reality.
Already in IT, going senior.
Junior engineer, sysadmin, QA, or developer.
You want to specialize at senior level: cloud, Kubernetes, observability, on-call.
You want depth, not breadth.
You want someone who has interviewed at this level.
Pricing
$1,500 CAD. One-time. Everything included.
Price
$1,500 CAD — one-time payment via Stripe
Tiers
None — one price, everyone gets the same program
Upsells
None — mock interviews, resume work, Day 90 call all included
Access
6 months from your start date
Support
Continues free until you land an offer
Complete the program and don't feel ready → rejoin the next cohort free.
Your readiness is the goal. Not the timeline.
The promise
Read the manual.
Attend the sessions.
Do the tickets.
Do these fully — and your understanding of DevOps and SRE will exceed most working engineers.
You'll be ready for any real interview.
You'll be ready for any real on-call rotation.
You'll be ready for any real production-grade problem.
Not because you memorized answers — because you internalized the patterns.
About
Built personally by Rohith Yadla.
Solutions Architect.
Deep experience across ETL, data warehousing, databases, DevOps, SRE, and cloud architecture.
Years of production work on systems handling real money, real traffic, real on-call rotations.
Viro is the program. Yarova is the company that builds and runs it.
Both based in Langley, British Columbia.
The manual, the repos, the cluster, the program — all built personally.
Questions
The questions you're probably asking.
My Cal.com is full and I have an interview tomorrow.
WhatsApp directly.
Pre-interview mocks are the highest priority on the schedule.
Always accommodated.
When should I start the program?
When arriving in Canada: start 6 months before arrival.
Use that time to read deeply and build artifacts. Arrive ready to interview.
When switching careers: start 6 months before you want to be applying.
The program is 12 weeks. The job hunt adds 4–8 more.
What if I'm stuck on a ticket?
Post in the cohort group chat first — someone often answers within minutes.
WhatsApp Rohith for things only he can answer.
Urgent before-interview help is always immediate.
What if I miss a group session?
Sessions recur at the same times every week.
The next is always 3–4 days away.
What if the cluster is down during a session?
The cluster spins up before each session.
When provisioning fails: troubleshooting happens live — that is its own learning.
Browser-based labs (Killercoda, LocalStack) are always available as backup.
What if I fall behind?
12 weeks is the recommended pace.
The 6-month access window covers students who go at half pace.
When everything is complete but readiness is not there: rejoin the next cohort free.
What if I fail an interview after we did a mock?
Debrief on WhatsApp.
Find exactly what broke down: technical depth, system design, behavioral, the closing.
Fix that before the next interview.
What if I don't have a programming background?
DevOps and SRE require basic programming literacy: reading scripts, modifying YAML, writing small tools.
The discovery call assesses this.
When the baseline is not there yet: you get specific things to build first and a welcome back when ready.
Do I need my own AWS, Azure, or GCP account?
Yes — your own free-tier accounts on all three clouds.
Setup is part of the foundation tickets.
The shared cluster runs in our infrastructure.
Your registry, database, and cloud-native services run in your accounts.
You've inspected the work.
Next is a 30-minute call.
We talk about where you are, what you need, and whether Viro is the right fit.
When fit: you proceed to enrollment.
When not fit: you get a clear path forward.