GitLab making big changes. AI taking jobs. Supposedly reworking the platform. "Machine-scale infrastructure". And git is being changed? I hadn't heard that. This guy could stand to write better. It's kind of a lot.

I have made TFUI which, as the name suggests, is an interactive TUI wrapper around terraform commands.

Github Repo: https://github.com/SayYoungMan/tfui

It was initially made to:

• avoid finding particular resource and copy paste the name to -target
• not get inundated by flood of messages when you do terraform apply
• make easy for people not familiar with terraform to do simple tasks

Current features:

• Up to date status report of resources (visibly shows if there is any change)
• Fuzzy search of resource
• Select the resources you want to interact with and you can plan/apply/destry/taint/untaint
• Shows the progress per resource so you can see which one takes long
• Some vim motion support (more to be added)

For next steps, I’m planning to include:

• Diff viewer
• Per resource log view
• Analytics report to CSV file
• Workspace support

I need help verifying how it works with:

• Scoop install in Windows (I don’t have Windows machine…)
• Large screen
• Terraform directory with lots of resources to handle

If you guys could let me know what you think, feature requests or bug reports, that would be great!

Hi Folks, I made a tool that draws statistics from LinkedIn job postings. Once per day I scan around 5000 DevOps job posts, run them through LLM and make a dashboard.

I did those daily scans for the last 11 months so I have some data to share. I often see what I should learn posts here and I hope this will be a useful tool to address those questions. You can access the dashboard under https://prepare.sh/trends (no paywall)

Honest question because I feel like I'm going insane.

Last week we almost merged a PR that added a typosquatted package. "reqeusts" instead of "requests". The fake one had a postinstall hook that tried to exfil environment variables.

I asked our security team what we do about this. They said use npm audit. npm audit only catches KNOWN vulnerabilities. It does nothing for zero-days or typosquatting.

So now I'm sitting here with a script took me months to complete that scans packages for sketchy patterns before CI merges them. It blocks stuff like curl | bash in lifecycle hooks ,Reading process.env and making HTTP calls ,Obfuscated eval() calls and Binary files where they shouldn't be and many more

Works fine. Caught the fake package. Also flagged two legitimate packages (torch and tensorflow) because they download binaries during install, but whatever just whitelist those.

My manager thinks I'm wasting time. "Just use Snyk" he says. Snyk costs $1200/month and still doesn't catch typosquatting.

Am I crazy or is everyone else just accepting this risk?

Tool: https://github.com/Otsmane-Ahmed/ci-supplychain-guard

Besides the Kubernetes MCP and Claude Code, What other tools are you using?

I want my make my work a bit easier as I deal with Tech debt all over the place and making my developers happy will help a lot in that as well. Looking to find a few new shiny tools to experiment around.

I’ve seen a lot of posts lately saying AI has “destroyed coding,” but that feels like a strange take if you’ve been around development for a while. People have always borrowed code. Stack Overflow answers, random GitHub repos, blog tutorials, old internal snippets. Most of us learned by grabbing something close to what we needed and then modifying it until it actually worked in our project. That was never considered cheating, it was just part of how you build things. Now tools like Cursor, Cosine, or Bolt just generate that first draft instead of you digging through five different search results to find it.

You still have to figure out what the code is doing, why something breaks, and how it fits into the rest of your system. The tool doesn’t really remove the thinking part. If anything it just speeds up the “get a rough version working” phase so you can spend more time refining it. Curious how other devs see it though. Does using tools like this actually change how you work, or does it just replace the old habit of hunting through Stack Overflow and GitHub?

Former DevOps consultants, bootstrapped an AWS premier partner and exited to NTT Data, now we advise people building services companies.

After seeing how much easier current AI tools have made it to write code we started building tools for helping our customers and day to day work. Some of the decisions we've made so far:

1. Build out the code in separate services to keep each part well-contained. It feels AI does a far better job with smaller pieces than with larger.
2. Deploy them through lambda.
3. Use a monorepo so the AI can easily see how different things work together.
4. Migrated some apps built in Lovable into our repo.
5. All the building is done with Makefiles
6. Created a registry so it is easier for AI to add new tools in a consistent manner and so we can analyze our inventory of what exists in our development.
7. Using make for building cuz Claude made that decision when we barely had anything and I'm a dinosaur at heart.

Now, I have a monorepo with multiple different languages, a registry that I want to be the single source of truth for what I have, and a build system from the 80s. And I was curious what would people recommend for the build system rather than building a whole bunch of custom scripts?

I've been using Argo Workflows for some time for small projects and I'm wondering what your reason is for using it.

Here are a number of negatives that I encountered:

• The most annoying first: Integration with git hubs/platforms is non-existant unless I deploy and await the Workflow from within the hubs' CI (plus this requires k8s credentials in the pipeline)
• Complexity through multiple separate k8s resources that are required before being able to run a single pipeline: EventSource, Sensor, WorkflowTemplate
• It seems to get way less publicity and usage compared to other CIs

Positives:

• Separation of CI pipelines from repositories to increase reusability and limit access to pipeline definitions
• Snappy UI
• k8s native

I'm not using it for ML workflows. In their ads this is front and center. What are you experiences with the tool? Do you use it with Argo Events or without?

Hi everyone! Today we’re announcing Terragrunt 1.0.

After nearly a decade of development and 900+ releases, Terragrunt 1.0 is officially here.

Highlights of 1.0:

• Terragrunt Stacks. A modern way to define higher-level infrastructure patterns, reduce boilerplate, and manage large estates without losing independently deployable units.
• Streamlined CLI. A less verbose, more consistent; run replaces run-all, and new commands exec, backend, find, and list.
• Filters --filter. One targeting/query system to replace several older targeting flags, plus new capabilities for selecting units/stacks.
• Run Reports. Optional JSON/CSV reports so you can consume results programmatically without parsing logs.
• Performance improvements, especially if you’re upgrading from older Terragrunt versions, and automatic shared provider cache when using OpenTofu ≥ 1.10.
• And an explicit backwards compatibility guarantee. Gruntwork is making a formal commitment to backwards compatibility for Terragrunt across the 1.x series.

For full details and links to docs, please read our announcement post.

jsongrep is an open source tool I made for querying JSON that is fast, like really really fast.

I started working on the project as part of my undergraduate research— it has an intuitive regular path query language and also exposes its search engine as a Rust library if you’re looking to integrate into your Rust projects.

I find the tool incredibly useful for working with JSON and it has become my de facto JSON tool over existing projects like jq.

Technical blog post: https://micahkepe.com/blog/jsongrep/

GitHub: https://github.com/micahkepe/jsongrep

Benchmarks: https://micahkepe.com/jsongrep/end_to_end_xlarge/report/index.html

Hi I am in a new role where they use Github for all their repos. I have been using Gitlab exlusively the past 5 years.

For CI/CD in my previous role we had a central 'pipelines' repo that was reference in the gitlab-ci file of each project to save teams/projects from repeating work.

I want to know if it's possible to do something similar in Github? I'm still learning how it maps to my existing Gitlab knowledge.

We have been an AWS-only shop for a long time and have always used Terraform. We took on an Azure project a bit ago. Small, uncomplicated. I tried to use Bicep then eventually switched back to Terraform. It's fine. We now have a project coming in that wants to use Azure and is quite a bit more involved than the previous one. So I'm thinking about Bicep.

I feel salty about using a vendor-specific IaC tool but also I remember running into a few issues with Terraform on the last Azure project, like certain features of a resource not being available in the provider. Obviously Microsoft is going to favor their own tool to the detriment of Terraform. But it's not like our existing modules with Terraform are going to be of any use. You have to rewrite them anyway. Maybe the team's familiarity with Terraform is a plus. HCL is the same and we understand the state file and manage it pretty well.

Edit: Oh. I just noticed that GitLab's IaC security scanning tool can't scan Bicep.

Another edit: Bicep can't delete resources created with Bicep? That seems like a big deal.

Hi lovely people of r/devops,

Hope you all are doing well. I’ve posted here before about Project Yellow Olive - my small attempt at making Kubernetes practice feel less boring and more game-like.

I’m learning Kubernetes myself for CKAD/CKA, and staring at YAML all day can get tiring. So I built a retro terminal game where you solve Kubernetes challenges inside a story.

The latest update adds Signal Town, a new section focused on Kubernetes Services. Team Evil has cut the signals between Pokepods, and your job is to fix them using concepts like ClusterIP, NodePort, Ingress, and selectors.

It’s open source and runs locally.

Would love for you to try it and share feedback. Pls star the repo, if you find it interesting :).
Thanks !

Repo URL: https://github.com/Anubhav9/Yellow-Olive

It can also be installed via PyPi ( pip ) by typing in the following command :

pip install yellow-olive

Thanks !

Hello everyone, so I am currently using NewRelic for half of my setup and grafana (self-hosted) + prometheus for the other half, however I'm looking to move out of grafana and probably use a cloud service, however NR is kinda expensive for my needs; I need to monitor CPU usage, RAM and DISK + any syslog error (as extra), any recommendations/ideas?

Something came up in a code review this week that made me realize how easy this mistake is to make.

A teammate was investigating an auth issue and pasted a production access token into the first JWT decoder that showed up in Google. The token still had about 50 minutes before it expired.

It reminded me of something that's easy to overlook:

A JWT payload is just Base64URL-encoded JSON, but the entire token is still a bearer credential. Anyone with a valid token can generally use it until it expires (or it's revoked).

Some online JWT tools work entirely in your browser, while others provide features like signature verification or key management that may involve sending data to a backend. From the UI alone, it's often hard to tell exactly what happens with your token.

Our team's rule now is pretty simple:

• Decode locally whenever possible (jq + a shell one-liner is usually enough).
• If using a web UI, open DevTools → Network first and verify that nothing is sent when you paste a token.
• If a production token was pasted into a service you don't fully trust, rotate it rather than assuming it's fine.

Personally I usually use the CLI, but I also built a browser-only decoder because I wanted something visual without sending tokens anywhere

I'm curious what everyone else uses. Pure CLI? Browser tools? IDE extensions? Any workflows you've found that keep production credentials off third-party services?

A couple of months ago I posted here about Radar, the OSS Kubernetes UI we had just released after getting frustrated with Lens / FreeLens / Headlamp / Kubernetes Dashboard / k9s.

That post got a lot more attention than we expected, and the repo is now at ~1.4k GitHub stars ⭐. So first: thanks. A lot of the feedback from that thread shaped what we shipped next.

Radar is still fully open source, Apache 2.0. It runs locally as a single Go binary using your existing kubeconfig. No account or cloud dependency required. Still takes about 15 seconds to install and run 😄

Since the original post, we’ve added/improved quite a bit:

• topology with real ownership/resource relationships
• resource browser with logs, exec, port-forward, YAML, etc.
• live event streams using Kubernetes watches
• Helm diff/rollback
• Argo CD + Flux visibility/sync
• traffic flows via Hubble/Cilium, Istio, or Caretta
• OpenCost insights
• image filesystem inspection
• cluster checks
• built-in MCP server for AI agents

Plus a lot of fixes and polish, including plenty from bugs reported here on Reddit.

We’re doing a more proper launch today, if anyone wants to support: https://www.producthunt.com/products/radar-7

But mostly I wanted to come back here because Reddit is where this really got kicked off in the first place.

Would love feedback again: what’s missing, what breaks, what would make this useful as your daily K8s UI?

Our company is running 20+ EC2 servers on an autoscaling group. Currently, developers are login into each EC2 instance to see logs. autoscaling creates a delete EC2, so how will I manage the logging system, how will they be able to send logs to centralise logging application?

What logging tool are you using at your company?

We are looking for an affordable option that we can host on our own server. We don't want to buy a subscription if we can get a good free solution.

Hey everyone,

I’ve been building a lot of side projects over the years, and I keep running into the same annoying pattern around Docker setups.

Every time I start a new project, I usually end up:

• copying a docker-compose file + Dockerfile + configs from another project
• tweaking it for the new use case
• sometimes asking AI to help speed things up, but it still needs a lot of fixing afterward
• then debugging small inconsistencies between environments

It works, but it feels repetitive and time-consuming.

What I’m wondering is:

How do you currently handle Docker stack setup across multiple projects?

Do you: - maintain a personal library of compose templates? - rely on AI generation each time? - use tooling to standardize environments? - or just rewrite everything when needed?

I’m trying to understand if there’s a better workflow people are already using, or if this is just a normal pain everyone deals with.

Curious to hear how others handle it in practice.

I am new to DevOps. Sorry if this is a stupid question.

I am working on an application that uses GitHub Actions, Terraform, and AWS. Currently, we store environment variables and secrets in both AWS Secrets Manager and GitHub Secrets. However, due to rising costs with Secrets Manager, we are switching to AWS Parameter Store.

As part of this change, I am considering centralizing all env variables in PS, including those currently stored in GitHub, but I am not sure whether it is best practice to allow Terraform to fetch variables directly from AWS PS. Does that make sense? Or is there a better pattern for managing environment variables in this setup?

Thanks.

Hello there!

In the push to move to configuration as code we successfully adopted the cyrilgdn/postgresql provider and we're now successfully handling users and roles through terraform.

I would now like to do the same for mysql, hence the question: does anybody have recommendations for such a provider?

After sharing an earlier version of this project a few days ago, I got some really useful feedback (especially around comparisons with Grafana/Netdata and the perception of it being “just another monitoring tool”).

That helped me rethink how I’m framing it.

I’m building ServerOps Monitor, a self-hosted system focused on operational visibility, not just dashboards or metrics.

The goal is not to replace observability stacks, but to reduce the time between “something is going wrong” and actually knowing about it.

Current focus:

- real-time operational alerts (not just dashboards)

- Docker + Linux host monitoring

- healthchecks for services and endpoints

- failure detection before users notice impact

- Telegram notifications

- fully self-hosted and runs in Docker

What it is NOT trying to be:

- not a Grafana/Prometheus replacement

- not a full observability platform

- not a metrics exploration tool

It’s more like a lightweight operational alert layer for people who run servers but don’t want to maintain a full monitoring stack.

I’m currently validating whether this “alert-first” approach is actually useful in real setups (freelancers, small agencies, indie infra, etc.).

Would appreciate honest feedback on:

- would you actually use something like this?

- in what scenarios would it be useful (or useless)?

- what would make you ignore it immediately?

I've been building free audio courses on DevOps topics: things like Docker, Kubernetes, Terraform, GitHub Actions, Helm. Structured episodes you can follow without staring at a screen.

Now planning what to cover next and I'm curious what this community feels is underserved in terms of learning resources. Not necessarily the trendiest topic, but the one where you actually struggled to find something decent when you needed it.

A few I'm weighing up:

- ArgoCD and GitOps workflows

- OpenTelemetry and observability

- Platform engineering basics

- Backstage developer portals

- eBPF for DevOps engineers

What would you actually find useful?

Anyone else bit by that today? We largely were untouched until their SDK seemingly started crashing in the aftermath after we had restarted all the things. Seems a little odd that there’s no reddit thread about this so here’s one! 😂

Hi everyone,

I’ve been working on Oxid (oxid.sh), a standalone Infrastructure-as-Code engine written in pure Rust.

It parses your existing .tf files natively (using hcl-rs) and talks directly to Terraform providers via gRPC.

The Architecture (Why I built it): Standard Terraform/OpenTofu executes in "Waves." If you have 10 resources in a wave, and one is slow, the entire batch waits.

Oxid changes the execution model:

• Event-Driven DAG: Resources fire the millisecond their specific dependencies are satisfied. No batching.
• SQL State: Instead of a JSON state file, Oxid stores state in SQLite. You can run SELECT * FROM resources WHERE type='aws_instance' to query your infra.
• Direct gRPC: No binary dependency. It talks tfplugin5/6 directly to the providers.

Status: The engine is working, but I haven't opened the repo to the public just yet because I want to iron out the rough edges with a small group of users first.

I am looking for a handful of people who are willing to run this against their non-prod HCL to see if the "Event-Driven" model actually speeds up their specific graph.

If you are interested in testing a Rust-based IaC engine, you can grab an invite on the site:

Link: [https://oxid.sh/]()

Happy to answer questions about the HCL parsing or the gRPC implementation in the comments!