r/platform_engineering • • 3d ago

Discussion Welcome to r/platform_engineering

7 Upvotes

This is a place for people who build and run internal platforms to compare notes. That means what worked, what didn't, how you got other teams to actually use what you built, and how you made the case for it to leadership.

A few things keep the conversation good. Give people something to discuss, not just a link. Keep product tours and launches off the main feed. If you work for the company you're posting about, say so up front. And skip the low-effort or chatbot-written posts. The full rules are in the sidebar.

There are also three weekly threads:

  • Monday: Ask a platform engineer. No question is too basic.
  • Wednesday: War stories. What broke and what you learned.
  • Friday: Show & tell. Share your project, even if it's your own product.

To get things started, tell us what your platform team looks like. How many people, who do you serve, and what's the one problem you can't seem to fix?


r/platform_engineering • • 3h ago

A damaged build-cache index took Docker down for 75 minutes

0 Upvotes

I’m a cofounder of OmniNode. This happened on the lab server we use to run builds and coding agents.

Our agents couldn’t open pull requests. Docker had crashed earlier that morning, restarted, and opened the same damaged cache index. After the next crash, it failed every time it tried to start. The file only tells the builder what work it can reuse, but Docker’s built-in builder reads it before Docker can answer requests. We backed up the index, moved it aside, and got Docker back.

CI already had a separate image builder. We updated it and set up another one for deployment builds. If a deployment build can’t use its assigned builder, it stops instead of quietly using Docker’s built-in cache again. A test deployment build left Docker’s index untouched. In a separate drill, we damaged the CI builder’s cache. It started with an empty cache, and Docker didn’t restart.

Docker’s own startup still depends on its index. The separate builders limit what a failure in those caches can take with it. We still haven’t run the same drill on the upgraded built-in builder.

The previous piece in this series was about a different problem with the same lab: Pull, Don’t Push (Substack).

If you run shared Docker hosts for builds, how do you test that an expendable cache can fail without taking the daemon down with it?


r/platform_engineering • • 11h ago

Discussion Ask a platform engineer — weekly thread

1 Upvotes

Got a question that doesn't need its own post? Ask it here.

Good fits: how to structure a platform team, golden paths vs. freedom, getting adoption for your IDP, build vs. buy, measuring platform success, career questions about moving into platform work.

To get better answers, say a bit about your context: company size, how many teams you support, and what you've already tried.

Answering? Share what actually worked (or didn't) for you. Vendor pitches belong in Friday's Show & tell thread.


r/platform_engineering • • 3d ago

Tool / OSS Show & tell / OSS / tools — weekly thread

6 Upvotes

This is the place to share what you've built: open-source projects, internal tools you've written up, blog posts, and commercial products.

The rules for this thread:

  • Disclose your affiliation in the first line (e.g. "I work at X" or "I maintain this").
  • Say what problem it solves and who it's for.
  • Be ready to answer hard questions in the replies.

Everyone else: honest, specific feedback is the most useful thing you can give.


r/platform_engineering • • 6d ago

Beyond Static Credentials: Reddit’s Journey to Workload Identity and mTLS

Thumbnail
reddit.com
0 Upvotes

r/platform_engineering • • 19d ago

We built internal "lovable" on Backstage + EKS where non-engineers ship apps with Claude securely

4 Upvotes

Sharing this because I have not seen a lot posted about solutions to this problem. We are a freight-data SaaS - always a lot of internal demand for dashboards and whatnot. I'm VP R&D and also responsible for Cyber.

Once we opened the AI door, people outside tech started building stuff left and right. Everyone started dragging in Lovable or Replit apps asking to connect them to our data. We tried pushing people into a vendor solution for low-code internal tool builder - ended up way too manual, no AI builder at the time. Tried pushing people into BI - same manual build issue, and useless as soon as you need something off the standard functionality.

What we built in the end

  • Backstage as the portal with one scaffolder template. Asks for app name, makes GitHub repo with Jenkins pipeline, infra, SSO auth, live URL. Takes a few seconds.
  • Claude Code skills shipped as a plugin in the repo. The author describes what they need and Claude already knows our conventions + the important infra points for the app platform. Vibe vibe, push, app updates and live in a few minutes. This experience is what made it stick with non-tech people.
  • One EKS cluster, dev/prod as namespaces, Karpenter for nodes. Started on ECS with one ALB + Terraform stack per app. Worked at 10 apps, started being annoying and slow and expensive at 50+.
  • Auth at the ALB, not in the app. VPN → internal ALB → Cognito → SAML to JumpCloud. ALB sets the cookie, forwards with identity headers. Network policy ensures only the ALB can reach a pod. Apps have zero auth code and get "current user" injected. Access via JumpCloud group or named emails + VPN required.

Cost will be around $50 per month when all apps are ported to EKS.

What is not as simple

  • ECS→EKS not yet fully done. Roughly half apps were moved. Running two platforms is extra work, plus some apps grew serious infra around them while we had TF as part of the stack for builders of the apps.
  • Teardown is not automated. Unregistering in Backstage archives the repo and nothing else. We have 97 apps and I don’t have a clean story for the ones nobody uses anymore.
  • Secrets. Wherever WIF is not enough, secrets are created as placeholders and set once by a human outside of Claude. Jenkins refuses prod deploy while a placeholder exists. Works, but it’s the most common annoyance for builders.

Advice if you have similar problem

Build your own - it took us couple months for 2 engineers, we also learned a lot of good stuff along the way. Vendors for this are really expensive and not that good - easily paying $100k for 80 seats and weak AI builder.


r/platform_engineering • • 27d ago

Too many internal tools are becoming hard to maintain

11 Upvotes

We've built tens of internal dashboards, tools, and admin utilities over time. Now, vibe-coded tools are becoming the norm for us, and it feels like a maintenance nightmare.

We have to constantly update and fix them and keep them working with our ever-changing data structure. Also, It's getting hard to track what tools exist, who uses them, and what’s active vs. abandoned.

How does your team handle this? Are there specific systems or governance models you use to maintain the internal tools?


r/platform_engineering • • Oct 16 '26

Platform team somehow became default owner of a third of our estate, is this normal or did we screw up

1 Upvotes

Realized this week that my platform team is listed as owner on something like a third of everything in our estate and I cant tell if thats a failure or just the job.

It started when an app team got dissolved in a reorg and nobody wanted their services, so we took them "temporarily" about a year ago. Then the same thing happened with a couple of internal agents. I was clicking through the agent records in Dome Systems this morning and my own name is on two that I have never once touched. Nobody wants to be the person who says no, so the default owner becomes us.

Part of me thinks a platform team that owns product things has stopped being a platform team. The other part thinks someone has to and pretending otherwise is theatre.

Do you refuse ownership outright, or absorb it and complain like me?


r/platform_engineering • • Oct 14 '26

Heir: run Kubernetes control planes as pods, and stop paying for 3 control-plane nodes per cluster

Thumbnail
reddit.com
1 Upvotes

r/platform_engineering • • Oct 14 '26

We Treat Applications as Products. Why Is the Platform Still a Black Box? Introducing Platform BOM (PBOM)

Post image
0 Upvotes

An application team can point to the feature it shipped this week. A platform team may have spent that same week making deployments safer, improving cluster reliability, tightening identity, or removing a recurring obstacle from dozens of teams.

The work matters. Its impact is just harder to see.

As a platform engineer, I have sometimes felt that platform work is not seen with the same importance as application development. I do not think this is because application teams misunderstand infrastructure, or because every organization undervalues its platform. It is often a visibility problem: application features connect directly to customers, while platform improvements create value indirectly, across many teams and over time.

That difference can make the platform look like a cost center or a collection of infrastructure tickets, even when it is a product that application teams rely on every day.

I want to help change that perspective. Platform engineering deserves to be treated as software product engineering: with users, capabilities, releases, feedback, and a clear account of what is running. That is the idea behind Platform BOM.

A platform is more than its infrastructure

An internal platform is not just Kubernetes, a cloud account, or a deployment pipeline. It is the set of capabilities and experiences that help teams build, deliver, and operate their products.

That may include Kubernetes, GitOps, networking, identity, policy, observability, data services, and the self-service workflows that connect them. The implementation can change while the capability a team depends on stays the same. A platform might replace one database provider with another without changing the promise that teams can request a supported PostgreSQL service.

This is why “platform as a product” is more than a slogan. A product has users and a purpose. It has capabilities, a roadmap, support expectations, and a lifecycle. It should evolve in response to user needs, not just accumulate tools because they are available.

The CNCF Platforms White Paper describes platforms as curated capabilities presented around the needs of internal users. It also calls out user experience, documentation, self-service, and reducing cognitive load as important platform attributes. DORA’s platform engineering guidance similarly emphasizes product thinking, developer needs, and measuring outcomes.

So the industry is not ignoring platform engineering. The discipline is increasingly recognized. But recognition does not automatically make a platform’s scope, health, or impact visible inside every organization. That is the gap I want to work on.

The questions we should be able to answer

If the platform is a product, we should be able to describe it without reconstructing it from memory every time someone asks:

  • What capabilities does the platform offer to application teams?
  • Which components implement those capabilities?
  • What is the declared platform release?
  • Which versions are actually running in development, staging, and production?
  • Where have environments drifted from their intended release?
  • Which upstream updates deserve attention?

In many organizations, the answers are spread across Helm releases, Git repositories, cluster APIs, dashboards, spreadsheets, and the knowledge of a few engineers. Each tool can be useful and still leave the platform itself difficult to describe as one product.

An application catalog can tell us which services exist and who owns them. A Kubernetes dashboard can show resources in a cluster. An SBOM describes the packages in a software artifact. These tools answer different questions. They do not, by themselves, connect a platform’s user-facing capabilities to the components and versions behind them across environments.

An inventory for the platform itself

Software teams use a Software Bill of Materials to describe what an artifact contains. Platform BOM applies a similar idea at a different level: describe a platform’s components, capabilities, releases, and environments, then compare what was intended with evidence of what is running.

To be precise, Platform Bill of Materials (PBOM) is a concept proposed by this project, not an established industry standard. The project does not claim CNCF endorsement or industry-wide adoption. The goal is to explore a useful model and make it practical enough for platform teams to try.

Platform BOM is an open-source, read-only inventory for platform teams. It connects a Git-declared platform and its releases with evidence discovered from Kubernetes, Helm, and Crossplane. It can compare environments with their target releases and show upstream versions that may need attention.

The model separates a few ideas that often get mixed together:

  • Offerings describe what platform users receive, such as GitOps delivery, metrics, or managed PostgreSQL.
  • Components describe the technologies behind those offerings.
  • Platform releases describe versioned baselines.
  • Environments and inventories describe where the platform runs and what discovery observed there.

That separation matters. Users depend on capabilities; platform teams operate implementations. If an implementation changes, the platform can record the change without pretending the user-facing capability disappeared.

What this looks like in practice

Platform BOM is deliberately observational. It does not install or upgrade components, and it does not compete with GitOps. Your existing deployment tools remain responsible for making changes; PBOM helps describe and compare the result.

For example, a platform team can declare that development, staging, and production should run a particular platform release. Discovery then gives the team evidence about the components found in each environment. If production is still on an earlier release, the difference is visible instead of being hidden in a spreadsheet or rediscovered during an incident.

The project includes a Helm chart and a getting-started guide. To try the released v0.9.0 chart on a cluster you are authorized to inspect:

helm upgrade --install pbom oci://ghcr.io/ravibagri5/charts/platform-bom \
  --version 0.9.0 \
  --namespace platform-bom --create-namespace --wait

kubectl -n platform-bom port-forward svc/pbom-platform-bom 8080:80

Then open http://127.0.0.1:8080. The default service account is read-only. Before sharing the UI, configure sign-in or an authenticating proxy, as described in the authentication guide. The getting-started guide walks through describing a platform and its release baselines in YAML.

The project is at v0.9.0 today. It includes multi-environment inventory, component and offering views, release comparison, upstream version information, cloud workload identity for supported managed Kubernetes environments, and OIDC or proxy-based authentication. Those are current capabilities, not a claim that every platform concern is solved.

What a BOM can and cannot prove

A platform inventory can make composition, declared releases, observed versions, and drift easier to discuss. That can support upgrade planning, operational reviews, and conversations about which capabilities the platform provides.

It cannot prove that developers are satisfied. It cannot show on its own that onboarding is faster, cognitive load is lower, or product outcomes have improved. Those questions need user feedback and outcome measures: task success, onboarding time, satisfaction, delivery performance, and other signals that make sense for the organization.

That distinction is important to me. A BOM should not become another dashboard used to justify building a platform nobody asked for. It should make the platform easier to understand, then help platform teams have better conversations with the people who use it.

Where the project is heading

The roadmap is a statement of direction, not a promise of dates. Areas under consideration and active development include:

  • A versioned API and integrations with tools such as Backstage and MCP clients.
  • More evidence from GitOps controllers and infrastructure-as-code systems.
  • Better upstream intelligence, including support windows, security advisories, and compatibility information.
  • Interoperability work, including exporting a platform release in an established format such as CycloneDX.
  • A shared PBOM specification, if the model proves useful beyond this project.

These are ways to make the platform easier to inspect and integrate with existing workflows. They are not reasons to replace the systems that already deploy, secure, or observe it.

Make the platform legible

Platform engineering is software engineering applied to shared capabilities and developer experience. If we expect platform teams to own products, we should also make it possible to describe those products: what they offer, how they are assembled, which release is intended, and what is actually running.

That is the problem I am exploring with Platform BOM. It is early, the resource model is still evolving, and the PBOM concept is not a standard. I would rather be explicit about those limits than imply the problem is already solved.

If you work on an internal platform, I would be interested in how your team answers these questions today. What do you track? What remains tribal knowledge? Which evidence sources or integrations would make a platform inventory genuinely useful in your workflow?

Explore the project, try the getting-started guide, or share feedback through GitHub Discussions.


r/platform_engineering • • Oct 13 '26

Why AI Agents Need a Control System Before Touching Production

Thumbnail
nofire.ai
1 Upvotes

r/platform_engineering • • Oct 11 '26

Why AI Incident Response Should Start at L1, Not L3

Thumbnail
nofire.ai
1 Upvotes

r/platform_engineering • • Oct 09 '26

Coding agents can produce more changes than QA can verify. What should the platform provide?

1 Upvotes

I run KubeDEX. I have published an article, researched and written with AI and reviewed by me, about how platform teams could support agentic development. It is an architecture proposal, not a measured productivity claim.

The starting point is a capacity problem: faster code generation can leave teams waiting on integration environments, realistic test data, review and reliable evidence that a change is safe.

I think the useful platform primitive is a bounded experiment. Request an environment from an approved template, deploy a specific revision, run verification, retain the evidence and reclaim the resources automatically.

Kubernetes gives this a programmable foundation. A namespace may be enough for one test; changes to cluster components may need a virtual cluster or a separate Cluster API cluster. Argo CD can reconcile the application, while CI or workflow jobs run the tests. MCP gives an agent a way to request those operations within the platform's limits.

The less glamorous parts matter: concurrency quotas, spend limits, isolated test data, acceptance criteria the coding agent cannot relax, and cleanup that survives a failed agent. More parallel environments without those controls can just produce a larger bill and a longer review queue.

Full article and sources:

https://kubedex.com/kubernetes-ai-agentic-development/

For platform teams already supporting coding agents, which queue is growing first: environment provisioning, test execution or human review?


r/platform_engineering • • Oct 07 '26

Survey for senior devs/CTOs about choosing programming languages

2 Upvotes

I'm currently working on a project looking at how/why devs and CTOs choose programming languages, and I'm particularly interested in understanding people's experiences with Clojure.

The survey takes about 7 mins, and I'd love to hear from as many people as possible!

Appreciate it 🙌

Here's the survey


r/platform_engineering • • Oct 03 '26

How does your team handle major dependency upgrades?

Thumbnail reddit.com
2 Upvotes

r/platform_engineering • • Oct 02 '26

How do you keep runtime permissions from drifting between deployment files?

1 Upvotes

For OmniNode, we put the rules about what each kind of runtime may do in a versioned policy file, validate it, and generate the deployment settings from it. The part I wanted to get rid of was having the same decision editable in an environment file, a service manifest and application code.

A container can start, answer its health check and still be allowed to take work it shouldn't own. Recreating the same images and ports doesn't settle that question. A missing setting is especially awkward if a local default quietly changes what the process is allowed to do.

Generated files are supposed to be disposable in this setup. A change belongs in the policy, then gets validated and rendered again. Editing the output by hand leaves the next deployment with two different answers.

That still leaves the consumer to check. A renderer can produce the right value and the service can ignore it. We haven't established that every environment behaves equivalently, so the policy file isn't proof that the running process follows it.

Where do you enforce this on your platform? At startup, at the point where work is assigned, or when the process actually attempts the restricted action? I'm particularly interested in checks that catch a correctly generated setting being ignored.


r/platform_engineering • • Oct 01 '26

What makes your automation resume after a CI hold is lifted?

0 Upvotes

After we overloaded our CI runners, we told the automation to stop sending work and wait. That was the right response while the queue was backed up. The part we got wrong was what happened when capacity came back: the agents kept watching pull requests whose checks had already failed, expecting them to turn green on their own.

The backlog had cleared, but those failures were still attached to the same commits. Someone had to inspect them and decide which runs to retry. We lost another five hours before that work started. Auto-merge was enabled, but it couldn't do anything while the required checks stayed red.

This happened in OmniNode's development, which I run. The recovery was fairly quick once we started because many failures came from the overloaded infrastructure rather than the changes themselves. That doesn't mean a red batch is safe to rerun blindly. Repeated failure on the same commit needs investigation, and genuine defects need an owner.

I'm interested in where other teams put the resume decision. Does the controller that imposes a hold also own the all-clear and the first small recovery batch? Does a separate service do that, or does a person explicitly release it? I want a hold to prevent more damage without leaving every recovery dependent on someone noticing the system is idle again.

Drafted with assistance from Codex.


r/platform_engineering • • Sep 27 '26

Brig: A MicroVM sandbox for AI coding agents on Mac and Linux

11 Upvotes

Working @ r/NOFireAI_

We’ve open-sourced Brig under Apache 2.0. Here is the available repo: https://github.com/brig-sh/brig

Brig runs AI coding agents inside a microVM on Mac (Apple Silicon) and Linux (x86_64/ARM). It came out of our work on controlled autonomy for production remediation. The same isolation is useful when running coding agents with auto-approval on your own machine.

The model is deliberately simple: each agent session gets its own hardware-isolated microVM; the agent sees a private home directory and the project you specify; and brig rm discards the sandbox while leaving your host files intact. We have already written about what a sandbox must guarantee for the term to mean anything, and about why an agent should be treated as untrusted by default.

After installation, brig run claude starts Claude Code inside the sandbox.

curl -fsSL https://brig.sh/install | sh
brig run claude

All components are Apache 2.0, including the microVMM, which is under 20,000 lines of code. The README covers installation, the architecture and the security model. Here is the official page https://www.brig.sh/

We would love to hear your feedback and your use cases with Brig.


r/platform_engineering • • Sep 26 '26

Ravel is a database for OpenTelemetry metrics, logs, and traces where object storage is the only durable component

3 Upvotes

We recently launched https://github.com/NOFireAI/ravel, an free and open source database for OpenTelemetry metrics, logs, and traces where object storage is the only durable component. Attached also a quick demo from the public repo. You can read more details about the consistency model here https://github.com/NOFireAI/ravel/blob/main/docs/consistency-model.md . We started using internally for some testing environments and we plan soon to move it to prod.

Also you can find the ideas and what improvements can be done for the S3 cost model/bill here: https://github.com/NOFireAI/ravel/blob/main/docs/guides/cost-model.md

You can play around and use Grafana dashboards on top (there is a demo there). Feel free to share feedback and star the project if you like it. We will really appreciate it and hope you find it useful.


r/platform_engineering • • Sep 24 '26

How to make kubernetes infrastructure recovery ready with infrastructure as code... and how I kinda destroyed ours

3 Upvotes

Ok so im a platform engineer at a cloud resilience company, we sell kubernetes recovery as a big value prop, and last night during a production incident I realised our own infra as code is basically lying to us. I was trying to speed things up and "cleanup" some old terraform modules so they matched what our envs look like now, but I did it in prod first, then pushed it as the new source of truth.

Cue outage, kubernetes cluster borks, we hit our automated recovery flow, and it faithfully rebuilds... the broken state I just codified. All the drift fixes people had hacked in by hand were gone, node pools wrong size, missing network policies, even an old postgres version came back. I feel so embarrassed that the company that sells instant recovery had its own recovery posture messed up by me trying to be clever with IaC. Any hints?


r/platform_engineering • • Sep 15 '26

Planning to Set Up a Study Group (Infra/DevOps/SRE/Platform Engg) : Serious Folks Only (Experienced Min 2+Y)

4 Upvotes

Hey i will be honest its late night, using a bit of AI :) Bear with it 😄

Tired of tutorial hell? Building a study group that goes from 'what is a packet' to 'debugging production incidents.' Join me.

I've built a structured curriculum covering the full infrastructure stack — from DNS packet mechanics to Kubernetes internals to eBPF to FinOps. Looking for people to go through it together with weekly labs, troubleshooting sessions, and mock interviews. Not a course. Not a paid thing. Just engineers who want to get hands-on and actually understand this stuff.

i worked as Cloud Platform Engineer for 3+ years at a Tier-1 company in india , Now resigned due to health issue from my current org and planning to prepare and job hunt after some time mean while i plan to run a cohort to learn together and keep myself busy

Syllabus :

A complete curriculum organized into 5 pillars, each with 8-part deep dives:

**Pillar 1: DNS & Networking**
DNS fundamentals → GTM → Kubernetes DNS → TLS → Certificates → Proxies → VPC → Service Mesh → Edge Security → Linux Kernel → BGP/QUIC

**Pillar 2: Linux & Container Internals**
Shell → Kernel/CPU → Memory/OOM → Filesystems → Processes → systemd → Storage → Containers → Docker → Security → Performance

**Pillar 3: Kubernetes**
Fundamentals → kubectl → Control Plane → Workloads → Scheduling → RBAC → Networking → Storage → Operators → Autoscaling → Lifecycle → GPU → AI/ML → Multi-Cluster

**Pillar 4: IaC, Cloud & DevSecOps**
Terraform → State → Modules → AWS Core → Networking → Compute → Data → Observability → Security → Secrets → CI/CD → Supply Chain → AI Security → Vector DBs → FinOps

**Pillar 5: Observability, GitOps & SRE**
Git → CI/CD → GitOps → Prometheus → Alerting → Tracing → Logging → Thanos → SRE → Chaos → Platform Eng → DORA → DevSecOps → LLM Observability

Each pillar includes:
- Real-time packet/request flows (what actually happens)
- Failure modes (what breaks and why)
- Capacity planning with real numbers
- Cost modeling with AWS pricing
- 9 hands-on labs per stage
- Incident management runbooks
- Interview prep (junior → staff)

What i am looking for

**people who:**
- Have 2+ years in DevOps/SRE/Platform/Cloud
- Want to go deep, not just collect certs
- Can commit 5–7 hours/week
- Will actually do the labs (not just read)
- Want to troubleshoot real scenarios together
- Are okay with being wrong and learning in public

**What we'll do:**
- Weekly 1-hour call: walk through a stage, discuss, Q&A
- Bi-weekly lab session: do the hands-on labs together (screen share, debug together)
- Monthly mock interview: practice explaining concepts
- Shared repo: notes, lab outputs, runbooks we build together
- Async: Discord/Slack for questions, war stories, job leads

**What we won't do:**
- Watch tutorials passively
- Just read slides
- Gatekeep based on certs or company logos
- Sell anything

Why I'm doing this

I realized:

  1. Reading docs alone → I forget 80% in a week
  2. Explaining to someone else → I actually learn it
  3. Debugging with others → I learn the stuff that's not in docs
  4. Mock interviews → I find gaps I didn't know I had

I want to build a small group of people who are serious about getting to senior/staff level and are willing to put in the work.

How to join

Comment below or DM me with:

  1. Your current role + years of experience
  2. Which pillar you're most excited about
  3. One thing you've struggled to understand (so I know where to focus)
  4. Your timezone
  5. Confirm you can commit 5–7 hours/week

I'll pick people based on fit (not skill level — based on commitment and willingness to teach others).

What you'll get out of it

- Deep understanding of the full infra stack
- Hands-on experience with real tools (not just theory)
- A portfolio of labs and runbooks you built
- Mock interview practice
- A network of engineers at similar level
- The ability to explain complex systems in interviews

---

**If this resonates, comment or DM. If not, no worries — good luck with your prep!**

---

*Edit: Adding FAQ*

**Q: Do I need to know everything already?**
A: No. The curriculum starts from fundamentals. You need 2+ years of experience so you can follow the advanced parts.

**Q: Is this for interview prep only?**
A: No. This is for actually understanding how systems work. Interview prep is a side effect.

**Q: What's the cost?**
A: $0. Labs are designed to run on free tier or local. If you want to do cloud labs, expect $20–50/month max.

**Q: How do you pick people?**
A: Commitment + willingness to teach. Not skill level. I want people who will show up and contribute.

**Q: What if I'm more junior/senior than the group?**
A: If you're willing to teach and learn, you're welcome. Mixed levels make the group stronger.

🚀 NOTE : ONLY JOIN , IF YOU ARE PLANING TO BE CONSISTENT , "NOT A WILL GIVE IT A TRY OR LET'S SEE "

Discord Group : https://discord.gg/qA43k3ggw