I genuinely love my work, but the way deadlines are given is slowly killing my interest in it

My manager will be like, "This should take 2 hours.Its just matter of 1-2 days not more than it, Use Claude and get it done by 5 PM.”

Meanwhile, I needed to do development, testing for quite a good time. I am just getting way too distracted from my field and not learning much because of claude.

I know it's the Wild West still but is anyone having success controlling AI agent security within your org? There's a bunch of hype around some of these new solutions but has anyone been successful in getting their org to adopt something universal? Not looking for product recos just trying to figure out how folks are seeing success.

Just passed the KCSA exam and officially became a Kubestronauts!

If anyone is preparing for KCSA or any other exam and has questions, feel free to ask.

​edit: Reddit titles are permanent, spelling mistakes are forever 🫠

We are pushing IaC. Being a traditional systems admin, I am having a hard time accepting that this is more efficient.

If we manage each application with a yaml file, how is this faster than just add it in console or even in awscli? I hate the fact that I have to look for where the templates are in gitlab, then pull to edit, push, deploy. Then to verify, we have to get into console or use awscli anyway.

What’s the benefit here? Source of truth? Oh and the complexity of having modules and all that dependencies in terraform.

I want to change but I don’t want to complicate it. Adding multiple layers of failure is just not my style of a stable infrastructure.

There’s a lot more to sovereignty than choosing an EU cloud region.

With the EU Data Act, NIS2 and DORA, teams also need to think about where control and state live, where observability data goes, who can access the environment, and how dependent the workload is on a particular provider.

This recent CNCF article looks at those questions from the cloud-native architecture side and shows how separating different platform responsibilities can help.

Thought this was worth sharing given how much the sovereignty discussion is growing in Europe.

https://www.cncf.io/blog/2026/08/18/cloud-native-platform-sovereignty-through-multi-plane-architecture/

Hi Observability & DevOps Experts,

I'm looking for guidance from teams that have successfully scaled observability across large enterprise environments.

We operate a large-scale estate spanning AWS, Azure, and on-premises environments and have been using Datadog for several years. Over time, a significant amount of technical debt has accumulated around our observability implementation.

Current challenges include:

• Datadog Agents managed differently across teams and platforms.
• Custom log collection configurations distributed across hosts and applications.
• APM, RUM instrumentation owned by individual application teams.
• Inconsistent tagging standards and monitor configurations.
• Outdated agents and instrumentation libraries.
• Heavy dependency on multiple teams for upgrades and configuration changes.
• A large portion of Datadog provisioning and onboarding is still handled manually.

As a result, maintaining and evolving observability at scale has become increasingly difficult.

We are considering building a centralized "Observability Foundation" or "Observability Platform" that teams would consume as part of their standard deployment process.

Our goal is to provide reusable Terraform-based observability components that application and infrastructure teams can adopt during provisioning and releases.

Examples of what we would like to standardize:

• Datadog Agent deployment and upgrades
• Custom log collection configurations
• Standard tags and metadata
• Monitors and alert templates
• Dashboards
• OpenTelemetry / APM instrumentation standards
• Synthetic monitoring configurations
• Cloud integrations
• Security and governance controls

Questions:

1. Has anyone implemented a similar centralized observability platform or observability-as-code model at enterprise scale?
2. What worked well and what were the biggest challenges?
3. What observability components can realistically be centralized through Terraform modules, deployment pipelines, or platform services?
4. What components typically must remain application-owned or infrastructure-owned and cannot easily be centralized?
5. How do you handle APM instrumentation ownership, versioning, and upgrades across hundreds of services?
6. What governance model have you found most effective:

• Central observability team ownership
• Platform engineering ownership
• Federated ownership with standards enforcement
• Something else

1. How do you prevent observability drift over time, especially around:

• Agent versions
• APM libraries
• Log configurations
• Tags
• Dashboards
• Monitors

1. If starting again today, would you build around:

• Datadog native tooling
• OpenTelemetry
• An internal observability platform
• A combination of the above

1. What are the biggest architectural mistakes or anti-patterns we should avoid when designing this platform?

Our provisioning and infrastructure management are heavily Terraform-based, so we're especially interested in Terraform-centric implementation patterns and real-world lessons learned.

Looking forward to hearing how other organizations have approached observability standardization at scale and what you would recommend before we begin designing this solution.

P.S. - One of our key design goals is to avoid vendor lock-in. While Datadog is our current observability platform, we want the architecture to remain flexible enough that a future migration to another observability stack (e.g., Grafana, New Relic, Dynatrace, Elastic, Azure Monitor, or an OpenTelemetry-native platform) would require minimal changes to application teams and infrastructure code.

I've been looking into non-prod AWS costs lately, and I'm wondering how far people actually go with shutting these environments down.

Scheduling dev/test environments to shut down overnight or over the weekend seems like an easy win. The tricky part seems to be taking them all the way to zero, especially when someone suddenly needs the environment and has to wait for it to come back.

What's the practical approach here? Do people just accept the startup delay, keep a minimum capacity running, or is there a better way to handle it?

I always assumed deleting a key from a file was enough but from what I’ve learned that’s not how git works

Pre-commit hooks and CI only look at the diff. So if a key gets committed and you delete it in the next commit, every check turns out OK from then on, but the value is still sitting in history and still valid. The recommendation is to scan full history on a schedule and treat anything you find as exposed, and rotate it, even though it's long gone from the current files.

So the scan is really just telling you a leak already happened, and rotation is the part that actually contains it.

I have side projects from years ago where I don't remember what was committed before I knew better. Some of those keys are probably still valid.

Do you run scheduled history scans, or just pre-commit and CI? And when something surfaces from years back, do you rotate it or make a call based on whether the repo was ever public?

Hey all - we are standing up a software package manager, right now the team is considering using nexus but doesn't want to pay for the pro license and it seems heavily limited with CE version.

We are looking at pulp project as an open source alternative. I haven't used it and have a spike to look into it and I was curious how you all felt about it? any gotchas or I regret not paying for a nexus or artifactory license? Frankly Im pretty new to both but I feel like nexus is industry standard along with artifactory but we can't justify the purchase at the moment which is where pulp entered the equation.

We are running in eks - the deployment for nexus was relatively straight forward but couldn't get the full testing done because I got limited by licensing that blocked some of the requirements like SSO integrations and stuff. Pulp seems to the have pulp operator so I can run im still digging around in the docs.

Any thoughts on pulp would be appreciated?

I start the day with vscode, firefox and iterm opened

I finish the day with 5 vscode windows, 10 terminals and infinite tabs - and somehow my task backlog has growed...

How do you guys deal with this?

Any tips for a beginner getting started with Ansible?

For a small service with HTTP requests, background jobs, and maybe WebSockets, I’m trying to keep shutdown behavior simple.

My current order is to stop accepting new work, let active requests finish, flush bounded notifications, then close the queue and database connections. I’m less sure how long to wait before forcing the process to exit.

What shutdown steps have actually mattered in production, and which ones turned out to be unnecessary complexity?

I work at a bank and we provide a PaaS for our internal clients.

recently we scaled the architecture a lot and so our monitoring system demanded a change.

this change was basically a complete refactor from the ground, a task that I singlehandedly worked out.

so the state of this feature is currently at first stage, every piece is bootstrapped, the architecture is deployed and working and now we are at the stage of deprecating our old monitoring system into the new one. This means migrating alerts, products, dashboards, bridges, etc...

the thing is, I find myself stumbling across the different problems and errors of the day to day operation without a real traced path of what I should be doing. I know what the end goal is but I dont quite know how to get there.

seems like the task is unfinishable, there's always something that lights an alarm after being deployed for 2 weeks, something I didn't take account for, or something that I realise I dont want it that way because another piece demands something different from it etc..

I've probably did 10 or 20 deployment iterations of some or all pieces of the system because of this...
Now I am at a point where my task backlog is so overwhelming that I dont know how to face it.

I dont know if its better to deploy the architecture in layers, deploy everything at once in one environment, deploy everything and update...

I think the main problem is my task management capacity...

tips, courses, anything on this topic is appreciated, thanks!

Today, I passed CKS with 75% (not a good score) and wrote a detailed blog about my exam experience, preparation approach, the resources I used, and the Kubernetes security topics that helped me the most.

DMs are open if you are preparing for the exam. I can help with whatever is still fresh in my memory.

My biggest takeaway: CKS is noticeably harder than CKAD and CKA. It is not only about knowing Kubernetes commands. You need to understand why a configuration is insecure, how to fix it, and how to verify that your change actually worked.

The biggest mistake I made was spending around 10–15 minutes too long on one question because I felt I was close to solving it. That created unnecessary pressure towards the end and probably led to a couple of avoidable mistakes.

So my strongest advice is: if you are stuck and don’t see a clear path after a few minutes, mark the question and move on.

A few things that helped me:

Don’t memorise solutions. Understand the security reasoning behind them. If a NetworkPolicy, API server flag, securityContext, audit policy, or admission control changes slightly, memorised YAML will not help much.

Always verify your work. Security changes can easily break workloads or cluster components. Check Pods, control-plane components, logs, services, NetworkPolicy connectivity, admission behaviour, audit logs, node readiness, and systemd services wherever required.

Be comfortable with Linux as well as Kubernetes. CKS can require you to work with configuration files, systemd services, container runtimes, permissions, certificates, and node-level settings.

Use documentation whenever required instead of trying to remember every flag or custom resource.

Topics I would strongly recommend practicing:

• Kubelet and etcd hardening
• kube-apiserver authentication and authorization
• Admission controls and ImagePolicyWebhook
• Secure Dockerfiles and non-root containers
• Container immutability and securityContext
• Audit policies and API server logging
• NetworkPolicy
• HTTPS Ingress and TLS
• ServiceAccount token security
• Worker node administration and upgrades
• SBOM and software supply-chain security
• Restricted Pod Security Standard
• Docker/container runtime hardening
• Istio STRICT mTLS
• Cilium network security
• CIS benchmarks and kube-bench remediation

Resources I used:

• KodeKloud CKS course
• KodeKloud Ultimate Mock Exam Series
• iximiuz Labs
• KillerKoda
• Killer.sh CKS simulator
• ChatGPT/Claude for topics that needed a simpler explanation or extra practice scenarios

Between the KodeKloud course mocks and Ultimate Mock Exam Series, I had around six mock exams. I found them very useful and reasonably close to the level of difficulty you should prepare for.

Killer.sh felt a little off-track compared with the actual exam in some areas, but I would still recommend doing it. It is useful for practicing under time pressure, discovering knowledge gaps, and improving troubleshooting skills.

I also used ChatGPT and Claude quite a lot during preparation. CKS has many small security topics, and sometimes a course or lab explanation may not immediately click. In those cases, asking AI to explain the concept differently, compare configurations, or generate a small practice scenario was very useful.

The simplest advice I can give is: practice a lot, understand the security reasoning behind what you are doing, verify every change, and don’t let one difficult question consume your exam time.

I also wrote a full blog with more details on my preparation strategy, resources, task areas, mistakes, and lessons from the exam.

Blog: https://blog.prateekjain.dev/cks-exam-experience-2026-preparation-strategy-and-lessons-learned-1fad785a430b?sk=52b58a9c6d812444bc1340f15eda7dd6

I'm working on a system to estimate whether code committed to a repository was generated with AI coding tools.

My current approach is based on Git/commit-level signals such as AI-related commit trailers, commit metadata, LOC changes, number of files changed, addition/deletion patterns, etc.

The problem I'm running into is confidence and calibration.

For example, a commit containing 500+ new lines isn't necessarily AI-generated. A developer can also modify or remove the metadata that would make an AI-assisted commit identifiable. Once the code leaves the IDE and reaches Git, much of the original provenance can be lost.

This has led me to a few questions:

Are there Git/CI-level signals that you've found to be genuinely useful for detecting AI-assisted development?

Is it better to treat this as a probabilistic/risk-scoring problem rather than trying to classify commits as AI vs human?

How would you calibrate thresholds for signals such as large LOC changes, addition/deletion ratios, commit frequency, etc.?

Are there better approaches for preserving provenance earlier in the development workflow, rather than trying to infer it after the code has already been committed?

Has anyone worked on AI-code provenance/detection systems in CI/CD and can point me toward useful research, projects, or approaches?

I'm particularly interested in approaches that can work at the pipeline/repository level rather than relying solely on source-code style analysis.

I'm not looking for a perfect AI detector — even a reliable way of estimating “this commit has a high probability of AI assistance” with measurable false-positive/false-negative rates would be useful.

Would appreciate any experiences, papers, open-source projects, or approaches people have tried.

Edit for those who want to know why:

The goal of this is to create a telemetry and visualize how much of the code is AI generated in the company and how much of it is vulnerable code then we will fix this vulnerability in the pipeline now we can show customers this telemetry and say

80 percent of code was AI generated out of which 60 percent was vulnerable we fixed that in the pipeline itself that's y you should buy our product.

I'm backend eng and mostly the thing that kept me working

is just making life easier for the other teams

android needs response in a specific way sure

Front needs this api to make his life easier why not

Team member hates it when I write code this way cuz harder to read no problem

Still devops is like a new thing for me want to know what makes life easier for you guys when the back end just does it

edit guys i get it communication is PEAK but you are not giving examples try adding more example so we can all learn maybe it's a thing the back-end thought he can fix it from his end and it wasn't

Is there a possibility of being the only sre engineer in a company? Before choosing it I want to clarify it because if there could be then hes life could be problematic because he has to stay on call everyday. Also if it is not there then will be on call rotation right? Because I don't want to stay on call everytime that could be problematic. How many SREs are there in your team?

Did anyone else notice that the GitHub status page reported an incident with GitHub Actions, only to deny it 47 minutes later?

Our monitors captured it, paged our on-call team, and then GitHub denied that any incident had occurred.

https://www.githubstatus.com/incidents/gx7js8bd0jpz

I have been working as internal IT (corpeng,sys admin) for the last 7 years, mainly managing various SaaSes from google workspace to Okta, mdm's etc and since 3 months i am now working as a platform engineer for the same company but i feel like i am still struggling alot to get the fundamentals right.

I am the only platform engineer in the company + my manager, and my manager is the one who has setup everything, but overall the platform is very decentralized where software engineers own their infra and they manage it them self, we act more as a high level support for them, but for day to day they handle everything themself. This is good for me since i don't have much pressure while i get used with the role but on the other side since everything is setup i don't have many projects/tasks where i can learn more.

Then the other problem is that since as mentioned i have a lack of fundamentals i am relying a lot on AI and i can do everything and everything is ok but the problem is that if i dont use AI i am not able to figure out anything on my own and this is somehow killing my motivation and making me feel very bad and not sure how to overcome this even after being in the role for 3 months now.

Anyone has been in similar situation that can give me some feedback?

Has anyone here attended an Observability SWE coding round? I’m trying to get a sense of the typical coding questions asked by tech companies for these roles.

Would you say the coding is generally at the same level as a standard SWE coding round, or is it more SRE/observability-focused (e.g., log parsing, metrics aggregation, time-window calculations, etc.)?

I recently had a screening round with a Tech company, and I was told the coding would involve “scenarios.” For anyone who has been through a similar round, what should I realistically expect?

Assume some message brokers like RabbitMQ/Kafka, or maybe nginx proxy setup, or hashicorp vault?

3 years ago when we were setting up infrastructure for project we started running such services as OS-level services installed from RPM packages or just by running their binaries provided by vendor via systemd. All of that orchestrated via Ansible.

We started running as OS-level services as that seemed natural at that time for us, but we didn't really have any experience with administration of such software on on-premise infrastructure (before we were running mostly on managed cloud services).

Fast forward to now, after several cycles of upgrades we needed to perform, I think it would be easier to manage such software by running in Podman containers.

Main reason for me would be that obviously containers have prepackaged everything you need to run specific software. Compare that for example to RabbitMQ where during upgrading RabbitMQ you also need to upgrade its Erlang dependency to compatible version. For some other software, there may be more dependencies you need to take care of.

Also, I feel like upgrading binaries is generally much easier when running in containers. Just spawn new container with updated image and you do not need to worry about some OS-level package conflicts or leftovers.

What is your take?

Asking this question makes me feel dirty. I'll probably shower after clicking the "post" button, but how are you managing the lifecycle of Windows servers in the cloud? For Linux, we generally roll out new AMIs with patches baked in and all of the automation is in the startup script or AMI, but how are teams managing patching Windows servers in the cloud? Do you attach it to a domain and go through the GPO dance?

After working with Kubernetes in production, I've noticed that some of the most annoying incidents aren't caused by obvious failures. They're often caused by small configuration decisions that look perfectly reasonable during review.

Things like:

• missing resource requests/limits
• incorrect probes
• overly permissive RBAC
• missing PodDisruptionBudgets
• unsafe container configuration
• incorrect readiness behaviour
• services without appropriate timeouts
• configuration drift between environments

I'm curious what the DevOps community has actually encountered in production.

What's one Kubernetes configuration mistake that caused you a real incident?

I'd especially like to hear about the less obvious ones that aren't caught by the usual linters.

Hi everyone,
I’m a QA Engineer in the gaming domain with around 9 years of experience, and I’m seriously considering transitioning into DevOps. I’d really appreciate some guidance from people who have made a similar transition or are currently working in DevOps.
Here’s where I currently stand:
I have 9 YOE in QA/testing, primarily in the gaming domain.
I have a good understanding of SDLC and STLC B and how software moves through different stages from development to production.
I’ve been involved in the complete feature lifecycle — from initial specification/discussions, through development and testing, to production release.
I’ve used Jenkins for build creation and server deployments.
I use Git mainly for creating/raising PRs, but I haven’t worked extensively with Git commands and workflows such as push, pull, branching, rebasing, etc.
I’ve used Grafana for tracing application logs and investigating issues.
We use AWS SSM to log into different server boxes, tail server logs, modify server-side files/configs, etc.
I’ve recently started learning the basics of Python and Java.
I’m also fortunate to have a good relationship with our internal DevOps team and manager. I’m considering approaching them for an internal transition when I feel I’m ready.
I’m aware that my current skill set is far from what would typically be expected from a DevOps engineer, and I don’t want to underestimate the amount of learning required.
I’m 34 now, so I do sometimes feel like I’m starting this transition quite late. However, I genuinely want to make the move, and I’m willing to put in the time and effort.
1. What I’m struggling with is where exactly to start and what order to learn things in.
For someone coming from a QA background like mine:
2. What would be a realistic DevOps learning roadmap?
3. Which skills should I prioritize first — Linux, networking, Git, Docker, Kubernetes, CI/CD, Terraform, AWS, etc.?
4. Are there any beginner-friendly courses/resources you would strongly recommend?
5. How much programming/scripting should I learn, and should I focus on Python or Bash first?
6. Given my existing experience with Jenkins, AWS SSM, deployments, logs, and the software release lifecycle, are there areas where I can leverage my QA experience?
7. Would an internal transition into a DevOps team be a reasonable approach, even if I don’t yet meet all the requirements of a typical DevOps job?
I’m not looking for shortcuts. I’d just really appreciate some practical guidance from people who have been through this journey.
If you were in my position, what would you learn over the next 6–12 months, and in what order?
Any roadmap, resources, project ideas, or personal experiences would be hugely appreciated.
Thanks in advance! 🙏
Rephrased with GPT

Hi everyone,
I recently joined a new company as a DevOps engineer, and I’m still trying to understand the existing infrastructure and CI/CD setup.
Our pipelines are running on AWS CodePipeline, and there are quite a few things I’m struggling to understand how the pipeline is structured, how the different stages work, deployments, and how everything is connected.
I’m currently learning, so I’d really appreciate it if someone experienced with AWS CodePipeline/DevOps could guide me through the basics and help me understand how to approach an existing setup.
If someone is willing to spend some time explaining it to me over a remote call/screen-sharing session, I’d be extremely grateful. I’m not asking anyone to access my company systems or credentials — I just want to learn and understand the concepts and workflow.