Cloud, containers and infrastructure stacks
Docker, Kubernetes, cloud provider service stacks, IaC with Terraform/Bicep, microservice production architecture, and server setup like NGINX, systemd, and VPS deployment.
31%
Best tweets about DevOps
42 Best Tweets About DevOps (2026)
Find the best tweets about DevOps, covering deployments, CI/CD, infrastructure, observability, reliability, incidents, automation, and platform engineering.
Production DevOps systems, deployment pipelines, infrastructure, observability, incidents, reliability, automation, and engineering tradeoffs.
- Creators
- 34
- Updated
Original Xholic analysis
What 42 top DevOps posts reveal
A 42-post DevOps set from 34 creators centers on cloud/container stacks, CI/CD pipeline design, career roadmaps and AI agents for ops. Supportive stances lead (47.6%). Posts with media show a higher median all-time score (36.47) than text-only posts (6.09). The top outlier, a post saying AWS DevOps Agent is generally available, scored 41.8x the median. Recurring threads: fundamentals over tool collecting, pipelines as confidence gates, and DevOps discipline as a prerequisite for agentic workflows.
- Dominant tone
- Positive
- Median score
- 15.1
- Leading format
- List
- Recent posts
- 28.6%
52.4% of posts
All-time engagement
33.3% of posts
Published in 90 days
Conversation map
The themes creators return to
CI/CD pipeline design and speed
How pipelines are structured: environment promotion, gating stages, build/run separation, integration testing with containers, security scans, caching, parallelism, runners, and release hygiene.
28.6%
DevOps careers and learning roadmaps
Roadmaps for DevOps, SRE and platform engineering, essential fundamentals, role distinctions, hiring judgment over certifications, curated resources, and learning-in-public deployment journeys.
28.6%
AI agents in DevOps and SRE
AI assistants and agents that generate pipelines, debug deployments, investigate incidents, provision infrastructure, or act as on-call SRE, plus debate on whether AI replaces DevOps roles.
26.2%
MLOps, LLMOps and agent evals
Adapting DevOps to ML and LLM systems: training pipelines as artifacts, drift monitoring, prompt versioning, eval pipelines for agents, and DevOps foundations required for agentic workflows.
11.9%
Observability, incidents and reliability
Logs, metrics, traces, health checks versus real health, Kubernetes troubleshooting, incident response, runbooks, postmortems, and SRE practices.
11.9%
Org structure and team tradeoffs
How team boundaries, culture, startup staffing, tool standardization, and AI-driven role consolidation shape delivery and accountability for DevOps and security.
11.9%
Deployment and rollout strategies
Blue-green, canary, feature toggles, dark launches, rollbacks, and tradeoffs in number of environments between dev and production.
4.8%
Tone and stance
SentimentPositive leads
Author postureSupportive leads
Performance benchmark
- Median likes
- 34
- Median reposts
- 5
- Median replies
- 5
- Median views
- 2.3K
Posts with media make up 57.1% of this collection. Their median all-time score is 36.5, compared with 6.09 for text-only posts.
Format mix
- List33.3% · score 16.5
- Opinion19% · score 17.5
- Story19% · score 9.85
- Other7.1% · score 107.5
Consensus and debate
Where creators agree, and where they do not
Shared view
Fundamentals beat tool and cert collecting
Career posts converge on depth over breadth: Linux, one cloud, and Kubernetes deployed and broken on purpose. They stress learning concepts in the right order and being able to defend tradeoffs rather than stacking certifications.
Shared view
CI/CD is a confidence pipeline, not auto-deploy
Builders describe pipelines as sequential gates: lint, tests, image builds, registry pulls, health checks, PR gating and containerized integration tests. Shivam Singh also notes that a passing /health check or running container does not prove the service is actually healthy.
Shared view
Agents need DevOps discipline first
Several voices argue agentic workflows depend on solid DevOps foundations. These include ephemeral environments, fast feedback loops, clear dev/staging/prod boundaries, comprehensive CI, and evals treated like tests.
Shared view
Keep pipeline setups simple and standardized
TechWorld with Nana recommends starting with Dev → Staging → Prod and adding environments only to solve a specific problem. Dr Milan Milanović advises picking one CI/CD tool and using it everywhere rather than mixing tools across teams.
Open debate
Can AI do the DevOps job?
Ayaan likens AWS DevOps Agent to a junior DevOps engineer, and Hot Aisle says a task that would have taken expert DevOps a week+ took minutes with AI. Branko counters that AI cannot carry the pager, own rollbacks or answer compliance questions. Alex argues that DevOps and security are where accountability concentrates.
Open debate
Do startups need DevOps specialists?
K.O.O says young startups can rely on a strong fullstack engineer for deployment, CI/CD and monitoring. Other posts frame these roles differently: Uday separates Cloud Engineer from DevOps Engineer roles, and zavx calls Platform Engineering a high-impact career.
Open debate
How much incident autonomy to give agents
Paul Iusztin showcases a student-built SRE agent that investigates incidents and proposes fixes with human approval. divyansh tiwari highlights OpenSRE agents that investigate incidents to find root cause. Hamid Dadkhah says incidents stay human-led, even as agents gather telemetry and propose mitigations.
What performs
Patterns behind standout posts
Announcement is the standout outlier
The post saying AWS DevOps Agent became generally available scored 629.86, or 41.8x the 15.07 median. ANNOUNCEMENT has the highest format median (318.55), but that figure covers only 2 posts and is driven by this single outlier.
Media posts outscore text-only posts
Posts with media make up 57.1% of the set and have a median all-time score of 36.47, versus 6.09 for text-only posts. This is a correlation, not a demonstrated cause. Per-post media flags are not supplied, so the cited posts are top scorers rather than confirmed media examples.
Small themes carry high medians
Deployment strategies (2 posts, median 112.24) and MLOps/LLMOps (5 posts, median 102.796) have far higher medians than cloud infra (31% share, 7.317) and AI agents for ops (6.581). The small samples make these medians fragile.
Tutorials post higher medians than lists and stories
TUTORIAL has a median of 86.297 across only 3 posts. LIST, the most common format (33.3% of posts), sits at 16.47, and STORY at 9.85.
Statistical standouts
- View standout post 1Score 629.9 · 41.8× median
- View standout post 2Score 137.8 · 9.15× median
- View standout post 3Score 137.4 · 9.11× median
- View standout post 4Score 136.8 · 9.08× median
- View standout post 5Score 135.7 · 9× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 23.8% of the selected posts.
1. Emmy Codes 🪖🚀👨💻
@_devEmmy
2 posts
2. Vaishnavi
@_vmlops
2 posts
3. Abhishek Singh
@0xlelouch_
2 posts
4. Branko
@brankopetric00
2 posts
5. Shalini Goyal
@goyalshaliniuk
2 posts
6. TechWorld with Nana | DevOps 🚀
@Njuchi_
2 posts
TechWorld with Nana leads top voices
TechWorld with Nana (@Njuchi_) has the highest top-voice median (136.76) across 2 posts on environment strategy and Kubernetes learning. Shalini Goyal follows with a median of 81.97 across posts on deployment strategies and microservice stacks.
Learning-in-public journeys are a distinct voice
Shivam Singh and Emmy Codes post day-numbered deployment progress, covering VPS CI/CD, observability, NGINX and systemd. Their medians of 15.22 and 11.16 sit near the 15.07 set median.
Conversation is broadly distributed
The set spans 34 creators across 42 posts, with a top-five placement share of 23.8%. Each listed top voice has only 2 posts.
Since the previous snapshot
What changed since Aug 26, 2026
- 52.4% of the selected posts remained.
- The creator count changed by -2.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 42-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best DevOps tweets
Top DevOps tweets from 34 creators
Ranked 01–42
- 01
@twtayaan ·
🚨 AWS DevOps Agent is finally here! On March 31, 2026, AWS DevOps Agent became generally available. This is actually a big deal. It can: → Generate CI/CD pipelines → Debug failed deployments → Suggest infrastructure changes → Analyze logs and incidents → Help with Terraform & CloudFormation → Recommend cost optimizations → Explain AWS architecture issues Basically, it’s like having a junior DevOps engineer inside AWS. DevOps is slowly becoming AI-assisted operations. Source: https://t.co/PMNbPPF4lW
- 106Replies
- 495Reposts
- 3.3KLikes
- 2.1MViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 02
@Aurimas_Gr ·
As an 𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿 you should also care about regular, non LLM-based ML models, productionising them comes with its own challenges. For example, 𝗖𝗜/𝗖𝗗 process is 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗳𝗼𝗿 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 compared to regular software. The important difference that the Machine Learning aspect of the projects brings to the CI/CD process is the treatment of the Machine Learning Training pipeline as a first class citizen of the software world. ➡️ CI/CD pipeline is a separate entity from Machine Learning Training pipeline. There are frameworks and tools that provide capabilities specific to Machine Learning pipelining needs (e.g. KubeFlow Pipelines, Sagemaker Pipelines etc.). ➡️ ML Training pipeline is an artifact produced by Machine Learning project and should be treated in the CI/CD pipelines as such. What does it mean? Let’s take a closer look: Regular CI/CD pipelines will usually be composed of at-least three main steps. These are: 𝗦𝘁𝗲𝗽 𝟭: Unit Tests - you test your code so that the functions and methods produce desired results for a set of predefined inputs. 𝗦𝘁𝗲𝗽 𝟮: Integration Tests - you test specific pieces of the code for ability to integrate with systems outside the boundaries of your code (e.g. databases) and between the pieces of the code itself. 𝗦𝘁𝗲𝗽 𝟯: Delivery - you deliver the produced artifact to a pre-prod or prod environment depending on which stage of GitFlow you are in. What does it look like when ML Training pipelines are involved? 𝗦𝘁𝗲𝗽 𝟭: Unit Tests - in mature MLOps setup the steps in ML Training pipeline should be contained in their own environments and Unit Testable separately as these are just pieces of code composed of methods and functions. 𝗦𝘁𝗲𝗽 𝟮: Integration Tests - you test if ML Training pipeline can successfully integrate with outside systems, this includes connecting to a Feature Store and extracting data from it, ability to hand over the ML Model artifact to the Model Registry, ability to log metadata to ML Metadata Store etc. This CI/CD step also includes testing the integration between each of the Machine Learning Training pipeline steps, e.g. does it succeed in passing validation data from training step to evaluation step. 𝗦𝘁𝗲𝗽 𝟯: Delivery - the pipeline is delivered to a pre-prod or prod environment depending on which stage of GitFlow you are in. If it is a production environment, the pipeline is ready to be used for Continuous Training. You can trigger the training or retraining of your ML Model ad-hoc, periodically or if the deployed model starts showing signs of Feature/Concept Drift. Let me know your thoughts. 👇
- 15Replies
- 37Reposts
- 202Likes
- 7.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 03
@Njuchi_ ·
The Minimalist, The Paranoid, and The Practical walk into a bar... Actually, they walk into a deployment meeting. And they all think the other two are doing CI/CD completely wrong. But here is the thing: 𝗧𝗵𝗲𝗿𝗲'𝘀 𝗻𝗼 "𝗰𝗼𝗿𝗿𝗲𝗰𝘁" 𝗻𝘂𝗺𝗯𝗲𝗿 𝗼𝗳 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁𝘀 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘆𝗼𝘂𝗿 𝗹𝗮𝗽𝘁𝗼𝗽 𝗮𝗻𝗱 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻. But every team acts like theirs is the only way that makes sense. Let me break down the 3 main approaches I see: 𝟭) 𝗧𝗵𝗲 𝗠𝗶𝗻𝗶𝗺𝗮𝗹𝗶𝘀𝘁: 𝗗𝗲𝘃 → 𝗣𝗿𝗼𝗱 ↳ Ship fast, fix faster. No safety nets. ↳ Your tests better be solid because that's your only checkpoint. ✅ Good: Lightning fast deployments. You learn to write bulletproof tests. ❌ Bad: One bad merge and your customers are your QA team. Best for: Startups, internal tools, teams with crazy good automation 𝟮) 𝗧𝗵𝗲 𝗣𝗮𝗿𝗮𝗻𝗼𝗶𝗱: 𝗗𝗲𝘃 → 𝗧𝗲𝘀𝘁 → 𝗦𝘁𝗮𝗴𝗶𝗻𝗴 → 𝗣𝗿𝗲-𝗣𝗿𝗼𝗱 → 𝗣𝗿𝗼𝗱 ↳ Every environment catches something different. ↳ Takes 2 weeks to deploy a button color change. ✅ Good: You'll catch bugs. All of them. Eventually. ❌ Bad: By the time you deploy, the original developer left the company. Best for: Banking, healthcare, anywhere a bug costs millions or lives 𝟯) 𝗧𝗵𝗲 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹: 𝗗𝗲𝘃 → 𝗦𝘁𝗮𝗴𝗶𝗻𝗴 → 𝗣𝗿𝗼𝗱 ↳ Staging is a production clone where you test the scary stuff. ↳ Fast enough to ship daily, safe enough to sleep at night. ✅ Good: Balance between speed and safety. Most teams end up here. ❌ Bad: Staging environments drift from prod. Always. No exceptions. Best for: Most software companies, SaaS products, anything customer-facing Here's what I actually tell people: Start with Dev → Staging → Prod. Seriously. Don't add environments because they sound professional. Add them when you have a specific problem to solve. Every extra environment is another place for things to break, drift, or slow you down. The best pipeline is the one your team actually uses correctly. 💬 Real talk: How many environments does your team have? And how many of them are actually working as intended? ------ 🧑🏻💻 And if you want to learn how to actually build this multi-stage deployment from scratch, we walk through the whole Dev → Staging → Prod flow in our CI/CD masterclass: https://t.co/oGzTE7q7uN
- 11Replies
- 65Reposts
- 393Likes
- 13KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 04
@milan_milanovic ·
𝗧𝗵𝗲 𝗔𝘇𝘂𝗿𝗲 𝗧𝗲𝗰𝗵 𝗦𝘁𝗮𝗰𝗸 Here are the most important Azure services organized by layer. 𝟭. 𝗙𝗿𝗼𝗻𝘁𝗲𝗻𝗱 Here we have Static Web Apps for Single-Page Applications, and a Content Delivery Network (CDN) for edge caching. If you need global routing, you can use Front Door, and here you also get WAF. Entra ID B2C can be used for customer identity. Most teams start with App Service, and honestly, that's the right call because it handles 80% of the cases that we need. 𝟮. 𝗔𝗣𝗜 𝗟𝗮𝘆𝗲𝗿 API Management is heavy, but if you need versioning, rate limiting, and a developer portal, it's worth the cost. App Gateway in front of internal services. Functions for event-driven compute, Event Hubs, when you're ingesting at scale and need Kafka compatibility. Load Balancer for Layer 4 routing. 𝟯. 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗟𝗮𝘆𝗲𝗿 Use AKS if your project requires Kubernetes. Container Instances for short-lived jobs, where spinning up a cluster is overkill. Service Bus for reliable queuing between services. Event Grid for reactive, event-driven stuff. Logic Apps is something people swear by for integration workflows, and I've never quite gotten there myself, but the use case is legitimate. 𝟰. 𝗗𝗮𝘁𝗮 𝗟𝗮𝘆𝗲𝗿 Most of the real architecture arguments happen here. Cosmos DB is when you need global distribution and multi-model flexibility, but also write-heavy systems. Azure SQL when relational is the right fit and you'd rather not manage your own SQL Server. Cache for Redis in front of either. Synapse for analytics workloads, Data Lake for raw storage, Stream Analytics when you need real-time processing on incoming event streams. 𝟱. 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆 𝗮𝗻𝗱 𝗜𝗱𝗲𝗻𝘁𝗶𝘁𝘆 Entra ID for identity, Key Vault for secrets and certificates. WAF placement depends on whether you're using Front Door or App Gateway. Defender for Cloud across the subscription, Sentinel as the SIEM. This layer tends to get scoped down when budgets are tight. Then something happens, and you rebuild it properly under pressure. 𝟲. 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆 App Insights for application telemetry and distributed tracing. Log Analytics for querying everything. Service Health so you know when Azure itself is having a bad day, which happens more often than the 99.9% SLA suggests. Most teams set this up too late. 𝟳. 𝗖𝗜/𝗖𝗗 𝗮𝗻𝗱 𝗗𝗲𝘃𝗢𝗽𝘀 Azure DevOps or GitHub Actions. Pick one, use it everywhere, don't mix them across teams. Bicep over ARM, the syntax is dramatically cleaner, and the tooling has caught up. Terraform, if you're multicloud or the team already has it. Container Registry for images close to your AKS clusters. The projects I've seen with the messiest pipelines are the ones that let different teams pick different tools. 𝟴. 𝗠𝗲𝗱𝗶𝗮 𝗮𝗻𝗱 𝗙𝗶𝗹𝗲𝘀 Blob Storage for unstructured data, Azure Files for SMB shares, Queue Storage for simple message passing. Media Services, if you're doing video processing. Computer Vision, when you need image analysis without building the model yourself. 𝟵. 𝗠𝘂𝗹𝘁𝗶-𝗥𝗲𝗴𝗶𝗼𝗻 𝗡𝗲𝘁𝘄𝗼𝗿𝗸𝗶𝗻𝗴 Virtual Network as the foundation. VPN Gateway for site-to-site, ExpressRoute, when you need private dedicated connectivity with predictable latency, and the cost is justified. Traffic Manager for DNS-based global routing. Private Link to expose services internally without putting them on the public internet. Most teams don't think about this layer until they're designing for a second region.
- 5Replies
- 49Reposts
- 289Likes
- 11.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 05
@Njuchi_ ·
5 Kubernetes mistakes costing you months of progress 😬 After teaching DevOps, here's what I see over and over: ❌ Jumping into K8s without understanding containers first ❌ Setting up your own cluster from scratch as a beginner ❌ Memorizing YAML syntax instead of understanding concepts ❌ Skipping networking fundamentals ❌ Trying to learn everything at once The smart approach? Start with Docker → Use managed K8s (EKS/GKE/AKS) → Deploy a basic app → Gradually add complexity (storage, RBAC, Helm, monitoring, Terraform) Separate K8s usage from K8s administration - each one is already a lot of work! ➡️ Want the complete learning path laid out for you? Our DevOps curriculum breaks down everything from containers to production K8s in the right order - no more guessing what to learn next 🎯 ➡️ https://t.co/PQriAkdwqT
Watch video- 8Replies
- 40Reposts
- 336Likes
- 9.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 06
@pauliusztin_ ·
A student from our Agentic AI Engineering course just built an on-call site reliability engineer agent. (It can debug production incidents in less than 60 seconds) Check it out → https://t.co/4wKDqdUg4X Most incident responses typically require site reliability engineers to: • Jump between logs, metrics, and traces • Guess what changed • Search for the right runbook • Manually piece together a timeline ... Under a lot of pressure and time-sensitive. Studies show that mean time to resolution for production incidents averages 1-4 hours across the industry. And a significant portion of that time spent on the investigation phase rather than the actual fix. This project flips that workflow. It’s an MCP-powered site reliability engineer agent that: • Plans the investigation (hypotheses + task graph) • Executes queries across logs, metrics, deploys in parallel • Synthesizes findings into a root-cause report • Proposes fixes with human approval What I like about this build? • Clean Architecture with clear separation (entities, use cases, infra) • Plan → Execute → Synthesize pattern done properly • Parallel + dependency-aware task execution • Human-in-the-loop for safe remediation • Strong use of structured outputs (Pydantic + Gemini) If you want to learn how to build systems like this from scratch, we cover these exact patterns in our Agent Engineering course. Enroll here: https://t.co/QEuz9Ub89T P.S. Credit to Horatio Benjamin Moggee for this awesome project. I was unable to find you on X. Comment if you see this.
- 3Replies
- 26Reposts
- 165Likes
- 8.4KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 07
@_vmlops ·
Kubernetes troubleshooting is a core skill for DevOps engineers, especially in production where issues like CrashLoopBackOff, Pending pods, ImagePullBackOff, OOMKilled errors, DNS failures, ingress issues, volume mount problems, resource pressure, restart loops & networking glitches are common Deploying applications is often straightforward the real challenge begins when things break & diagnosing those failures quickly & effectively is what separates experienced engineers from the rest
- 3Replies
- 44Reposts
- 198Likes
- 6.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 08
@_avichawla ·
DevOps vs. MLOps vs. LLMOps: Many teams are trying to apply DevOps practices to LLM apps. But DevOps, MLOps, and LLMOps solve fundamentally different problems. DevOps is software-centric. You write code, test it, and deploy it. The feedback loop is straightforward: Does the code work or not? MLOps is model-centric. Here, you're dealing with data drift, model decay, and continuous retraining. The code might be fine, but the model's performance can degrade over time because the world changes. LLMOps is foundation-model-centric. Here, you're typically not training models from scratch. Instead, you're selecting foundation models and then optimizing through three common paths: - Prompt Engineering - Context/RAG Setup - Fine-Tuning But here's what really separates LLMOps: The monitoring is completely different. In MLOps, you track data drift, model decay, and accuracy. In LLMOps, you're watching for: - Hallucination detection - Bias and toxicity - Token usage and cost - Human feedback loops This is because you can't just check if the output is "correct." You need to ensure it's safe, grounded, and cost-effective. The evaluation loop in LLMOps also feeds back into all three optimization paths simultaneously. Failed evals might mean you need better prompts, richer context, OR fine-tuning. So it's not a linear pipeline anymore. One more thing: prompt versioning and RAG pipelines are now first-class citizens in LLMOps, just like data versioning became essential in MLOps. And the ops layer you choose should match the system you're building. 👉 Over to you: What does your LLM monitoring stack look like right now? ____ Find me → @_avichawla Every day, I share tutorials and insights on DS, ML, LLMs, and RAGs.
Watch video- 10Replies
- 52Reposts
- 236Likes
- 15.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 09
@arpit_bhayani ·
Months of building and shipping AI systems made me realize - one thing that makes agentic workflows work is good old best devops practices. If you do not have proper tooling, clean (and also well-defined) processes, and ephemeral environments set up, an AI agent cannot run or help you reliably. Be it agentic SDLC, running evals, phased agent rollouts, circuit breakers, database access, or anything else. Think about what an agent actually needs to do good work. It needs a safe place to run code, a fast feedback loop to know if something broke, and clear boundaries between development, staging, and production. Most skip this and go straight to "let the agent write and deploy code." Then they hit weird failures, lose trust in the system (and even AI), and quietly give up on agentic workflows altogether. The fix is not about AI at all. It is the same old devops discipline that made human engineering teams reliable in the first place. Good things die hard :)
- 34Replies
- 19Reposts
- 477Likes
- 33.3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 10
@mjovanovictech ·
My secret to never crashing production: I run my tests inside the CI/CD pipeline. This gives me maximum confidence in my code. And it's all thanks to Testcontainers and Docker. You can run external services as containers and access them in the tests. And now you can connect to these services from your application (and tests). Ready to take your integration testing in .NET to the next level? Here's a complete guide: https://t.co/oGSUMXSaTl What do you think about this approach? You can get close to "production" testing with minimal overhead. It will slow down your CI runs, but it's worth it for me. I caught so many problems this way before they ever touched prod.
- 9Replies
- 30Reposts
- 162Likes
- 6.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post.
- 11
@goyalshaliniuk ·
Choosing the right deployment strategy can make or break the rollout of new microservices. This guide breaks down five popular deployment patterns every DevOps and backend engineer should understand: 1. Blue-Green Deployments Switch traffic between two identical environments (Blue and Green) to minimize downtime and risk. Great for seamless rollbacks. 2. Canary Releases Gradually expose new features to a small subset of users before full rollout. Monitor performance and catch issues early. 3. Feature Toggles Enable or disable features at runtime for specific user segments—without redeploying code. Ideal for staged rollouts and A/B testing. 4. Dark Launches Deploy features in production but keep them hidden from end users. Used for internal testing, performance tuning, and readiness checks. 5. A/B Testing Run controlled experiments by comparing two feature versions with different user groups. Use data to guide product decisions. Takeaway: These strategies help you ship fast, reduce risk, and gather real-world feedback—without breaking your production environment. Which strategy do you use the most?
Watch video- 14Replies
- 31Reposts
- 120Likes
- 2.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 12
@goyalshaliniuk ·
Building scalable applications with microservices demands more than just code. It’s a carefully designed flow from pre-production to production - integrating APIs, containers, databases, and cloud infrastructure. 1. Pre-production Flow It all starts with the developer. APIs are defined using tools like OpenAPI and Postman. Microservices and frontends are built with frameworks like Java, Node.js, or React, then tested using Jenkins and JUnit. Once stable, Docker images are created and deployed through orchestrators like Kubernetes. 2. Production Flow In production, traffic flows from client apps through load balancers (e.g., NGINX) and CDNs (e.g., Cloudflare) to the API Gateway (e.g., Spring Boot with Netflix Eureka). Behind the scenes, services connect to databases, caches (Redis), search engines (Elasticsearch), and message brokers (Kafka), all monitored via tools like Postman and Kubernetes. 3. Unified Tooling This stack combines containerization, CI/CD, observability, and modular architecture to support fast deployments and scalable systems, ensuring every component runs independently yet harmoniously. Save this stack if you're working on building production-ready microservices—or planning to start soon.
Watch video- 13Replies
- 30Reposts
- 107Likes
- 2.8KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 13
@mischavdburg ·
You don't need 12 certifications to break into DevOps. You need: - Linux fundamentals (not just commands, the actual OS) - One cloud provider, learned deeply - Kubernetes, deployed and broken on purpose - A homelab that proves you've done the work That's the whole list.
- 8Replies
- 13Reposts
- 165Likes
- 4.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 14
@techyoutbe ·
> You don't need to learn 50 tools first. > You need to understand the right concepts in the right order. > I created this SRE Roadmap to help you go from the basics to advanced SRE concepts. > Start with Linux & System Fundamentals. > Then learn Networking, Scripting & Automation, Observability, Incident Management and Reliability Engineering. > Once the fundamentals are clear, move into CI/CD, Infrastructure as Code, Kubernetes and Platform Engineering. > Finally, focus on SRE practices, documentation, collaboration, continuous learning and career growth. > The roadmap covers the key concepts, tools and practices you should know at each stage. Linux → Networking → Automation → Observability → Incident Management → Reliability → CI/CD → IaC → Platform Engineering → Career Growth > Save this roadmap if you're learning SRE, Platform Engineering or DevOps. > Follow me for more Cloud, DevOps, Kubernetes and SRE content.
- 1Replies
- 17Reposts
- 92Likes
- 5.5KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 15
@brankopetric00 ·
Nobody gets hired in DevOps for knowing what a load balancer is. I've spent 2 years sharing free content with people trying to break in, and the ones who struggle almost always make the same mistake: They collect. Certs. Courses. Cheat sheets. Another YouTube playlist. Meanwhile the ones who get hired do something different. They can defend a decision. Ask them "why did you scale the pods instead of fixing the memory leak?" and they don't panic. They walk you through the tradeoff like they've done it a hundred times. Because in their head, they have. That's the gap between "I studied DevOps" and "I can do the job." Certs prove you can memorize. Judgment proves you can be trusted at 3am. Interviewers are buying the second one. So practice the second one. Take real decisions. Get challenged on them. Defend them until it's second nature. That's the whole game.
- 5Replies
- 6Reposts
- 121Likes
- 7.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 16
@Dominus_Kelvin ·
Young startups do not need a DevOps specialist. A cracked senior or mid-level fullstack engineer can handle deployment, CI/CD, servers, monitoring, databases, and shipping the product. Most startups are hiring for complexity they have not encountered yet.
- 23Replies
- 18Reposts
- 234Likes
- 20.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 17
@enisco ·
How CI/CD pipelines work (explained in 2 mins or less): A CI/CD pipeline is an automated workflow that facilitates continuous integration (CI) and continuous delivery or deployment (CD) by managing code building, testing, and release processes. It integrates the various stages of the software development lifecycle (SDLC) into a seamless, repeatable process. These stages include source code management, automated testing, artifact creation, and deployment orchestration. Continuous ‘delivery’ and ‘deployment’ are sometimes used synonymously. But there is a clear and important distinction between the two. Delivery is about ensuring the software can be released at any time. It requires manual intervention to deploy to production. Deployment, on the other hand, does the release through automated workflows.
- 14Replies
- 9Reposts
- 45Likes
- 1.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 18
@Daviowhite ·
Pushed my First Commits last night These are the steps I followed 1. I started building in Google AI studio for the first time then faced a challenge with testing on my device 2. I downloaded the react codes to my device and created a repo in GitHub after chatting with macOS built in terminal 3. Making updates was slow so I got VS code to make it faster 4. Discovered it was better so I shutdown macOS terminal, created a new terminal inside vs code 5. Imported my project file folder into it and started making updates directly 6. Learned to pause and restart vite server using control C so I can push new build and test it 7. To test the app on my phone, I created an account with Vercel with my GitHub connected 8. Went back to terminal to test that all integrations are working including GitHub branch “main” and status 9. Pushed my first commit at 4AM, added the commit message, sync with terminal to allow build go through 10. It auto deployed in Vercel and was live on my localhost and phone with the Vercel url 11. I discovered copilot agent was in vs code so I tried it to make a small update to the bottom navigation since 50% of it was hiding behind the browser url Copilot completely moved the bottom navigation below the page 🥲 so I asked my buddy gpt for help 12. It taught me how to undo deployments using a set of codes including git reset —hard HEAD~1 git push —force These commands brought back my previous build but it didn’t push to Vercel so I updated the bottom navigation using “100dvh” instead of “100vh” 13. New commit was available now in Source control so I pushed and it was fixed Made some few adjustments turning the web app into a progressive web app on my phone so it can live as an app icon hiding web browser This process taught me a lot, I went from Hello World to a commit super fast My Complete Tool Stack Core Tech - React + TypeScript - Vite - Tailwind CSS Version Control & Deployment - Git (version control) - GitHub (repository + source control integration) - Vercel (CI/CD + auto deployment) Development Environment - VS Code AI / Assistance Tools - ChatGPT (architecture, debugging, guidance, decision support) - GitHub Copilot (inline code assistance) - Google AI Studio (experimentation, alternative code generation) My workflow - Develop locally - Commit changes - Push to GitHub - Auto-deploy via Vercel - Test on mobile - Iterate
- 15Replies
- 12Reposts
- 166Likes
- 11.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 19
@0xlelouch_ ·
Top 10 practical DevOps resources (for working devs): 1) Google SRE Book (free online): SLOs, error budgets, incident response, and why toil kills teams. 2) The Phoenix Project: good mental model for flow, constraints, and why approvals and batching wreck delivery. 3) Kubernetes docs + kubebuilder tutorial: skip courses until you can read the upstream docs and ship a controller. 4) Terraform docs + a real module repo: learn state, drift, import, and how to not brick prod with a plan. 5) AWS Well-Architected Framework: concrete checklists for reliability, cost, security, and ops tradeoffs. 6) Linux Upskill Challenge: the unsexy stuff that pays off at 2am (systemd, networking, logs, disks). 7) Brendan Gregg’s blog (perf): flame graphs, CPU/memory/IO debugging, and how to stop guessing. 8) Grafana + Prometheus docs: build RED/USE dashboards, alerts that page for symptoms not causes. 9) GitHub Actions or GitLab CI docs: write a pipeline with caching, artifacts, env promotion, and rollback. 10) Practice project: build + ship a tiny service - Dockerfile, helm/kustomize - CI to deploy to a test cluster - metrics/logs/traces - chaos test: kill pods, drop DB, rotate secrets
- 2Replies
- 4Reposts
- 29Likes
- 1.9KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 20
@shivam74689 ·
Day 128 — Becoming AI Engineer Today I learned that deployment is not the end of engineering. It is the start of operating the system. TicketPilot is now deployed on a VPS with CI/CD in place, but I realized that: "Service is running" ≠ "Service is healthy" A Docker container being up, CI passing, or /health returning success does not prove that every part of the application is actually behaving correctly. To understand what is happening in production, I need evidence. That evidence comes from observing the live system. I started inspecting the logs and error paths directly on the VPS instead of relying on my local terminal or assumptions. The production request path now looks more like: User → Caddy → API → PostgreSQL / Redis → LLM → Response A failure can happen anywhere along this chain. For example: • Caddy can fail to route the request correctly • The API can raise an application error • PostgreSQL can become unavailable • Redis can fail or become slow • The LLM can return malformed output • A timeout can occur between dependencies • A fallback path can execute instead of the normal path So when something fails, the important question is not simply: "Is the container running?" The questions I need to answer are: • What happened? • Where did it fail? • Which dependency was involved? • What request triggered it? • Did the retry execute? • Did the human fallback execute? • Is the system still healthy? I also started validating the failure-handling behavior I designed earlier directly on the deployed system. In particular, I began checking the production behavior for: • Malformed LLM output • Dependency failures • Retry behavior • Human-fallback paths The important part is not just that these mechanisms exist in the code. They need to be observable when the system is actually running. A failure-handling mechanism that works in a unit test but cannot be observed or diagnosed in production is still difficult to operate. The bigger lesson: "Production engineering is about evidence, not assumptions." Deployment tells me that I successfully moved the software to a server. Observability tells me what the software is actually doing. And operational confidence comes from connecting the two: Deploy → Observe → Inject Failure → Trace → Recover → Verify This is the mindset I want to build as an AI engineer. Not just: "Can I build the system?" But: "Can I understand what the system is doing when something goes wrong?" Next: continue the capability gate, verify the production failure paths, and turn the findings into a postmortem. #AI #AIEngineer #AgenticAI #Python #FastAPI #Docker #PostgreSQL #Redis #GenAI #DevOps #Observability #BuildInPublic #LearningInPublic
- 8Replies
- 4Reposts
- 22Likes
- 616Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 21
@_devEmmy ·
Day 36 of Coding – AI | Machine Learning 🚀 Hi guys, Today was mostly about preparing my FastAPI project for real-world deployment. I learned how to handle database migrations using Alembic, which allows me to automatically detect changes in my SQLAlchemy models and generate the proper database tables or updates without manually recreating the database. I also added CORS configuration and finally deployed the API on Render. Next up I’ll be diving deeper into the deployment side of things: • Setting up an Ubuntu server environment • Configuring NGINX • Connecting a custom domain • Setting up firewalls • Writing a Dockerfile • Running proper tests • Automating workflows with GitHub Actions And a lot more. Slowly moving from just building APIs to learning how to ship and run them in production. I’m also noticing that I’m picking up some DevOps knowledge, which will definitely help when I start deploying AI agents.
- 3Replies
- 5Reposts
- 45Likes
- 584Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 22
@0xlelouch_ ·
90% of DevOps in 2026 is still 10 boring concepts executed under pressure: 1) Linux + networking basics. DNS vs TCP timeouts, conntrack, MTU, and why it works on the node but not in the pod. 2) Containers are packaging, not isolation. Know cgroups limits, file descriptors, PID 1, and how OOMKill looks in metrics and logs. 3) Kubernetes primitives. Deployments/Jobs, probes, requests vs limits, PDBs, and how rollouts actually fail (and wedge). 4) CI/CD with safety rails. Small diffs, fast rollback, canaries, and stopping a bad deploy automatically instead of paging humans. 5) State and data ownership. Backups you have restored, schema migrations with rollback plans, and the cost of cross-region replication. 6) Incident response as a system. Clear severity, runbooks that match reality, and postmortems that fix triggers not people. 7) Observability you can query. RED/USE, high-cardinality tradeoffs, traces for async hops, and sampling that doesn’t hide the bad tail. 8) Debugging production. Reproduce with real inputs, diff configs, check last change, and avoid SSH-driven fixes that never land in git. 9) Security as defaults. Least-privilege IAM, secret rotation, SBOMs, patch windows, and blocking outbound egress until needed. 10) Cost and capacity tradeoffs. Right-size, autoscale with guardrails, know p95 vs p99, and don’t confuse load tests with steady state traffic.
- 0Replies
- 1Reposts
- 34Likes
- 1.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 23
@shivam74689 ·
Day 127 — Becoming AI Engineer Today I learned that CI/CD is not simply "auto-deploy on push." It is a sequence of gates that progressively increases confidence that the code can safely reach production. The TicketPilot pipeline now follows: Code → Lint → Test → Docker Build → GHCR → SSH Deploy → Health Check Each stage has a different responsibility: • Lint checks code quality before deployment • Tests verify that the application still behaves correctly • Docker build confirms the application can be packaged successfully • GHCR stores the exact images produced by CI • SSH provides the secure connection from CI to the VPS • Deployment updates the running services • /health verifies that the live application is actually responding One important architectural decision was separating build from run. Instead of rebuilding TicketPilot manually on the VPS, GitHub Actions builds the Docker images in CI and pushes them to GitHub Container Registry. The VPS then pulls the exact image that CI produced. That gives me a much cleaner flow: Developer → GitHub → CI builds image → GHCR → VPS pulls image → Application runs The CI environment and production environment are separate systems, so deployment needs an explicit and secure mechanism to move the release from one environment to the other. I also learned that a successful deployment does not necessarily mean a working application. Containers can start successfully while the application is still broken because of: • PostgreSQL connection problems • Missing environment variables • Incorrect routing • Service dependency failures • Application-level errors That's why I added a final /health smoke check that tests the running application from the outside. The full chain I now care about is: Code → Lint → Tests → Docker Build → GHCR → VPS → Containers → /health → Live Application I also continued documenting the deployment process in runbook.md. The goal is simple: Deployment should not depend on my terminal history or memory. Another engineer should be able to understand: • what commands are required • what order they run in • why each step exists • what can fail • how to troubleshoot it The bigger lesson: "CI/CD is a confidence pipeline, not just an automation pipeline." Every stage removes a different class of failure before the system reaches the user. Together with the VPS hardening, DNS, Caddy, HTTPS, and Docker deployment from the previous stage, TicketPilot is now moving from a manually operated deployment toward a reproducible production workflow. Next: continue improving deployment reliability and operational confidence. #AI #AIEngineer #AgenticAI #Python #FastAPI #Docker #PostgreSQL #Redis #GenAI #DevOps #GitHubActions #BuildInPublic #LearningInPublic
- 7Replies
- 2Reposts
- 14Likes
- 597Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 24
@zavxai ·
Everyone wants to become a Software Engineer. Very few are talking about Platform Engineering. But every fast-growing engineering team eventually needs a platform that helps developers build, test, deploy, and scale software efficiently. If I were starting in 2026, this is the roadmap I’d follow: 1.Learn Linux, networking, and Git. 2.Master Docker and Kubernetes. 3.Learn cloud platforms like AWS, GCP, or Azure. 4.Understand Infrastructure as Code with Terraform. https://t.co/qkLetEEN51 CI/CD pipelines using GitHub Actions or GitLab CI. 6.Learn observability with Prometheus, Grafana, and OpenTelemetry. 7.Understand service meshes, API gateways, and microservices. 8.Learn scripting with Python, Go, or Bash. https://t.co/rmG6tL4CXL security fundamentals, secrets management, and IAM. https://t.co/8mKKEgw7vF internal developer platforms and automate repetitive workflows. Your portfolio should include: • A Kubernetes deployment from scratch. • A complete CI/CD pipeline. • Infrastructure managed with Terraform. • A monitoring dashboard with Prometheus and Grafana. • A self-service developer platform or deployment portal. Platform Engineers don’t just keep servers running. They build the infrastructure, tooling, and automation that enable developers to ship software faster, more reliably, and at scale. As engineering organizations continue to grow, Platform Engineering is becoming one of the most valuable and high-impact careers in software.
- 9Replies
- 1Reposts
- 11Likes
- 98Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 25
@anuraggoel ·
The best infrastructure shifts happen when a new application pattern breaks old assumptions. Agents are breaking a lot of them. They still need the basics: CI/CD, databases, caches, networking, previews, autoscaling, and IaC. But they also need isolated compute, long-running execution, disk-as-memory, and stateful workflow orchestration. Let's make agents boring to ship.
- 7Replies
- 4Reposts
- 36Likes
- 4.7KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 26
@DivyanshT91162 ·
Your AI coding agent won't help much when production goes down at 3 AM. OpenSRE is building AI agents for the problems that start after the code ships. It investigates incidents across logs, metrics, traces, cloud infrastructure, runbooks, and incident platforms to find the actual root cause instead of throwing guesses at the wall. The interesting part? They're not just building an agent. They're building the benchmark, training environment, and failure simulations needed to make AI SRE agents better over time. Think SWE-Bench for infrastructure incidents. 60+ integrations already supported, including Kubernetes, AWS, Datadog, Grafana, CloudWatch, PostgreSQL, Kafka, PagerDuty, Slack, OpenAI, Anthropic, Gemini, Ollama, and more. One of the more ambitious open-source AI infrastructure projects I've seen recently. Repo: https://t.co/h3YlfA6Pzk
- 2Replies
- 4Reposts
- 8Likes
- 551Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 27
@uday_devops ·
Cloud Engineer != DevOps Engineer📚 Let me clear this up once and for all. They're not interchangeable roles, no matter what those job descriptions tell you. Cloud Engineers own: ✔️Cloud infrastructure architecture, maintenance, Resource provisioning and management ✔️Migrations to cloud environments ✔️Security & Network Implementation ✔️Cost optimization strategies ✔️AI/ML infrastructure setup and scaling ✔️Managing GPU resources for AI workloads and more, depending on your cloud stack and niche DevOps Engineers drive: ✔️Development workflow optimization ✔️CI/CD pipelines and Infrastructure as Code (IaC) ✔️Deployment automation ✔️Breaking down dev–ops silos ✔️Monitoring, alerting, and logging ✔️Automating ML model deployment pipelines (MLOps) ✔️Building CI/CD for AI/ML experimentation and production Here's the interesting part: Modern cloud platforms are built with DevOps in mind. Think AWS CodePipeline, Azure DevOps, or Google Cloud Build ~ they're all devops services in the cloud.
- 5Replies
- 1Reposts
- 14Likes
- 219Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 28
@Techjunkie_Aman ·
Most people think Docker is complicated. It’s not. You’re just missing the point. Docker: • Packages your app + dependencies • Runs the same everywhere • Lightweight vs VMs • No “works on my machine” Think: Portable app box 📦 Why devs rely on it: • Faster setup (no manual installs) • Consistent environments • Easy testing (prod = local) • One-command deployment Core pieces: • Image → blueprint (layered, reusable) • Container → running instance • Dockerfile → build instructions Power features: • Docker Compose (multi-container apps) • Volumes (persistent data) • Networks (service communication) • Registries (share images) • BuildKit (faster builds) Infra benefits: • Works on local, cloud, CI/CD • Easy scaling (spin up/down) • Better resource usage • Isolation without heavy VMs Docker = dev → test → deploy Same environment. Zero surprises.
Watch video- 4Replies
- 3Reposts
- 25Likes
- 4.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 29
@_devEmmy ·
Day 37 of Coding – AI | Machine Learning 🚀 Hi guys, Just wrapped up Day 37. I was on seat for about 8 hours today working on deploying my FastAPI application on a real server. I walked through the full deployment pipeline on an AWS EC2 server running Ubuntu, which helped me understand what actually happens when you move a backend app from local development to the internet. I worked with nano to edit server configs, set up NGINX as a reverse proxy to forward traffic from port 80 to my FastAPI app on port 8000, and ran the app using Gunicorn with Uvicorn workers for production. I also created a systemd service so the app runs in the background and restarts automatically if the server reboots. Along the way I practiced debugging with logs and testing configs using nginx -t, which helped me catch and fix configuration errors. So the deployment flow now makes a lot more sense to me: Browser → NGINX → Gunicorn → FastAPI It’s interesting realizing this is the same pattern many real backend services use in production.
- 4Replies
- 5Reposts
- 23Likes
- 812Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 30
@brankopetric00 ·
AI can't replace DevOps Engineers, here's why: AI raises throughput and instability at the same time. DORA 2025 found AI adoption correlates with higher delivery throughput but a negative relationship with delivery stability. More changes, same blast radius. 66% of developers say the top AI frustration is output that is almost right, but not quite. Almost right in prod is an incident. 45% say debugging AI-generated code takes more time. Guess who debugs it at 3am. AI does not carry the pager. It cannot own a rollback decision. Half the job is not code. Vendors, permissions, cloud bill, saying no. No model knows why that one node group is pinned to an old AMI. That context lives in people (unfortunately). Compliance asks who approved the change. "The model suggested it" is not an answer. The tools got faster. The verification did not.
- 5Replies
- 1Reposts
- 34Likes
- 2.1KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 31
@ankit_ops2799 ·
If your CI/CD pipeline takes more than 15 minutes to run, your developers aren't building software. They're context-switching into oblivion waiting for a green checkmark. Slow feedback loops are the hidden productivity killer in modern engineering teams. Here's how to shrink build and test times from 20+ minutes down to under 3. 1. Cache your dependency layers aggressively: Stop re-downloading the same packages on every single run. Build and application layers should be cached separately, so a code change doesn't force a full dependency reinstall every time. 2. Parallelize your test suites: Running thousands of unit tests sequentially is an anti-pattern. Split them across parallel jobs instead of grinding through everything on one runner. 3. Spin up ephemeral test environments per PR: Don't queue pipelines waiting on a shared staging environment everyone's fighting over. Isolated environments created on-demand and destroyed after the PR closes remove that bottleneck entirely. 4. Move off resource-constrained default runners: Auto-scaling, properly resourced runner pools finish the same job in a fraction of the time. Fast CI/CD isn't a luxury. It's the difference between shipping 10 times a day or twice a week.
- 1Replies
- 0Reposts
- 4Likes
- 134Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 32
@RaulJuncoV ·
You wouldn’t ship a service with no tests. But teams are shipping agents with no evals. That’s the part nobody wants to admit. Most agent quality today is still a vibe check: “It worked in the demo.” “Users haven’t complained.” “The dashboard is green.” But green dashboards can lie. You update a system prompt, and everything looks fine. Then three days later, you find out the agent has been routing tool calls to the wrong endpoint 9% of the time. Same thing happens when you add a new tool. The agent gets a new capability. Then it starts using it in places where it shouldn’t. A real agent eval pipeline should include: 1. Tool correctness check. For every agent run in CI, assert that the right tools were called with the right parameters. Wrong tool call = failed test. 2. LLM-as-judge on production traces. Score live traces for faithfulness, hallucination risk, and goal completion. Not just “did the request finish?” Ask: “Did the agent do the right thing?” 3. Behavioral diff on every prompt change. Keep a golden set of inputs and expected outputs. Before a prompt ships, compare the new behavior against the baseline. Your prompts need regression tests too. 4. Intervention rate as a pipeline metric. Track how often humans override, correct, or roll back agent decisions. That metric matters as much as error rate. If it spikes after a deploy, behavior regressed. 5. Failure-to-dataset automation. Every edge case a reviewer touches should become a future test case. Production failures should feed the next eval suite. This is just CI/CD for agents. We already learned this lesson with software: You don’t trust code without tests. You shouldn’t trust agents without evals. What does your current agent eval pipeline look like?
- 9Replies
- 7Reposts
- 34Likes
- 2.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 33
@hamidships ·
the real "software factory" isn’t everyone using coding agents. that’s the 2x. the 10x is a different thing entirely. the loop starts closing on its own. 2x = every engineer using agents, ~100% AI-generated code. soon, that’ll be table stakes. you made the same loop faster, but the bottleneck is still human attention at every gate. 10x = the loop self validates. agents stop waiting on you. but it only works if the scaffolding is real: comprehensive CI, evals that actually catch regressions, and end-to-end test environments agents spin up to check their own work. to be clear, 10x is not "fewer humans." it is humans on the decisions that carry real risk and off the rote gates. we still need to hire exceptional engineers, their judgment is the scarce input now, so you spend it where it actually counts. but here is what breaks traditional SaaS instincts: building agents is divergent. fix one thing and 10 new things need evaluating. converging on that locally is a trap. so ship the 80/20 fast, but through controlled early access: opt-in design partners, clear guardrails, tiered rollout. never unfinished work dumped on people who did not sign up for it. then close the loop. feedback-loop agents take that signal, implement it, merge it, validate post-deploy, continuously. and because CI/CD is fast, the gap between "customer said X" and "X is live and validated" collapses. coding at the speed of thought. give agents the same context a human uses to make the call, user feedback, docs, prod monitoring, ephemeral test clusters. encode your review standards as rules the reviewer agent reads. auto-merge the low-risk stuff classified by your reviewer agent. reserve human eyes for billing, auth, the paths where a mistake is expensive. humans do not disappear, they concentrate. incidents stay human-led, business impact's too high to hand off, though agents now dig datadog + telemetry + code and hand you impact + root cause + mitigation in minutes. and someone guards the critical paths: as agentic volume climbs you risk losing deep understanding of your own codebase. the fix isn't to slow down — it is to lock down what's expensive to get wrong. Not all code carries equal risk. at Ramp, this is Inspect, our internal coding agent: deep Ramp context, MCP integrations, CI visibility, and self-validation that boots the UI and tests real workflows. On a recent UI change, it deployed a preview, authenticated as a fixture user, validated desktop and mobile behavior, and attached visual evidence to the PR. the metric I actually care about: fewest human touches per safely merged PR. not lines, not PR count. how much can the loop close on its own without breaking the things that matter and do it super fast? that's the edge.
- 3Replies
- 0Reposts
- 19Likes
- 11.3KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 34
@TosinOlugbenga ·
I just moved a production app off an online AI builder onto full local dev. Clone → configure → full stack running on any machine. Hosted builders are great for MVPs. Serious products need local-first. Why local matters If your app only runs in a hosted builder, you don't own your workflow.Local dev = faster loops, real debugging, reproducible envs, and confidence you're not shipping environment magic. The boring work The unglamorous migration work that actually pays off:• Docker Compose for one-command stack • Pinned tooling so builds don't drift • Split env files by concern • One onboarding doc, not five READMEsBoring = reliable. CI/CD angle Local working is step 1.Step 2: every PR gated, branch flow develop → staging → prod, images via GitHub Actions, DB migrations manual + confirmed.DevOps isn't flashy. It's how you ship without praying. Hot take Online AI building tools are brilliant for prototyping.But "works in the builder" ≠ "works for the team."Invest early in local-first + pipeline-first, or pay later. Punchy Moved off a hosted AI builder this week.Full stack runs locally. CI/CD owns deploy. No platform lock-in.Worth the migration pain.
- 5Replies
- 1Reposts
- 4Likes
- 265Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 35
@lucamezzalira ·
The most expensive belief in our industry is that a new architecture will fix the rest of the company. Unless you also decentralise the decision making, reassess who owns what, and rethink the team boundaries, the architecture will start raising friction instead of removing it. Pipelines slow down, deployments need coordination across three teams, bundle sizes creep up. The blame goes to the architecture when the architecture is just doing its job, which is surfacing the fact that something deeper isn't working. Most of the time it's not a tech problem at all. It's how communication flows inside the teams, it's the engineering culture, it's the org chart. The architecture is the messenger. This is the triangle I always come back to when I design distributed systems: architecture, organisational structure, and engineering culture, all three linked together. You cannot pull on one and ignore the other two and expect the system to work. At @ReactAdvanced in November I sat down to talk through all of this, plus the Tokyo flight that led to the first micro-frontend PoC at @DAZN, the 25-deployments-a-day teams I worked with, and why a CI/CD pipeline taking more than 15 minutes should stop everything else in the team until it's fixed. Check it out: https://t.co/DlYssTs7FJ
- 0Replies
- 2Reposts
- 10Likes
- 1.2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 36
@tristanbob ·
Software developers, how many of you perform security stages in your CI/CD pipeline, including secret leak detection, static application security testing (SAST), and dependency vulnerability scanning? My guess is that indie devs don't do these steps and enterprise does... but I'm not sure. (They are quite easy to add, FYI. It seems like a no-brainer, the only downside is the increased cost of runners)
- 1Replies
- 1Reposts
- 4Likes
- 350Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 37
@_vmlops ·
GOOGLE ENGINEERS WERE TIRED OF WRITING BASH so they built a tool that changed how developers script forever every developer has been there you start with a "simple" bash script 20 lines in, you're googling how to split a string 40 lines in, you're debugging why a variable has a space in it 60 lines in, you've rage-quit and called a python script from inside bash bash is powerful bash is also a special kind of torture → no JSON support → array handling that makes you question your career choices → error handling that silently fails and takes your sanity with it → string escaping that requires a computer science degree to understand google engineers felt this too so someone just... snapped. and built zx the idea was simple: what if you could write shell scripts in javascript...? that's it... real shell commands... real javascript... no glue code → async/await built in → full npm ecosystem access → try/catch for error handling like a normal human → JSON parsing without crying devops engineers, platform teams, and solo devs all said the same thing at the same time: "finally." the repo is google/zx. still actively maintained. still saving developers from bash-induced breakdowns daily the best tools aren't invented... they're born from frustration https://t.co/CETjGtIA8o
- 0Replies
- 1Reposts
- 5Likes
- 200Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 38
@HotAisle ·
I used AI to build this awesome self-hosted ephemeral GH runner solution on one of our extra servers. Crazy enough, as a test, I let Codex run remotely with ssh/sudo access (through Zed!). I gave specific instructions to ask for permission when it needed to do anything destructive or write data. That part worked flawlessly. The implementation wasn't perfect out the gate. I've tuned it over time. For example, AI missed some of the cleanup tasks that need to happen, but it was also no big deal to prompt it to fix things. Again, running amok as root. I baked all of our tooling (golang, etc...) into the base VM image, so that it just grabs the source and everything is already installed and ready to go. There is an AI generated 7400 line bash script that will rebuild the image with whatever versions we want. Cut our build times in half. Every build is done in a fresh VM, just like GH does. The script keeps 2 VM's running at all times and cleans up after itself, including telling GH to updates its state as well. It even keeps the GH App Access token refreshed. I'd love to document it as a blog post, but I can't figure out the best way to do that. It is kind of a gnarly set up with several bash scripts. I doubt anyone would read this and think to themselves: "Yea, I'll get right on that." Probably the best takeaway is that AI is really good at this stuff now and don't be afraid to try it. Something that would have taken expert devops a week+ of effort, is now minutes. Give it a try.
- 1Replies
- 0Reposts
- 8Likes
- 628Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 39
@alexanderOpalic ·
Everyone's asking which jobs AI will replace. Wrong question. The real shift isn't roles disappearing. It's roles merging, and the unit of accountability getting bigger per person. The teams that win will look like startups inside big companies. Fewer people, each owning more of the value chain end to end. Here's how I think it plays out. Most roles will either merge or become obsolete. Take business development and design. A designer will use agents to implement features directly, and the business person will do the same from their side. The handoffs that used to separate these roles start to disappear when anyone can turn intent into a working feature. Developers shift too. Less time writing every line by hand, more time managing the codebase, setting guardrails, and making sure the agents are actually doing the right thing. They'll still build their own features, but babysitting the agents becomes part of the job. Scrum is where I expect the biggest break. All the scrum related roles will fade out. Scrum was built for a world where humans had to write code by hand and coordinate every step. That world is ending. The coordination problem doesn't vanish, but it gets so much lighter that the heavy ceremony around it stops earning its keep. We need a new framework, not a faster version of the old one. So what stays fixed while everything else consolidates? Two things: security and devops. Not because AI can't touch them, but because they're where accountability concentrates. When agents write most of the code, the scarce skill becomes verifying, constraining, and securing what gets shipped. These roles don't shrink. They become the platform that everything else stands on. That's the shape I see coming. Small autonomous teams that operate like startups, each owning a slice of the product, supported by a platform team of security and devops that keeps the whole thing safe and running. Two questions I keep coming back to. How do you think roles will actually change as this lands? And would you still tell someone to start their career as a scrum master today?
- 1Replies
- 0Reposts
- 1Likes
- 187Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 40
@ThePracticalDev ·
Shipping code is only 99% of finishing a project. This dev breaks down what actually seals a release: versioned tags, branch hygiene, rulesets, release notes, licensing, CI/CD health, and more. Includes a checklist you can copy. { author: @georgekobaidze } https://t.co/DkiBmOOFQN
- 0Replies
- 0Reposts
- 6Likes
- 1.6KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 41
@chrsaravia ·
Day 40 of building Sara, my personal AI agent. "Sara, take the HTML file we built yesterday, add a draggable tennis ball that moves the ASCII art, push it to production. Add something to track visit analytics." This is where things start getting interesting. Not because of any single tool, but because multiple capabilities are compounding together. First, Sara taking on the coder role... She picked up yesterday's pretext project (from Day 39 post, shoutout to @_chenglou) and kept building. The page is a single HTML file with zero frameworks. "SARA" is rendered in ASCII characters on a canvas, each one flickering through a color wave. She drew a tennis ball entirely with canvas APIs (no image file), added gravity and bounce physics, and built a water-like effect where dragging the ball through the text displaces the characters and they spring back like a finger through water. All running Codex on my Mac Mini while I gave feedback over Telegram from my phone. Then, Sara the DevOps engineer... After my Day 38 post about Stripe Projects, @jeff_weinstein from Stripe's Product team replied on X and got me early access (thx jeff!)... I pointed Sara at the docs and told her to figure it out. She ran: → stripe projects init → stripe projects link vercel → stripe projects add posthog/analytics Linking my existing Stripe and Vercel accounts was straightforward. But that last command is the one worth paying attention to. I didn't have a PostHog account. Sara ran one command and Stripe Projects created the account from scratch, provisioned a project, and injected the environment variables into .env automatically. No signup form. No dashboard. No copy-paste. She added the analytics snippet, deployed to Vercel, and it was live. I opened PostHog and watched my own pageview events arrive in real time. Try it → https://t.co/yFDZ7G8vjh (drag the tennis ball through the text, or drop it and watch it bounce... silly project but useful to show the capabilities) One agent. One conversation. Code, infrastructure, deployment, analytics. All done by Sara, my ai agent. I'm convinced this is the future of how software gets built. Not just AI writing code, but AI provisioning the infrastructure the code needs to run. Hosting, analytics, databases, authentication... in this example, @stripe Projects makes all of it programmable from the command line. When infrastructure is programmable, agents can own the full loop from code to prod... Tiny bumps along the way still (some of these tools are in developer preview), but directionally this is where I see everything is heading... The human says what they want. The agent either builds it or picks the best provider for the job (e.g. vercel, posthog, yalo), sets it up, ships it, and tracks it. Exciting times...
Watch video- 0Replies
- 0Reposts
- 5Likes
- 156Views
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post. - 42
@ThePracticalDev ·
What does it look like to use Gemini CLI as your DevOps engineer? This dev deployed a LINE Bot cloud backup tool to Cloud Run by "talking" through each step, including the real pitfalls they hit along the way. { author: @Evan_Lin + @GoogleDevExpert } https://t.co/4asiStJvLR
- 0Replies
- 2Reposts
- 3Likes
- 2KViews
Rewrite this post in your own voice and angle.See the hook, structure, and reusable template behind this post.
Best DevOps tweets
Write posts like these, in your own voice
Xholic studies what works in your niche, drafts posts in your voice and schedules them for the hours your audience is online.
Start 3-day trial for $0Try the live demoTake a 2-minute tour of a sample account in the real app. No sign-up or login needed.
$0 today · Card required · Cancel anytime
Browse all tweet collectionsLive demo: no sign-up or login needed · takes about 2 minutes
Keep exploring
From the blog
- Twitter API Examples: A Practical Guide for BuildersExplore real Twitter API examples with code, auth flows, rate limits, and patterns for posting, streaming, analytics, and growth workflows on X.
- 10 X Analytics API Alternative Options for 2026Compare 10 X analytics API alternatives for 2026, from low-cost data providers and custom scrapers to enterprise listening platforms.
- 10 Best Twitter Bot Maker Tools for 2026Compare the best Twitter bot maker tools for 2026, from the official X API to no-code workflow builders, SDKs, and browser automation platforms.
More topics like this
- Best tweets about TypeScriptBrowse the best tweets about TypeScript, from type-system techniques and releases to tooling, architecture, migrations, libraries, and developer workflows.
- Best tweets about ReactExplore the best tweets about React, including components, hooks, Server Components, performance, state, architecture, releases, and production lessons.
- Best tweets about RustFind the best tweets about Rust programming, including ownership, async, performance, tooling, libraries, systems design, releases, and developer experience.
- Best tweets about Next.jsDiscover the best tweets about Next.js, covering App Router, Server Components, caching, rendering, performance, deployments, releases, and architecture.