<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: JacivaldoCarvalho</title>
    <description>The latest articles on DEV Community by JacivaldoCarvalho (@jacivaldocarvalho).</description>
    <link>https://dev.to/jacivaldocarvalho</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4201512%2F77b15e91-6f5c-4787-b0f8-b445e7d253cd.jpg</url>
      <title>DEV Community: JacivaldoCarvalho</title>
      <link>https://dev.to/jacivaldocarvalho</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/jacivaldocarvalho"/>
    <language>en</language>
    <item>
      <title>From Planning to the First Backend: Building the Foundation of JC SocialFlow AI</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Tue, 17 Nov 2026 03:35:00 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/from-planning-to-the-first-backend-building-the-foundation-of-jc-socialflow-ai-2g7a</link>
      <guid>https://dev.to/jacivaldocarvalho/from-planning-to-the-first-backend-building-the-foundation-of-jc-socialflow-ai-2g7a</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;FastAPI, PostgreSQL, Redis, Celery, and Docker — and the real-world challenges that emerged when everything had to work together.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every software project starts with an idea. But there is a considerable gap between defining what we want to build and having an application that actually works, is tested, and is ready to evolve.&lt;/p&gt;

&lt;p&gt;That is exactly the gap I started bridging with &lt;strong&gt;JC SocialFlow AI&lt;/strong&gt;, a personal software engineering project focused on social media content management and automation across platforms such as Instagram, Facebook, WhatsApp, TikTok, and YouTube.&lt;/p&gt;

&lt;p&gt;The goal is to build a platform capable of organizing, preparing, and eventually publishing content across multiple channels, combining automation, artificial intelligence, and human oversight.&lt;/p&gt;

&lt;p&gt;But before thinking about social media integrations or AI-powered features, I had a more important question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can I build a technical foundation that allows the project to grow without turning every new feature into an infrastructure problem?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That became the mission of Sprint 01.&lt;/p&gt;

&lt;p&gt;A quick note: in my current projects, I use &lt;em&gt;Sprint XX&lt;/em&gt; to describe development phases. Each phase has a defined scope, validation criteria, and a clear outcome.&lt;/p&gt;




&lt;h2&gt;
  
  
  First, the foundation
&lt;/h2&gt;

&lt;p&gt;During the previous phase, Sprint 00, I focused on planning: requirements, architecture, security, the roadmap, and component responsibilities.&lt;/p&gt;

&lt;p&gt;For the implementation, I chose a &lt;strong&gt;modular monolith with independent workers&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;It was a deliberate decision.&lt;/p&gt;

&lt;p&gt;Instead of starting with multiple microservices, each requiring its own infrastructure and operational considerations, I preferred to keep the backend within a modular application.&lt;/p&gt;

&lt;p&gt;Each module has clearly defined responsibilities, while the architecture leaves room to extract components later if there is a genuine need.&lt;/p&gt;

&lt;p&gt;This approach reduces initial operational complexity without sacrificing important engineering principles such as separation of concerns, testability, and observability.&lt;/p&gt;

&lt;p&gt;The technology stack includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Python 3.12+ and FastAPI:&lt;/strong&gt; API development and modular organization.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PostgreSQL and SQLAlchemy:&lt;/strong&gt; data persistence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Alembic:&lt;/strong&gt; versioned and controlled database migrations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Redis and Celery:&lt;/strong&gt; asynchronous task processing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Docker Compose:&lt;/strong&gt; integrated service execution.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;GNU Make:&lt;/strong&gt; standardized operational commands.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pytest and GitHub Actions:&lt;/strong&gt; automated testing and continuous integration.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The goal was not to use as many technologies as possible, but to ensure that each one had a clear purpose.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff8dz5nnlxpb5exxrl7xt.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff8dz5nnlxpb5exxrl7xt.png" alt="IMAGE 1 — JC SocialFlow AI architecture diagram" width="402" height="458"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1 — JC SocialFlow AI architecture after Sprint 01: a modular FastAPI backend, PostgreSQL persistence, and asynchronous processing with Redis and Celery.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  A simple API with important responsibilities
&lt;/h2&gt;

&lt;p&gt;The first step was turning the architecture into a working application.&lt;/p&gt;

&lt;p&gt;I built the API with FastAPI, organizing it into modules and preparing it to handle identity, auditing, and infrastructure concerns without mixing their responsibilities.&lt;/p&gt;

&lt;p&gt;I also implemented two endpoints that might look simple but make a significant difference during operation:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;GET /health/live
GET /health/ready
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The first checks whether the application process is running.&lt;/p&gt;

&lt;p&gt;The second checks whether the application is ready to handle operations that depend on PostgreSQL.&lt;/p&gt;

&lt;p&gt;This distinction became especially important during testing.&lt;/p&gt;

&lt;p&gt;At one point, the API responded successfully to the &lt;em&gt;liveness&lt;/em&gt; endpoint while returning HTTP 503 from the &lt;em&gt;readiness&lt;/em&gt; endpoint.&lt;/p&gt;

&lt;p&gt;In other words, the process was alive, but the application was not ready.&lt;/p&gt;

&lt;p&gt;That behavior helped uncover real configuration and database connectivity issues instead of hiding them behind a simple HTTP 200 response.&lt;/p&gt;

&lt;p&gt;I also introduced structured JSON logging, correlation IDs, and sanitized error handling.&lt;/p&gt;

&lt;p&gt;These details may not be particularly exciting in a visual demonstration, but they become extremely useful when something goes wrong.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F645rkejx0sjs60wr4j4q.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F645rkejx0sjs60wr4j4q.png" alt="IMAGE 2 — Terminal showing health endpoints and container status" width="800" height="322"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 2 — Local Docker Compose services and FastAPI health checks after completing Sprint 01.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Identity and security from the beginning
&lt;/h2&gt;

&lt;p&gt;Another important goal was establishing the first authentication and authorization mechanisms.&lt;/p&gt;

&lt;p&gt;The backend now uses &lt;strong&gt;Argon2id for password hashing&lt;/strong&gt;, along with opaque, revocable sessions managed through the database.&lt;/p&gt;

&lt;p&gt;I also implemented protections involving cookies, request origins, CSRF, and role-based and resource-owner authorization.&lt;/p&gt;

&lt;p&gt;On the PostgreSQL side, I separated database roles for administration, migrations, and application runtime.&lt;/p&gt;

&lt;p&gt;This means the database user used by the API does not need the same permissions as the user responsible for changing the database schema.&lt;/p&gt;

&lt;p&gt;Migrations are not executed automatically when the application starts, either.&lt;/p&gt;

&lt;p&gt;They must be triggered explicitly and require interactive confirmation when targeting the persistent local development database.&lt;/p&gt;

&lt;p&gt;This introduced a little more operational work, but it established an important distinction between &lt;strong&gt;running an application&lt;/strong&gt; and &lt;strong&gt;modifying its data structures&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;And, interestingly enough, this was where some of the most valuable lessons of the sprint emerged.&lt;/p&gt;




&lt;h2&gt;
  
  
  When an &lt;code&gt;@&lt;/code&gt; in a password becomes an infrastructure problem
&lt;/h2&gt;

&lt;p&gt;One of the most challenging parts of Sprint 01 involved PostgreSQL configuration and database migrations.&lt;/p&gt;

&lt;p&gt;The environment used Docker Compose with a persistent database volume.&lt;/p&gt;

&lt;p&gt;After some changes to the &lt;code&gt;.env&lt;/code&gt; file, the application stopped passing its readiness check.&lt;/p&gt;

&lt;p&gt;The first issue was relatively common: PostgreSQL retained users and passwords from the database's previous initialization.&lt;/p&gt;

&lt;p&gt;Changing an environment variable does not automatically update credentials already stored in a persistent database.&lt;/p&gt;

&lt;p&gt;I had to reconcile the existing database roles while preserving the data.&lt;/p&gt;

&lt;p&gt;Then came a more subtle issue.&lt;/p&gt;

&lt;p&gt;One of the passwords used during testing contained the &lt;code&gt;@&lt;/code&gt; character.&lt;/p&gt;

&lt;p&gt;In a database connection URL, this character has a special meaning. Without proper encoding, it can be interpreted as part of the URL structure, changing how the connection address is parsed.&lt;/p&gt;

&lt;p&gt;The solution involved applying the correct &lt;em&gt;percent-encoding&lt;/em&gt; to the URLs and strengthening configuration validation.&lt;/p&gt;

&lt;p&gt;But there was still a third issue.&lt;/p&gt;

&lt;p&gt;During Alembic execution, the configuration handling duplicated &lt;code&gt;%&lt;/code&gt; characters from the encoded password. As a result, PostgreSQL received credentials that differed from the intended values.&lt;/p&gt;

&lt;p&gt;I fixed the connection setup so the correctly encoded URL was preserved when creating the database engine.&lt;/p&gt;

&lt;p&gt;I also adjusted the migration command to prevent Docker Compose from unnecessarily recreating the database container.&lt;/p&gt;

&lt;p&gt;Eventually, Alembic revision &lt;code&gt;0002&lt;/code&gt; was successfully applied without removing the persistent volume.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson was straightforward:&lt;/strong&gt; a configuration can pass validation and still fail when it moves through different libraries.&lt;/p&gt;

&lt;p&gt;It is not enough to check whether a URL looks correct. You need to test the actual path through which that URL will be consumed.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkynt3x31ao956map70sk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkynt3x31ao956map70sk.png" alt="IMAGE 3 — Sanitized evidence showing Alembic revision  raw `0002` endraw  applied" width="592" height="176"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 3 — PostgreSQL confirms Alembic revision 0002_identity_security, while the FastAPI readiness endpoint returns HTTP 200.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Asynchronous processing without building features too early
&lt;/h2&gt;

&lt;p&gt;Another part of Sprint 01 involved preparing the asynchronous processing infrastructure.&lt;/p&gt;

&lt;p&gt;For this, I used Redis as the message broker and Celery to execute tasks in a worker running independently from the API.&lt;/p&gt;

&lt;p&gt;At this stage, the goal was not to publish content to social media platforms.&lt;/p&gt;

&lt;p&gt;Instead, I implemented a deterministic internal diagnostic task with no external side effects.&lt;/p&gt;

&lt;p&gt;This task allows me to validate the flow between the application, the queue, and the worker, including tracking execution through correlation IDs.&lt;/p&gt;

&lt;p&gt;The approach helped verify the infrastructure before introducing external integrations, platform credentials, or more complex publishing rules.&lt;/p&gt;

&lt;p&gt;During implementation, I also encountered issues involving dependencies and service startup behavior.&lt;/p&gt;

&lt;p&gt;Once again, the challenge was not simply getting each component to work independently.&lt;/p&gt;

&lt;p&gt;It was making sure they worked together.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvb0x5vz9l2hme0c9oo32.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvb0x5vz9l2hme0c9oo32.png" alt="IMAGE 4 — Celery worker logs showing successful diagnostic task execution" width="623" height="298"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 4 — Celery worker logs confirming successful completion of internal diagnostic tasks, with correlation IDs for execution tracking.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Making the environment reproducible
&lt;/h2&gt;

&lt;p&gt;With the main components implemented, the next challenge was simplifying local operations.&lt;/p&gt;

&lt;p&gt;Docker Compose now manages the API, PostgreSQL, Redis, and worker.&lt;/p&gt;

&lt;p&gt;PostgreSQL and Redis do not need to expose their ports directly to the host, while the API is accessible through the local loopback interface.&lt;/p&gt;

&lt;p&gt;To reduce manual commands and make operational procedures more consistent, I introduced a Makefile.&lt;/p&gt;

&lt;p&gt;Some examples:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;make up
make status
make check
make smoke
make down
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;make check&lt;/code&gt; command runs code checks and automated tests.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;make smoke&lt;/code&gt; command validates the integrated services.&lt;/p&gt;

&lt;p&gt;And &lt;code&gt;make down&lt;/code&gt; stops the services without removing persistent volumes.&lt;/p&gt;

&lt;p&gt;I also prepared a manual acceptance procedure covering authentication, sessions, and authorization.&lt;/p&gt;

&lt;p&gt;An unexpected issue appeared in the documentation itself.&lt;/p&gt;

&lt;p&gt;A command example using a &lt;em&gt;heredoc&lt;/em&gt; could leave the terminal waiting at a continuation prompt when the closing delimiter was not copied correctly.&lt;/p&gt;

&lt;p&gt;I replaced that example with a dedicated script that requests credentials interactively and displays only the necessary HTTP results.&lt;/p&gt;

&lt;p&gt;It was a useful reminder that &lt;strong&gt;operational documentation needs testing, too&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  Testing: from my local machine to GitHub Actions
&lt;/h2&gt;

&lt;p&gt;By the end of the sprint, the main components had gone through automated, integrated, and manual testing.&lt;/p&gt;

&lt;p&gt;The results included:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;20 passing Pytest tests.&lt;/li&gt;
&lt;li&gt;Five passing migration-validator tests.&lt;/li&gt;
&lt;li&gt;Regression tests using passwords containing &lt;code&gt;@&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Integrated smoke tests involving the API, PostgreSQL, and worker.&lt;/li&gt;
&lt;li&gt;Alembic revision &lt;code&gt;0002&lt;/code&gt; successfully applied and verified.&lt;/li&gt;
&lt;li&gt;Health endpoints returning HTTP 200.&lt;/li&gt;
&lt;li&gt;Successful manual functional acceptance.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I also published the continuous integration workflow through GitHub Actions.&lt;/p&gt;

&lt;p&gt;The final workflow run, triggered by the push of the Sprint 01 closing commit, completed successfully in &lt;strong&gt;1 minute and 26 seconds&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That does not mean the system is production-ready.&lt;/p&gt;

&lt;p&gt;It means the foundation has met the validation criteria defined for this development phase and can continue evolving in a controlled way.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxf3ovvldwmw69eealqr1.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxf3ovvldwmw69eealqr1.png" alt="IMAGE 5 — Successful Sprint 01 GitHub Actions workflow" width="799" height="286"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  What I learned along the way
&lt;/h2&gt;

&lt;p&gt;Sprint 01 reinforced a few principles that I consider important in software engineering.&lt;/p&gt;

&lt;p&gt;The first is that &lt;strong&gt;architectural simplicity does not mean a lack of engineering discipline&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;A modular monolith can include authentication, access control, versioned migrations, independent workers, observability, and integrated testing without starting as a collection of microservices.&lt;/p&gt;

&lt;p&gt;The second is that persistent infrastructure requires careful handling.&lt;/p&gt;

&lt;p&gt;Containers can be recreated, but volumes retain state. And that state does not necessarily follow changes made to configuration files.&lt;/p&gt;

&lt;p&gt;The third is that seemingly small problems can reveal deeper integration issues.&lt;/p&gt;

&lt;p&gt;A password containing a reserved character, for example, exposed differences in URL handling across libraries and tools.&lt;/p&gt;

&lt;p&gt;Finally, this sprint reinforced something I have learned repeatedly: &lt;strong&gt;automated tests do not completely replace operational validation&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Some of the most important issues appeared during manual acceptance, using the actual persistent local development environment.&lt;/p&gt;

&lt;p&gt;Those problems eventually became regression tests and improvements to the development process.&lt;/p&gt;




&lt;h2&gt;
  
  
  What's next?
&lt;/h2&gt;

&lt;p&gt;With Sprint 01 completed, JC SocialFlow AI now has an initial foundation that includes a modular API, persistence, identity, auditing, asynchronous processing, a reproducible local environment, and continuous integration.&lt;/p&gt;

&lt;p&gt;There is still plenty of work ahead.&lt;/p&gt;

&lt;p&gt;Backup and recovery, data retention, key rotation, production security hardening, and more advanced observability remain areas that need attention.&lt;/p&gt;

&lt;p&gt;Social media integrations, artificial intelligence features, media processing, and the user interface are also part of the project's planned evolution.&lt;/p&gt;

&lt;p&gt;My intention is to move forward one phase at a time, documenting architectural decisions, real-world problems, and lessons learned along the way.&lt;/p&gt;

&lt;p&gt;Because, in the end, building software is not just about implementing features.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It is about creating the conditions for a system to keep working — and evolving — as complexity grows.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  References and further reading
&lt;/h2&gt;

&lt;p&gt;The following official resources provide additional technical context for the technologies and engineering practices discussed in this article.&lt;/p&gt;

&lt;h3&gt;
  
  
  Architecture and API development
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;FastAPI — Official Documentation.&lt;/strong&gt; API development, dependency injection, application structure, and testing.&lt;br&gt;&lt;br&gt;
&lt;a href="https://fastapi.tiangolo.com/" rel="noopener noreferrer"&gt;https://fastapi.tiangolo.com/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Python Software Foundation — Python 3.12 Documentation.&lt;/strong&gt; Language and standard library reference.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.python.org/3.12/" rel="noopener noreferrer"&gt;https://docs.python.org/3.12/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;The Twelve-Factor App — Config and Processes.&lt;/strong&gt; Principles for application configuration and process separation.&lt;br&gt;&lt;br&gt;
&lt;a href="https://12factor.net/" rel="noopener noreferrer"&gt;https://12factor.net/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Database, migrations, and security
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;PostgreSQL — Database Roles.&lt;/strong&gt; Role management and database privileges.&lt;br&gt;&lt;br&gt;
&lt;a href="https://www.postgresql.org/docs/current/user-manag.html" rel="noopener noreferrer"&gt;https://www.postgresql.org/docs/current/user-manag.html&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;SQLAlchemy — Engine Configuration.&lt;/strong&gt; Database URLs, connection configuration, and special characters in passwords.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.sqlalchemy.org/en/20/core/engines.html" rel="noopener noreferrer"&gt;https://docs.sqlalchemy.org/en/20/core/engines.html&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Alembic — Official Documentation.&lt;/strong&gt; Database migrations with SQLAlchemy.&lt;br&gt;&lt;br&gt;
&lt;a href="https://alembic.sqlalchemy.org/en/latest/" rel="noopener noreferrer"&gt;https://alembic.sqlalchemy.org/en/latest/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;OWASP — Password Storage Cheat Sheet.&lt;/strong&gt; Password hashing recommendations, including Argon2id.&lt;br&gt;&lt;br&gt;
&lt;a href="https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html" rel="noopener noreferrer"&gt;https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;OWASP — Session Management Cheat Sheet.&lt;/strong&gt; Secure session management practices.&lt;br&gt;&lt;br&gt;
&lt;a href="https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html" rel="noopener noreferrer"&gt;https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Asynchronous processing and infrastructure
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Celery — Official Documentation.&lt;/strong&gt; Distributed task queues, workers, and asynchronous processing.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.celeryq.dev/en/stable/" rel="noopener noreferrer"&gt;https://docs.celeryq.dev/en/stable/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Redis — Official Documentation.&lt;/strong&gt; Redis concepts, configuration, and messaging capabilities.&lt;br&gt;&lt;br&gt;
&lt;a href="https://redis.io/docs/latest/" rel="noopener noreferrer"&gt;https://redis.io/docs/latest/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Docker — Compose Documentation.&lt;/strong&gt; Multi-container applications, services, and lifecycle management.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.docker.com/compose/" rel="noopener noreferrer"&gt;https://docs.docker.com/compose/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Docker — Volumes.&lt;/strong&gt; Persistent storage and volume lifecycle.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.docker.com/engine/storage/volumes/" rel="noopener noreferrer"&gt;https://docs.docker.com/engine/storage/volumes/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Testing and continuous integration
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Pytest — Official Documentation.&lt;/strong&gt; Automated testing and test organization.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.pytest.org/en/stable/" rel="noopener noreferrer"&gt;https://docs.pytest.org/en/stable/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;GitHub Actions — Official Documentation.&lt;/strong&gt; Continuous integration workflows and automation.&lt;br&gt;&lt;br&gt;
&lt;a href="https://docs.github.com/en/actions" rel="noopener noreferrer"&gt;https://docs.github.com/en/actions&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;GNU Make — Official Manual.&lt;/strong&gt; Build automation and reproducible commands.&lt;br&gt;&lt;br&gt;
&lt;a href="https://www.gnu.org/software/make/manual/" rel="noopener noreferrer"&gt;https://www.gnu.org/software/make/manual/&lt;/a&gt;&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This article is part of a series documenting the development of JC SocialFlow AI, following the project's evolution from architectural decisions to implementation and operation.&lt;/p&gt;

</description>
      <category>python</category>
      <category>fastapi</category>
      <category>devops</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Beyond Green CI: Building a More Trustworthy DevSecOps Pipeline</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Mon, 16 Nov 2026 15:12:00 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/beyond-green-ci-building-a-more-trustworthy-devsecops-pipeline-cih</link>
      <guid>https://dev.to/jacivaldocarvalho/beyond-green-ci-building-a-more-trustworthy-devsecops-pipeline-cih</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;How real container images, security checks, and CI failures helped improve the InfraPulse security pipeline.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;In &lt;a href="https://dev.to/jacivaldocarvalho/12-green-ci-jobs-422-security-findings-lessons-from-building-an-observability-platform-4hk4"&gt;Part 1 — 12 Green CI Jobs, 422 Security Findings&lt;/a&gt;, I shared an important lesson: even when all required CI checks pass, security scanners can still report hundreds of findings that need further investigation.&lt;/p&gt;

&lt;p&gt;In &lt;a href="https://dev.to/jacivaldocarvalho/from-422-security-findings-to-auditable-evidence-building-trust-in-a-devsecops-pipeline-2ikp"&gt;Part 2 — From 422 Security Findings to Auditable Evidence&lt;/a&gt;, I explored how InfraPulse evolved to produce more reliable evidence about software components, artifact integrity, and the software supply chain.&lt;/p&gt;

&lt;p&gt;Now, in Part 3, a new challenge emerged:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can we make sure these security checks still work when we move beyond controlled tests and start analyzing real container images?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That became the focus of the next stage of &lt;strong&gt;InfraPulse&lt;/strong&gt;, an open-source monitoring and observability platform I am building to explore software engineering, DevOps, DevSecOps, and Site Reliability Engineering (SRE) through practical implementation.&lt;/p&gt;

&lt;p&gt;The goal was to improve the security pipeline by connecting previously verified evidence to real container image analysis.&lt;/p&gt;

&lt;p&gt;This article covers what changed, the challenges I encountered, and the lessons learned along the way.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. The Challenge: Verification Is Not the Same as Trust
&lt;/h2&gt;

&lt;p&gt;Imagine an application running inside a Docker container.&lt;/p&gt;

&lt;p&gt;That container includes the application itself, operating system files, libraries, and other dependencies required to run.&lt;/p&gt;

&lt;p&gt;Before using the image, we might want to answer a few questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Are we analyzing the files we actually expected?&lt;/li&gt;
&lt;li&gt;Does the dependency inventory match the contents of the image?&lt;/li&gt;
&lt;li&gt;Was the information used for comparison properly verified?&lt;/li&gt;
&lt;li&gt;Can we confidently say that every software component was identified?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These questions sound similar, but they address different concerns.&lt;/p&gt;

&lt;p&gt;For example, a valid digital signature can help verify that an artifact has not changed and that it was signed using a key accepted by a configured trust policy.&lt;/p&gt;

&lt;p&gt;However, it does not automatically prove that every dependency was discovered or establish the real-world identity of the person or system that built the image.&lt;/p&gt;

&lt;p&gt;Similarly, two inventories may match without either one containing every component.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The first important lesson was that successful verification must come with clearly defined limits.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  2. How the InfraPulse Security Pipeline Evolved
&lt;/h2&gt;

&lt;p&gt;InfraPulse already had mechanisms for validating security evidence, including digital signatures, artifact information, and software component inventories.&lt;/p&gt;

&lt;p&gt;One of these inventories is called an &lt;strong&gt;SBOM (Software Bill of Materials)&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Think of an SBOM as an ingredient list for software. It records known components and dependencies associated with an application.&lt;/p&gt;

&lt;p&gt;The next step was to compare this information with the contents of real container images using the OCI format, a standard widely used in the container ecosystem.&lt;/p&gt;

&lt;h3&gt;
  
  
  A broader view of the security pipeline
&lt;/h3&gt;

&lt;p&gt;Before exploring the implementation details, it helps to understand how the different security checks fit together.&lt;/p&gt;

&lt;p&gt;The following diagram provides a high-level overview of the InfraPulse security pipeline, from source code and CI checks to container analysis, evidence verification, and reporting.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feomnkooavsaokzbt5ln0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feomnkooavsaokzbt5ln0.png" alt="Figure 1 — InfraPulse Final Security Pipeline" width="800" height="410"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1 — InfraPulse Security Pipeline Overview. Conceptual overview of code quality checks, container image analysis, security evidence, signature verification, and OCI inventory reconciliation. The pipeline preserves explicit coverage limitations rather than treating successful CI execution as proof of complete security.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The diagram highlights an important idea: security is not a single check performed at the end of development.&lt;/p&gt;

&lt;p&gt;It involves multiple activities, including code quality, testing, vulnerability analysis, artifact integrity, and evidence verification.&lt;/p&gt;

&lt;p&gt;Each activity contributes useful information, but no individual check can guarantee that an application is completely secure.&lt;/p&gt;

&lt;h3&gt;
  
  
  How the verification process works
&lt;/h3&gt;

&lt;p&gt;The integration implemented in this stage follows five main steps:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Receive the evidence package and independently defined trust requirements.&lt;/li&gt;
&lt;li&gt;Verify signatures, expected identities, and supporting information.&lt;/li&gt;
&lt;li&gt;Preserve the exact SBOM content that successfully passed verification.&lt;/li&gt;
&lt;li&gt;Compare that verified content against the inventory extracted from the container image.&lt;/li&gt;
&lt;li&gt;Report the results while keeping any limitations visible.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The most important detail is step three.&lt;/p&gt;

&lt;p&gt;Imagine a system verifies a file and then opens the same file path again a few seconds later.&lt;/p&gt;

&lt;p&gt;If the file changes between those operations, the system might end up processing something different from what it originally verified.&lt;/p&gt;

&lt;p&gt;To avoid that inconsistency, InfraPulse passes forward &lt;strong&gt;the exact data snapshot that was verified&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The principle is straightforward:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verifying an artifact is not enough. We also need to ensure that the data we use afterward is the data that passed verification.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This integration was delivered through &lt;a href="https://github.com/jacivaldocarvalho/jc-infrapulse/pull/15" rel="noopener noreferrer"&gt;Pull Request #15&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://github.com/jacivaldocarvalho/jc-infrapulse/actions/runs/43656845330" rel="noopener noreferrer"&gt;post-merge GitHub Actions workflow&lt;/a&gt; completed successfully.&lt;/p&gt;

&lt;h3&gt;
  
  
  An important verification limitation
&lt;/h3&gt;

&lt;p&gt;The implementation reuses the existing signed-evidence verifier instead of introducing a separate signature-verification mechanism.&lt;/p&gt;

&lt;p&gt;This reduces duplicated logic and helps maintain consistent verification behavior.&lt;/p&gt;

&lt;p&gt;However, the historical signing materials used in an earlier execution were not preserved with the real-image artifacts.&lt;/p&gt;

&lt;p&gt;As a result, that exact historical signed execution cannot be reproduced.&lt;/p&gt;

&lt;p&gt;The integration was exercised through automated tests, including mocked verifier interactions and real Cosign signing and verification in CI using disposable keys.&lt;/p&gt;

&lt;p&gt;These tests provide evidence that the implemented components work under the tested conditions.&lt;/p&gt;

&lt;p&gt;They do not reproduce the original historical signature chain.&lt;/p&gt;

&lt;p&gt;This distinction matters because &lt;strong&gt;testing an integration and reproducing a specific historical verification are not the same thing&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  3. Real Container Images Reveal Problems That Test Files May Miss
&lt;/h2&gt;

&lt;p&gt;During development, small and controlled test files are extremely useful.&lt;/p&gt;

&lt;p&gt;They make it easier to reproduce specific situations, such as invalid paths, malformed archives, or unexpected file structures.&lt;/p&gt;

&lt;p&gt;But real container images are more complicated.&lt;/p&gt;

&lt;p&gt;In this stage of the project, I worked with preserved archives from two images:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Backend:&lt;/strong&gt; the application and its dependencies.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Nginx:&lt;/strong&gt; the component used to serve the frontend.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These images contained variations of TAR archive metadata that the earlier tests did not fully represent.&lt;/p&gt;

&lt;p&gt;The image layer reader had to be extended to support the observed formats, including USTAR, a GNU TAR header variant, and selected PAX metadata.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why does this matter?
&lt;/h3&gt;

&lt;p&gt;A container image is not just one compressed file.&lt;/p&gt;

&lt;p&gt;It contains layers that describe changes to a filesystem. Understanding the resulting content requires interpreting those layers and their metadata correctly.&lt;/p&gt;

&lt;p&gt;If a tool encounters an unfamiliar format, guessing how to interpret it can produce misleading results.&lt;/p&gt;

&lt;p&gt;For this reason, the implementation follows a simple rule:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;If the reader encounters an unsupported structure, it rejects the input instead of silently accepting it.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This approach is known as &lt;em&gt;fail-closed&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;It does not make the reader compatible with every possible container image format. Instead, it helps prevent unsupported data from being treated as successfully analyzed.&lt;/p&gt;

&lt;p&gt;Some valid archive variations, such as compressed layers or unsupported PAX extensions, may still require additional implementation work.&lt;/p&gt;

&lt;h3&gt;
  
  
  What did the real-image validation show?
&lt;/h3&gt;

&lt;p&gt;The validation used image archives preserved from an earlier GitHub Actions execution.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Result&lt;/th&gt;
&lt;th&gt;Backend&lt;/th&gt;
&lt;th&gt;Nginx&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Layers processed&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inventory entries&lt;/td&gt;
&lt;td&gt;11,095&lt;/td&gt;
&lt;td&gt;2,214&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Files with content hashes&lt;/td&gt;
&lt;td&gt;9,228&lt;/td&gt;
&lt;td&gt;1,264&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;In total, &lt;strong&gt;24 layers were processed&lt;/strong&gt;, with checks against recorded file hashes, image identifiers, and layer information.&lt;/p&gt;

&lt;p&gt;These figures come from the project's validation report and should be confirmed against the retained execution evidence before publication.&lt;/p&gt;

&lt;p&gt;The result demonstrated that the reader could process those specific real images and their observed archive formats.&lt;/p&gt;

&lt;p&gt;It did not prove universal OCI compatibility or complete detection of every software component.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3crpyrcicewj7ngkbyih.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3crpyrcicewj7ngkbyih.png" alt="Figure 2 — Backend and Nginx Image Validation" width="800" height="410"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 2 — Real OCI Image Validation. InfraPulse analyzed two preserved container images: Backend and Nginx. Each image contained 12 processed layers, generating a total of 13,309 inventory entries and 10,492 files with content hashes. The validation included image identity and integrity checks, along with inventory comparison against the verified SBOM. The reported status remained COVERAGE_PARTIAL, indicating that successful validation does not guarantee universal OCI compatibility or complete identification of all software components.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Security Also Means Controlling Resource Usage
&lt;/h2&gt;

&lt;p&gt;Another important lesson was that security tools need protection too.&lt;/p&gt;

&lt;p&gt;Imagine receiving an unexpectedly large archive or one containing an excessive number of filesystem entries.&lt;/p&gt;

&lt;p&gt;Even without malicious code, processing that archive could consume too much memory, overload the CPU, or interrupt a service.&lt;/p&gt;

&lt;p&gt;To reduce that risk, I introduced explicit limits into the OCI layer reader.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Resource&lt;/th&gt;
&lt;th&gt;Implemented limit&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Bytes per layer&lt;/td&gt;
&lt;td&gt;128 MiB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Total layer bytes&lt;/td&gt;
&lt;td&gt;256 MiB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inventory entries&lt;/td&gt;
&lt;td&gt;100,000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Number of layers&lt;/td&gt;
&lt;td&gt;64&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Local PAX metadata&lt;/td&gt;
&lt;td&gt;1 MiB&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Additional restrictions cover file path length and depth.&lt;/p&gt;

&lt;p&gt;These values are specific defensive choices made for this implementation, not universal requirements of the OCI specification.&lt;/p&gt;

&lt;h3&gt;
  
  
  One limitation worth understanding
&lt;/h3&gt;

&lt;p&gt;These controls protect the reader, but they do not automatically protect every step before it.&lt;/p&gt;

&lt;p&gt;For example, a downloader could load an oversized archive into memory before the reader has an opportunity to reject it.&lt;/p&gt;

&lt;p&gt;A production-oriented solution therefore needs resource controls throughout the process, including:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Downloading artifacts.&lt;/li&gt;
&lt;li&gt;Extracting archives.&lt;/li&gt;
&lt;li&gt;Parsing image layers.&lt;/li&gt;
&lt;li&gt;Building inventories.&lt;/li&gt;
&lt;li&gt;Generating reports.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is an example of &lt;strong&gt;defense in depth&lt;/strong&gt;: using multiple layers of protection rather than relying on a single security check.&lt;/p&gt;

&lt;p&gt;The same principle applies to other systems that process external files, including backup tools, document processors, and software deployment pipelines.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. When a CI Failure Is Actually Good News
&lt;/h2&gt;

&lt;p&gt;During the implementation, GitHub Actions detected a Python formatting issue.&lt;/p&gt;

&lt;p&gt;The check was performed by &lt;strong&gt;Ruff&lt;/strong&gt;, a tool used to enforce code quality and formatting rules.&lt;/p&gt;

&lt;p&gt;The initial pipeline run failed.&lt;/p&gt;

&lt;p&gt;This was not a security vulnerability or a major architectural problem. The code simply did not meet one of the project's established quality requirements.&lt;/p&gt;

&lt;p&gt;After correcting the formatting issue, the required checks were executed again and passed.&lt;/p&gt;

&lt;p&gt;The workflow after the pull request was merged also completed successfully.&lt;/p&gt;

&lt;p&gt;This reinforced an important principle:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The goal of CI is not to stay green at all costs. Its purpose is to catch problems before they become part of the codebase.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A failure that is detected, understood, and corrected shows that a quality control is doing its job.&lt;/p&gt;

&lt;p&gt;The same reasoning applies to security checks.&lt;/p&gt;

&lt;p&gt;We need to distinguish between situations such as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A scanner completed successfully and reported vulnerabilities.&lt;/li&gt;
&lt;li&gt;A scanner failed before completing its analysis.&lt;/li&gt;
&lt;li&gt;A required security check never ran.&lt;/li&gt;
&lt;li&gt;An informational security audit reported findings without blocking the pipeline.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These results mean different things.&lt;/p&gt;

&lt;p&gt;Treating them as equivalent can create a false sense of security.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1hp49yyl1hatb4u4wjlo.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1hp49yyl1hatb4u4wjlo.png" alt="Figure 3 — GitHub Actions CI Failure and Recovery" width="800" height="409"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 3 — GitHub Actions Validation. The initial Ruff formatting failure was corrected before merge, followed by successful required checks and a successful post-merge workflow. Passing CI does not establish that the application is free from vulnerabilities.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  6. The Most Important Result Was Not a Green CI Pipeline
&lt;/h2&gt;

&lt;p&gt;By the end of this implementation stage, InfraPulse could validate the expected image information, process the supported layers, and compare image inventories against previously verified data.&lt;/p&gt;

&lt;p&gt;Even so, the final result retained an explicit status:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;COVERAGE_PARTIAL&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;In other words, &lt;strong&gt;partial coverage&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Why keep that status after so many checks succeeded?&lt;/p&gt;

&lt;p&gt;Because three concepts need to remain separate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Integrity:&lt;/strong&gt; Does the data match the expected values?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Authenticity:&lt;/strong&gt; What can we establish about the identity or authority behind an artifact or signature?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Completeness:&lt;/strong&gt; Have all relevant software components actually been identified?&lt;/p&gt;

&lt;p&gt;A tool may successfully verify file integrity without proving who originally built the image.&lt;/p&gt;

&lt;p&gt;Likewise, it may compare two inventories without proving that either inventory is complete.&lt;/p&gt;

&lt;p&gt;That is why InfraPulse does not turn a successful comparison into a claim of complete software coverage.&lt;/p&gt;

&lt;p&gt;The project also does not claim to have achieved a particular SLSA level.&lt;/p&gt;

&lt;h3&gt;
  
  
  What about the 422 security findings from Part 1?
&lt;/h3&gt;

&lt;p&gt;Those findings remain important context.&lt;/p&gt;

&lt;p&gt;The 422 records were scanner-reported occurrences across different tools and targets. They were not necessarily 422 unique, confirmed, exploitable vulnerabilities.&lt;/p&gt;

&lt;p&gt;This stage of the project did not demonstrate that all those findings had been eliminated.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A green CI pipeline does not mean zero vulnerabilities. It means the configured required checks passed under the conditions they evaluated.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Understanding that distinction is essential when interpreting security results.&lt;/p&gt;

&lt;p&gt;It also explains why maintaining the &lt;code&gt;COVERAGE_PARTIAL&lt;/code&gt; status is useful.&lt;/p&gt;

&lt;p&gt;Instead of presenting a stronger guarantee than the available evidence supports, the pipeline makes its coverage limitations explicit.&lt;/p&gt;




&lt;h2&gt;
  
  
  7. Five Lessons I Learned Along the Way
&lt;/h2&gt;

&lt;p&gt;This stage of InfraPulse brought several lessons that apply beyond this particular project.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Use the data that was actually verified
&lt;/h3&gt;

&lt;p&gt;When an artifact passes validation, avoid later using another version that could have changed.&lt;/p&gt;

&lt;p&gt;This applies to SBOMs, configuration files, deployment manifests, and other security-sensitive data.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Keep trust requirements independent
&lt;/h3&gt;

&lt;p&gt;Trusted keys, expected image identifiers, and verification policies should not be defined solely by the artifact being examined.&lt;/p&gt;

&lt;p&gt;Otherwise, an artifact could effectively set its own acceptance rules.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Combine controlled tests with real artifacts
&lt;/h3&gt;

&lt;p&gt;Small test fixtures help reproduce specific problems.&lt;/p&gt;

&lt;p&gt;Real artifacts reveal compatibility issues and unexpected details that controlled tests may miss.&lt;/p&gt;

&lt;p&gt;Both approaches are valuable, but they answer different questions.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Protect the entire processing flow
&lt;/h3&gt;

&lt;p&gt;A parser limit cannot prevent excessive memory usage if the downloader has already loaded a huge file.&lt;/p&gt;

&lt;p&gt;Resource controls need to cover every relevant stage.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Never claim more than the evidence supports
&lt;/h3&gt;

&lt;p&gt;A valid signature, a matching inventory, a successful scanner execution, and a green CI result are all useful.&lt;/p&gt;

&lt;p&gt;But they do not prove the same thing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Reliable engineering means understanding what each result confirms—and what remains uncertain.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That was probably the most valuable lesson from this implementation.&lt;/p&gt;




&lt;h2&gt;
  
  
  8. What Still Needs Improvement
&lt;/h2&gt;

&lt;p&gt;The planned integration was completed, but several opportunities for improvement remain.&lt;/p&gt;

&lt;p&gt;One is extending image format compatibility while maintaining safe parsing behavior.&lt;/p&gt;

&lt;p&gt;Another is improving the ability to reproduce earlier security validations.&lt;/p&gt;

&lt;p&gt;Different categories of evidence currently have different retention periods:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Artifact&lt;/th&gt;
&lt;th&gt;Retention&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Preserved image archives&lt;/td&gt;
&lt;td&gt;1 day&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sanitized reports&lt;/td&gt;
&lt;td&gt;7 days&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unsigned CI evidence&lt;/td&gt;
&lt;td&gt;30 days&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This means a report may remain available after the original files needed to reproduce its results have already been removed.&lt;/p&gt;

&lt;p&gt;Additionally, the disposable signing materials used in an earlier historical verification were not preserved, so that exact signed execution cannot be replayed.&lt;/p&gt;

&lt;p&gt;This revealed another important distinction:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Keeping a report is not necessarily the same as preserving everything required to reproduce it.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Evidence retention and reproducibility are related, but they are not identical.&lt;/p&gt;

&lt;p&gt;A project may retain summary reports for weeks while no longer having access to the exact image archives or signatures used in an earlier verification.&lt;/p&gt;

&lt;p&gt;This is something worth considering when designing CI/CD pipelines that need to support audits or repeatable investigations.&lt;/p&gt;

&lt;p&gt;Beyond the security pipeline, future areas of exploration include service-level indicators, actionable alerts, failure recovery, and repeatable operational procedures.&lt;/p&gt;

&lt;p&gt;These are potential improvements, not features being claimed as completed here.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4b8eu3kvumc4o36ahsa2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4b8eu3kvumc4o36ahsa2.png" alt="Figure 4 — Evidence Retention and Reproducibility" width="800" height="409"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 4 — Evidence Retention and Reproducibility. Image archives, sanitized reports, and unsigned CI evidence have different retention periods. Preserving a report does not necessarily preserve all materials required to reproduce the original verification.&lt;/em&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  9. Conclusion
&lt;/h2&gt;

&lt;p&gt;This stage of InfraPulse demonstrated that implementing security controls is only part of the challenge.&lt;/p&gt;

&lt;p&gt;We also need to verify that those controls work with real files, handle unexpected inputs safely, and produce results that can be interpreted correctly.&lt;/p&gt;

&lt;p&gt;Throughout this implementation, I:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Connected verified security evidence to OCI image inventory analysis.&lt;/li&gt;
&lt;li&gt;Extended the reader to handle formats encountered in real images.&lt;/li&gt;
&lt;li&gt;Introduced resource limits to reduce processing risks.&lt;/li&gt;
&lt;li&gt;Fixed an issue detected by CI before merging.&lt;/li&gt;
&lt;li&gt;Completed the integration with the required checks passing.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But the most important lesson was understanding that &lt;strong&gt;a reliable system must recognize its own limits&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;A green pipeline, a valid signature, or a well-structured report is not enough on its own.&lt;/p&gt;

&lt;p&gt;We need to understand what each result actually proves.&lt;/p&gt;

&lt;p&gt;InfraPulse continues to evolve as an open-source project focused on practical software engineering, DevOps, DevSecOps, and SRE.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;GitHub:&lt;/strong&gt; &lt;a href="https://github.com/jacivaldocarvalho/jc-infrapulse" rel="noopener noreferrer"&gt;https://github.com/jacivaldocarvalho/jc-infrapulse&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;There are still challenges to explore, solutions to test, and lessons to share.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Until next time!&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  References and Tools
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/jacivaldocarvalho/jc-infrapulse" rel="noopener noreferrer"&gt;InfraPulse — GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/opencontainers/image-spec" rel="noopener noreferrer"&gt;OCI Image Specification&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://cyclonedx.org/specification/overview/" rel="noopener noreferrer"&gt;CycloneDX Specification&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.sigstore.dev/cosign/verifying/verify/" rel="noopener noreferrer"&gt;Sigstore Cosign — Signature Verification&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://slsa.dev/spec/v1.2/" rel="noopener noreferrer"&gt;SLSA Specification&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://in-toto.io/docs/specs/" rel="noopener noreferrer"&gt;in-toto Specifications&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.github.com/en/actions" rel="noopener noreferrer"&gt;GitHub Actions Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://trivy.dev/docs/latest/target/container_image/" rel="noopener noreferrer"&gt;Trivy — Container Image Scanning&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>devsecops</category>
      <category>devops</category>
      <category>security</category>
      <category>cicd</category>
    </item>
    <item>
      <title>Local AI Video Generation: ComfyUI and LTX-Video 2B on an RTX 3050 6GB</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Wed, 04 Nov 2026 23:12:20 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/local-ai-video-generation-comfyui-and-ltx-video-2b-on-an-rtx-3050-6gb-38nj</link>
      <guid>https://dev.to/jacivaldocarvalho/local-ai-video-generation-comfyui-and-ltx-video-2b-on-an-rtx-3050-6gb-38nj</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Phase 00 — Building a local AI-powered video generation pipeline.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  1. Introduction
&lt;/h2&gt;

&lt;p&gt;AI-powered video generation has evolved significantly, but running generative models locally remains challenging, especially on computers with limited hardware resources.&lt;/p&gt;

&lt;p&gt;Many demonstrations rely on high-performance GPUs with substantial VRAM or cloud-based computing platforms.&lt;/p&gt;

&lt;p&gt;This raises an interesting question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is it possible to generate AI videos using a laptop GPU with only 6GB of VRAM?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;To investigate this, I started &lt;strong&gt;JC IA Video&lt;/strong&gt;, a project focused on developing a local text-to-video generation pipeline.&lt;/p&gt;

&lt;p&gt;The goal is not simply to generate videos, but to understand the underlying infrastructure, identify technical limitations, and progressively build an automated solution.&lt;/p&gt;

&lt;p&gt;In this initial stage, called &lt;strong&gt;Phase 00&lt;/strong&gt;, the objective was to validate local execution of ComfyUI with the LTX-Video 2B model and produce usable MP4 files.&lt;/p&gt;

&lt;p&gt;The result was a functional proof of concept, including the resolution of a real issue involving animated WebP conversion.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Phase 00 Objectives
&lt;/h2&gt;

&lt;p&gt;The experiment was organized around five primary objectives:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Configure a Python environment with NVIDIA GPU support.&lt;/li&gt;
&lt;li&gt;Run ComfyUI locally using memory optimization techniques.&lt;/li&gt;
&lt;li&gt;Load LTX-Video 2B and generate videos from text prompts.&lt;/li&gt;
&lt;li&gt;Convert generated outputs into H.264 MP4 files.&lt;/li&gt;
&lt;li&gt;Validate the resulting media files and document the findings.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;An important requirement was to keep inference entirely local, without relying on external inference services.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Hardware and Software Environment
&lt;/h2&gt;

&lt;p&gt;The experiment was conducted on an Alienware 16 Aurora laptop with the following configuration:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Component&lt;/th&gt;
&lt;th&gt;Configuration&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Device&lt;/td&gt;
&lt;td&gt;Alienware 16 Aurora&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Operating system&lt;/td&gt;
&lt;td&gt;Ubuntu Linux&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPU&lt;/td&gt;
&lt;td&gt;NVIDIA GeForce RTX 3050 Laptop&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;VRAM&lt;/td&gt;
&lt;td&gt;6 GB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;System RAM&lt;/td&gt;
&lt;td&gt;16 GB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;3.12.3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ComfyUI&lt;/td&gt;
&lt;td&gt;0.44.0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PyTorch&lt;/td&gt;
&lt;td&gt;2.15.0+cu132&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Generative model&lt;/td&gt;
&lt;td&gt;LTX-Video 2B v0.9.5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Video processing&lt;/td&gt;
&lt;td&gt;FFmpeg 6.1.1&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The limited amount of VRAM was one of the main constraints.&lt;/p&gt;

&lt;p&gt;For this reason, the initial configuration prioritized low resolutions, short videos, and memory-efficient execution.&lt;/p&gt;

&lt;h3&gt;
  
  
  Evidence 01 — GPU Detection
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmry7wt73qhebivwxaasw.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmry7wt73qhebivwxaasw.png" alt="Figure 1 — NVIDIA RTX 3050 Laptop GPU detected by the operating system, with 6GB of VRAM." width="800" height="399"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1 — NVIDIA RTX 3050 Laptop GPU detected by the operating system, with 6GB of VRAM.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The screenshot should display the GPU model, driver version, and available memory.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Solution Architecture
&lt;/h2&gt;

&lt;p&gt;The initial pipeline was built using tools with clearly separated responsibilities.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;                    Text Prompt
                         |
                         v
                       ComfyUI
                         |
                         v
                   LTX-Video 2B
                         |
                         v
                    CUDA Inference
                         |
                         v
                   Generated Frames
                         |
                         v
                    Animated WebP
                         |
                         v
                       Pillow
                   Frame Extraction
                         |
                         v
                       FFmpeg
                    H.264 Encoding
                         |
                         v
                      Final MP4
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;ComfyUI provides the interface for executing AI generation workflows.&lt;/p&gt;

&lt;p&gt;LTX-Video generates the visual frames based on the supplied conditioning inputs.&lt;/p&gt;

&lt;p&gt;Pillow processes frames from animated WebP files, while FFmpeg handles the final MP4 encoding.&lt;/p&gt;

&lt;p&gt;This separation of responsibilities will become particularly important in future phases, when the workflow is controlled by a dedicated Python application.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Configuring ComfyUI
&lt;/h2&gt;

&lt;p&gt;ComfyUI was installed inside a Python virtual environment to isolate its dependencies.&lt;/p&gt;

&lt;p&gt;The application was launched using:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/projects/jc-ia-video/ComfyUI

&lt;span class="nb"&gt;source&lt;/span&gt; .venv/bin/activate

python main.py &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--listen&lt;/span&gt; 127.0.0.1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--port&lt;/span&gt; 8188 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--lowvram&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;--lowvram&lt;/code&gt; parameter was used to adapt execution to the GPU's memory constraints.&lt;/p&gt;

&lt;p&gt;The application was available at:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;http://127.0.0.1:8188&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The environment successfully initialized with CUDA support and memory management mechanisms, including DynamicVRAM and model weight offloading between system memory and GPU memory.&lt;/p&gt;

&lt;p&gt;These mechanisms do not eliminate hardware limitations, but they help make certain workloads feasible on GPUs with limited VRAM.&lt;/p&gt;

&lt;h3&gt;
  
  
  Evidence 02 — ComfyUI Execution and Model Loading
&lt;/h3&gt;

&lt;p&gt;The logs recorded dynamic model loading and three completed executions.&lt;/p&gt;

&lt;p&gt;Selected log entries:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[INFO] To see the GUI go to: http://127.0.0.1:8188
[INFO] Requested to load LTXV
[INFO] Model LTXV prepared for dynamic VRAM loading.
[INFO] Requested to load VideoVAE
[INFO] Prompt executed in 16.72 seconds
[INFO] Prompt executed in 6.87 seconds
[INFO] Prompt executed in 12.01 seconds
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;These messages confirm that ComfyUI was accessible, the inference components were prepared, and all three prompts completed execution.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr36b1gv1iz2nowc44utd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr36b1gv1iz2nowc44utd.png" alt="Figure 2 — ComfyUI logs showing dynamic loading of LTXV and VideoVAE models and three completed prompt executions." width="800" height="193"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 2 — ComfyUI logs showing dynamic loading of LTXV and VideoVAE models and three completed prompt executions.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The full logs also recorded text encoder preparation and execution of the 12 sampling steps.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Models Used
&lt;/h2&gt;

&lt;p&gt;Two main components were used for video generation.&lt;/p&gt;

&lt;h3&gt;
  
  
  LTX-Video 2B v0.9.5
&lt;/h3&gt;

&lt;p&gt;The generative model responsible for producing visual content.&lt;/p&gt;

&lt;p&gt;Model file:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;models/checkpoints/
└── ltx-video-2b-v0.9.5.safetensors
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  T5 XXL FP8
&lt;/h3&gt;

&lt;p&gt;The text encoder used to process text conditioning inputs.&lt;/p&gt;

&lt;p&gt;Model file:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;models/text_encoders/
└── t5xxl_fp8_e4m3fn_scaled.safetensors
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The LTX-Video model was downloaded from Hugging Face.&lt;/p&gt;

&lt;p&gt;The text encoder was made available to ComfyUI through a symbolic link pointing to a file already stored in the local Hugging Face cache.&lt;/p&gt;

&lt;p&gt;This avoided creating another copy of approximately 4.9GB.&lt;/p&gt;

&lt;p&gt;One important operational consideration is that deleting the original cached file would break the symbolic link.&lt;/p&gt;

&lt;p&gt;Model weights are excluded from the project's Git repository.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Building the Generation Workflow
&lt;/h2&gt;

&lt;p&gt;After configuring the environment, I loaded a text-to-video workflow compatible with LTX-Video.&lt;/p&gt;

&lt;p&gt;The workflow connects components responsible for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Checkpoint loading.&lt;/li&gt;
&lt;li&gt;Text encoder loading.&lt;/li&gt;
&lt;li&gt;Positive and negative prompt processing.&lt;/li&gt;
&lt;li&gt;Video latent configuration.&lt;/li&gt;
&lt;li&gt;Sampling schedule configuration.&lt;/li&gt;
&lt;li&gt;Frame generation.&lt;/li&gt;
&lt;li&gt;Output decoding.&lt;/li&gt;
&lt;li&gt;Animated WebP export.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Evidence 03 — Workflow and Generation Parameters
&lt;/h3&gt;

&lt;p&gt;Conservative generation parameters were selected to reduce resource consumption.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Parameter&lt;/th&gt;
&lt;th&gt;Value&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Landscape resolution&lt;/td&gt;
&lt;td&gt;512 × 288&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Portrait resolution&lt;/td&gt;
&lt;td&gt;288 × 512&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Frames&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Frame rate&lt;/td&gt;
&lt;td&gt;8 FPS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sampling steps&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CFG&lt;/td&gt;
&lt;td&gt;3.0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sampler&lt;/td&gt;
&lt;td&gt;&lt;code&gt;res_multistep&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Batch size&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;With 25 frames at 8 FPS, each video has a nominal duration of:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;25 / 8 = 3.125 seconds.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The portrait resolution of 288 × 512 preserves the 9:16 aspect ratio commonly used by TikTok, Instagram Reels, and YouTube Shorts.&lt;/p&gt;

&lt;p&gt;However, this resolution is significantly lower than typical production-quality video resolutions.&lt;/p&gt;

&lt;p&gt;The purpose of this phase was to validate the generation pipeline, not to achieve final production quality.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb1d5w2gp7s0v0in30mh2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb1d5w2gp7s0v0in30mh2.png" alt="LTX-Video 2B text-to-video workflow in ComfyUI, including generation parameters." width="800" height="429"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 3 — LTX-Video 2B text-to-video workflow in ComfyUI, including generation parameters.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;This screenshot combines the visual workflow architecture and the relevant configuration values.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. First Generation Results
&lt;/h2&gt;

&lt;p&gt;The workflow successfully generated three animated WebP files.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;File&lt;/th&gt;
&lt;th&gt;Resolution&lt;/th&gt;
&lt;th&gt;Frames&lt;/th&gt;
&lt;th&gt;FPS&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00001_.webp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;512 × 288&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00002_.webp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;512 × 288&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00003_.webp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;288 × 512&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;During generation, GPU utilization was observed reaching 100% at one point.&lt;/p&gt;

&lt;p&gt;This indicates intensive GPU processing, although it does not establish that the GPU remained fully utilized throughout the entire inference process.&lt;/p&gt;

&lt;h3&gt;
  
  
  Execution Times
&lt;/h3&gt;

&lt;p&gt;ComfyUI recorded the following execution times:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Execution&lt;/th&gt;
&lt;th&gt;Recorded Time&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;First&lt;/td&gt;
&lt;td&gt;16.72 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Second&lt;/td&gt;
&lt;td&gt;6.87 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Third&lt;/td&gt;
&lt;td&gt;12.01 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The first execution may include additional model loading and initialization overhead.&lt;/p&gt;

&lt;p&gt;These values represent execution times reported by ComfyUI. They should not be interpreted as controlled benchmark results.&lt;/p&gt;

&lt;p&gt;Repeated tests under standardized conditions will be required to evaluate performance, consistency, and resource consumption.&lt;/p&gt;

&lt;h3&gt;
  
  
  Demo — Portrait Video (9:16)
&lt;/h3&gt;

&lt;p&gt;The third video was generated at 288 × 512 pixels, with 25 frames and a frame rate of 8 FPS.&lt;/p&gt;

&lt;p&gt;The result was published on YouTube Shorts as a visual demonstration of the proof of concept.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://www.youtube.com/shorts/SrLoz3rJNZc" rel="noopener noreferrer"&gt;Watch the AI-generated video on YouTube Shorts&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.youtube.com/shorts/SrLoz3rJNZc" rel="noopener noreferrer"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7mq2nj1astjc6obe5ml6.jpg" alt="JC IA Video — Phase 00 Demonstration" width="480" height="360"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Demo 1 — Portrait video generated locally using ComfyUI and LTX-Video 2B on an RTX 3050 Laptop GPU with 6GB of VRAM.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;This demonstration provides a visual reference for the model's output, complementing the configuration and execution evidence.&lt;/p&gt;

&lt;h2&gt;
  
  
  9. A Real Issue: FFmpeg and Animated WebP
&lt;/h2&gt;

&lt;p&gt;After generating the videos, I encountered an issue while converting the output files to MP4.&lt;/p&gt;

&lt;p&gt;The first attempt used FFmpeg directly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ffmpeg &lt;span class="nt"&gt;-i&lt;/span&gt; input.webp &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-c&lt;/span&gt;:v libx264 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-pix_fmt&lt;/span&gt; yuv420p &lt;span class="se"&gt;\&lt;/span&gt;
  output.mp4
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;However, the FFmpeg version available in the environment could not correctly decode the animated WebP files produced by ComfyUI.&lt;/p&gt;

&lt;p&gt;The observed messages included:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;skipping unsupported chunk: ANIM
skipping unsupported chunk: ANMF
image data not found
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The conversion process failed to produce valid MP4 videos.&lt;/p&gt;

&lt;p&gt;Subsequent validation also identified invalid media containers, including the error:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;moov atom not found
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This demonstrated an important lesson: the existence of a file with an &lt;code&gt;.mp4&lt;/code&gt; extension does not guarantee that it contains a valid, playable video.&lt;/p&gt;

&lt;p&gt;The container structure and media metadata must be validated.&lt;/p&gt;

&lt;p&gt;The original terminal screenshots were not preserved. Therefore, the error messages recorded during the experiment are included as textual evidence.&lt;/p&gt;

&lt;h2&gt;
  
  
  10. The Solution: Pillow + FFmpeg
&lt;/h2&gt;

&lt;p&gt;To work around the decoding limitation, I separated the conversion process into two stages.&lt;/p&gt;

&lt;p&gt;First, Pillow extracts individual frames from the animated WebP file.&lt;/p&gt;

&lt;p&gt;Then, FFmpeg encodes those frames into an H.264 MP4 video.&lt;/p&gt;

&lt;p&gt;The updated pipeline became:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Animated WebP
     |
     v
   Pillow
     |
     v
Temporary PNG Frames
     |
     v
FFmpeg / libx264
     |
     v
  H.264 MP4
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I created a Python script to automate this conversion.&lt;/p&gt;

&lt;p&gt;The initial implementation uses &lt;code&gt;Image.open()&lt;/code&gt; to read the animated WebP frames, &lt;code&gt;TemporaryDirectory()&lt;/code&gt; to store temporary PNG files, and &lt;code&gt;subprocess.run()&lt;/code&gt; to execute FFmpeg.&lt;/p&gt;

&lt;p&gt;A simplified example of the frame extraction process:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;PIL&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Image&lt;/span&gt;

&lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;Image&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;input.webp&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;n_frames&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;seek&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;frame&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;convert&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;RGB&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;frame&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;save&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="si"&gt;:&lt;/span&gt;&lt;span class="mi"&gt;05&lt;/span&gt;&lt;span class="n"&gt;d&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;.png&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The extracted frames can then be encoded using:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ffmpeg &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-framerate&lt;/span&gt; 8 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-i&lt;/span&gt; &lt;span class="s2"&gt;"%05d.png"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-c&lt;/span&gt;:v libx264 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-pix_fmt&lt;/span&gt; yuv420p &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-movflags&lt;/span&gt; +faststart &lt;span class="se"&gt;\&lt;/span&gt;
  output.mp4
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;yuv420p&lt;/code&gt; pixel format improves compatibility with media players and online platforms.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;+faststart&lt;/code&gt; option relocates MP4 metadata to support progressive playback more efficiently.&lt;/p&gt;

&lt;p&gt;The initial converter assumes a constant frame rate. Handling variable frame durations remains a potential improvement for a future version.&lt;/p&gt;

&lt;h2&gt;
  
  
  11. Validating the MP4 Files
&lt;/h2&gt;

&lt;p&gt;After implementing the conversion script, all three WebP files were successfully processed.&lt;/p&gt;

&lt;p&gt;The recorded output was:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;OK: ComfyUI_00001_.mp4 | 25 frames | 8.00 FPS
OK: ComfyUI_00002_.mp4 | 25 frames | 8.00 FPS
OK: ComfyUI_00003_.mp4 | 25 frames | 8.00 FPS
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I then used &lt;code&gt;ffprobe&lt;/code&gt; to inspect the generated media metadata.&lt;/p&gt;

&lt;p&gt;The results were:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;File&lt;/th&gt;
&lt;th&gt;Resolution&lt;/th&gt;
&lt;th&gt;FPS&lt;/th&gt;
&lt;th&gt;Duration&lt;/th&gt;
&lt;th&gt;File Size&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00001_.mp4&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;512×288&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;3.125 s&lt;/td&gt;
&lt;td&gt;43,349 bytes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00002_.mp4&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;512×288&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;3.125 s&lt;/td&gt;
&lt;td&gt;46,037 bytes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ComfyUI_00003_.mp4&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;288×512&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;3.125 s&lt;/td&gt;
&lt;td&gt;157,615 bytes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Validation confirmed that all three MP4 files contained resolution, frame rate, and duration metadata consistent with the generation settings.&lt;/p&gt;

&lt;p&gt;The third file confirmed successful export in a portrait 9:16 format.&lt;/p&gt;

&lt;p&gt;The results are preserved as textual evidence and a technical table, without requiring additional terminal screenshots.&lt;/p&gt;

&lt;h2&gt;
  
  
  12. Results and Limitations
&lt;/h2&gt;

&lt;p&gt;Phase 00 successfully validated the fundamental components of a local AI video generation pipeline.&lt;/p&gt;

&lt;h3&gt;
  
  
  Confirmed Results
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;ComfyUI running locally with CUDA support.&lt;/li&gt;
&lt;li&gt;LTX-Video 2B loaded and used for generation.&lt;/li&gt;
&lt;li&gt;Three animated WebP outputs generated.&lt;/li&gt;
&lt;li&gt;Landscape and portrait generation tested.&lt;/li&gt;
&lt;li&gt;Successful conversion to H.264 MP4.&lt;/li&gt;
&lt;li&gt;Output metadata verified using &lt;code&gt;ffprobe&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Three execution times recorded by ComfyUI.&lt;/li&gt;
&lt;li&gt;A portrait video published as a visual demonstration.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Identified Limitations
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Low output resolution.&lt;/li&gt;
&lt;li&gt;Video duration limited to approximately three seconds in the initial tests.&lt;/li&gt;
&lt;li&gt;High GPU resource utilization.&lt;/li&gt;
&lt;li&gt;No controlled performance benchmark yet.&lt;/li&gt;
&lt;li&gt;Video conversion still handled by a separate script.&lt;/li&gt;
&lt;li&gt;Generation workflow still operated manually.&lt;/li&gt;
&lt;li&gt;Visual quality not yet evaluated using systematic criteria.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These limitations help define the scope of future development.&lt;/p&gt;

&lt;p&gt;The results do not imply that every video configuration, resolution, or model will run successfully on a 6GB GPU.&lt;/p&gt;

&lt;p&gt;They demonstrate that &lt;strong&gt;one specific configuration was successfully validated on this hardware&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  13. Next Phase: Python Automation
&lt;/h2&gt;

&lt;p&gt;With the proof of concept completed, the next objective is to transform the manual workflow into an automated pipeline.&lt;/p&gt;

&lt;p&gt;Phase 01 will focus on using the ComfyUI API to:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Receive text prompts.&lt;/li&gt;
&lt;li&gt;Load previously validated workflows.&lt;/li&gt;
&lt;li&gt;Submit generation jobs.&lt;/li&gt;
&lt;li&gt;Monitor execution status.&lt;/li&gt;
&lt;li&gt;Identify and retrieve generated outputs.&lt;/li&gt;
&lt;li&gt;Automatically convert results into MP4.&lt;/li&gt;
&lt;li&gt;Record execution metadata, errors, and processing times.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The proposed architecture is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Python CLI
    |
    v
Workflow Manager
    |
    v
ComfyUI API
    |
    v
LTX-Video 2B
    |
    v
Output Manager
    |
    v
Media Converter
    |
    v
MP4 + Execution Metadata
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This approach will allow the project to evolve without modifying ComfyUI's internal source code.&lt;/p&gt;

&lt;h2&gt;
  
  
  14. Conclusion
&lt;/h2&gt;

&lt;p&gt;This experiment demonstrated that short AI-generated videos can be produced locally using an RTX 3050 Laptop GPU with 6GB of VRAM, provided that the workload is configured within the available hardware constraints.&lt;/p&gt;

&lt;p&gt;It also highlighted that building a functional AI video generation pipeline involves much more than running a generative model.&lt;/p&gt;

&lt;p&gt;It requires understanding the inference environment, managing hardware resources, interpreting execution errors, processing intermediate media formats, and validating the resulting artifacts.&lt;/p&gt;

&lt;p&gt;The animated WebP conversion issue was particularly valuable: a seemingly simple failure demonstrated the importance of separating responsibilities between tools and verifying outputs rather than assuming success.&lt;/p&gt;

&lt;p&gt;Phase 00 established the technical foundation of JC IA Video.&lt;/p&gt;

&lt;p&gt;The next step is to transform this proof of concept into a reproducible and automated pipeline.&lt;/p&gt;

&lt;h2&gt;
  
  
  15. Project Repository and Availability
&lt;/h2&gt;

&lt;p&gt;JC IA Video is being developed incrementally, with each phase documenting technical decisions, implementation details, limitations, and validation results.&lt;/p&gt;

&lt;p&gt;The project currently maintains its source code, workflows, scripts, and technical documentation in a local Git repository.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The GitHub repository will be made publicly available in the future&lt;/strong&gt;, once the project reaches an appropriate level of organization, reproducibility, and documentation.&lt;/p&gt;

&lt;p&gt;Future articles in this series will cover the implementation of the automation pipeline, resource optimization, and additional video processing capabilities.&lt;/p&gt;




&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/comfyanonymous/ComfyUI" rel="noopener noreferrer"&gt;ComfyUI — Official GitHub Repository&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/Lightricks/LTX-Video" rel="noopener noreferrer"&gt;LTX-Video — Official GitHub Repository&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://huggingface.co/Lightricks/LTX-Video" rel="noopener noreferrer"&gt;LTX-Video — Hugging Face&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.pytorch.org/docs/stable/index.html" rel="noopener noreferrer"&gt;PyTorch — Official Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://pillow.readthedocs.io/en/stable/" rel="noopener noreferrer"&gt;Pillow — Official Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://ffmpeg.org/documentation.html" rel="noopener noreferrer"&gt;FFmpeg — Official Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://ffmpeg.org/ffprobe.html" rel="noopener noreferrer"&gt;FFprobe — Official Documentation&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;em&gt;This is the first article in the JC IA Video — Local AI Video Generation series, documenting the incremental development of a local AI video generation pipeline using Python, ComfyUI, and open-source tools.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>python</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>From 422 Security Findings to Auditable Evidence: Building Trust in a DevSecOps Pipeline</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Mon, 02 Nov 2026 01:57:23 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/from-422-security-findings-to-auditable-evidence-building-trust-in-a-devsecops-pipeline-2ikp</link>
      <guid>https://dev.to/jacivaldocarvalho/from-422-security-findings-to-auditable-evidence-building-trust-in-a-devsecops-pipeline-2ikp</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Part 2 — How vulnerability triage, SBOMs, provenance, cryptographic signatures, and independent validation changed my approach to software supply chain security.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;In &lt;a href="https://dev.to/jacivaldocarvalho/12-green-ci-jobs-422-security-findings-lessons-from-building-an-observability-platform-4hk4"&gt;Part 1 — 12 Green CI Jobs, 422 Security Findings: Lessons from Building an Observability Platform&lt;/a&gt;, I shared a situation that changed how I evaluate continuous integration pipelines.&lt;/p&gt;

&lt;p&gt;While developing &lt;strong&gt;InfraPulse&lt;/strong&gt;, a monitoring and observability platform I'm building as a hands-on engineering and technical portfolio project, I reached an important milestone: 12 successful GitHub Actions jobs.&lt;/p&gt;

&lt;p&gt;The pipeline covered code quality, unit testing, PostgreSQL integration, API contracts, end-to-end testing, observability, Docker image validation, and foundational security controls.&lt;/p&gt;

&lt;p&gt;Everything looked promising.&lt;/p&gt;

&lt;p&gt;Then I introduced dedicated vulnerability scanning.&lt;/p&gt;

&lt;p&gt;The scanners reported &lt;strong&gt;422 findings&lt;/strong&gt;, including one classified as critical and 95 as high severity.&lt;/p&gt;

&lt;p&gt;Those findings did not represent 422 unique or necessarily exploitable vulnerabilities. They were occurrences reported across different components and scanning contexts, requiring further investigation.&lt;/p&gt;

&lt;p&gt;The central lesson was:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A green pipeline is evidence of engineering quality. It is not a certificate of zero risk.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;But that discovery raised another question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can we transform scanner results and automated checks into evidence that can be verified, correlated, and trusted?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That question guided the next stage of InfraPulse's development.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. The Problem Doesn't End When a Scanner Finds a Vulnerability
&lt;/h2&gt;

&lt;p&gt;One of the first challenges in vulnerability management is understanding what scanner results actually mean.&lt;/p&gt;

&lt;p&gt;During the initial InfraPulse security audit, I used three tools:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;pip-audit&lt;/code&gt; for Python dependencies.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;npm audit&lt;/code&gt; for frontend dependencies.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Trivy&lt;/code&gt; for container images.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The consolidated results were:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Target&lt;/th&gt;
&lt;th&gt;Findings&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Python dependencies&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;npm dependencies&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Backend Docker image&lt;/td&gt;
&lt;td&gt;176&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nginx Docker image&lt;/td&gt;
&lt;td&gt;229&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;422&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The severity distribution included one critical occurrence, 95 high, 143 medium, 15 moderate, 159 low, and nine unknown.&lt;/p&gt;

&lt;p&gt;These numbers were significant, but they were not enough to establish the actual risk to the application.&lt;/p&gt;

&lt;p&gt;The same advisory can appear in multiple container images. A vulnerable package may exist only during the build process. A Linux distribution may backport a security fix without changing the upstream version number reported by a scanner.&lt;/p&gt;

&lt;p&gt;Furthermore, identifying a vulnerable component does not automatically demonstrate that the affected functionality is reachable or exploitable.&lt;/p&gt;

&lt;h3&gt;
  
  
  From Discovery to Triage
&lt;/h3&gt;

&lt;p&gt;Turning a finding into an engineering decision requires answering several questions:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Which component was identified, and in which artifact?&lt;/li&gt;
&lt;li&gt;Is the component present in the production runtime?&lt;/li&gt;
&lt;li&gt;Does the vulnerability apply to the version and configuration being used?&lt;/li&gt;
&lt;li&gt;Is a compatible fix available?&lt;/li&gt;
&lt;li&gt;Does the same underlying issue appear across multiple targets?&lt;/li&gt;
&lt;li&gt;What is the potential impact, and how should remediation be prioritized?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This is the difference between &lt;strong&gt;automated vulnerability detection&lt;/strong&gt; and &lt;strong&gt;vulnerability management&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;In InfraPulse, the initial vulnerability audit remained informational.&lt;/p&gt;

&lt;p&gt;This allowed the project to preserve scanner results and investigate their quality before converting them into blocking CI policies.&lt;/p&gt;

&lt;p&gt;It did not mean that critical findings were considered acceptable.&lt;/p&gt;

&lt;p&gt;It meant recognizing that a severity label alone is not a complete security policy.&lt;/p&gt;

&lt;p&gt;An important limitation remains: &lt;strong&gt;the full triage and deduplication of the original 422 findings have not yet been completed&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Therefore, I cannot claim that all findings have been classified, remediated, or formally accepted.&lt;/p&gt;




&lt;h2&gt;
  
  
  2. Security Policies Must Distinguish Different Failure Conditions
&lt;/h2&gt;

&lt;p&gt;One important engineering decision was separating the operational result of a scanner from the outcome of its analysis.&lt;/p&gt;

&lt;p&gt;Consider four possible states:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;State&lt;/th&gt;
&lt;th&gt;Meaning&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;PASS&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The check executed successfully and satisfied its acceptance criteria&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;FINDINGS&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The audit completed and identified issues requiring evaluation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;SCANNER_ERROR&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The scanner failed to produce a valid result&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;NOT_RUN&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The audit was not executed&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This distinction prevents a dangerous failure mode: interpreting the absence of a vulnerability report as evidence that no vulnerabilities exist.&lt;/p&gt;

&lt;p&gt;Imagine that Trivy fails because of an execution error.&lt;/p&gt;

&lt;p&gt;If the pipeline converts that failure into an empty findings list, the result may appear secure even though the scan never completed successfully.&lt;/p&gt;

&lt;p&gt;That would be a &lt;em&gt;fail-open&lt;/em&gt; behavior.&lt;/p&gt;

&lt;p&gt;For mandatory security controls, an inability to obtain or validate required evidence should not silently become a successful result.&lt;/p&gt;

&lt;p&gt;However, this does not mean every reported vulnerability must immediately block every delivery.&lt;/p&gt;

&lt;p&gt;A reliable blocking policy needs explicit criteria for applicability, priority, evidence quality, remediation, and exceptions.&lt;/p&gt;

&lt;p&gt;In InfraPulse, foundational integrity and execution controls became mandatory, while vulnerability discovery remained informational during this development phase.&lt;/p&gt;

&lt;p&gt;The final coverage and completeness policy is still under development.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Running a security scanner and designing a trustworthy policy around its results are two different engineering problems.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  3. SBOM: First, We Need to Know What We're Analyzing
&lt;/h2&gt;

&lt;p&gt;The next stage introduced a &lt;strong&gt;Software Bill of Materials (SBOM)&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;An SBOM is a structured inventory of the components associated with a software artifact.&lt;/p&gt;

&lt;p&gt;It helps answer a seemingly simple question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What components and dependencies are associated with the software we're building?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In InfraPulse, I implemented CycloneDX SBOM generation covering:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Python dependencies.&lt;/li&gt;
&lt;li&gt;npm dependencies.&lt;/li&gt;
&lt;li&gt;The backend Docker image.&lt;/li&gt;
&lt;li&gt;The Nginx Docker image.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Dependency inventories use lockfile-based inputs, while container images are analyzed through image inspection and scanning tools.&lt;/p&gt;

&lt;p&gt;The implementation also introduced validation tests for the structure and consistency of generated documents.&lt;/p&gt;

&lt;h3&gt;
  
  
  What Does an SBOM Actually Prove?
&lt;/h3&gt;

&lt;p&gt;An SBOM provides visibility into the components identified by its generation process.&lt;/p&gt;

&lt;p&gt;But there is an important distinction:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A structurally valid SBOM is not necessarily a complete inventory of the artifact.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If a scanner fails to recognize a package, the resulting document may still be valid while omitting that component.&lt;/p&gt;

&lt;p&gt;Similarly, comparing two results generated by the same scanner may demonstrate consistency without establishing independent completeness.&lt;/p&gt;

&lt;p&gt;This became one of the central concerns of Sprint 06.&lt;/p&gt;

&lt;p&gt;The container image inventories therefore remain classified as &lt;code&gt;COVERAGE_PARTIAL&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Producing a valid CycloneDX document is only the beginning.&lt;/p&gt;

&lt;p&gt;We also need to understand which files, layers, and components were actually examined — and which remain outside the verified scope.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Integrity Is Not Authenticity: Introducing Provenance
&lt;/h2&gt;

&lt;p&gt;Once the project could generate component inventories, another question emerged:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can we verify that an SBOM corresponds to the material it is supposed to represent?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This led to the introduction of provenance mechanisms.&lt;/p&gt;

&lt;p&gt;InfraPulse now produces structured documents using &lt;strong&gt;in-toto Statement v1&lt;/strong&gt; and the &lt;strong&gt;SLSA Provenance v1&lt;/strong&gt; predicate format.&lt;/p&gt;

&lt;p&gt;These documents represent information about artifacts, materials, and the processes associated with their production.&lt;/p&gt;

&lt;p&gt;The local implementation validates properties such as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;File and inventory integrity.&lt;/li&gt;
&lt;li&gt;Consistency between expected and observed materials.&lt;/li&gt;
&lt;li&gt;Content hashes.&lt;/li&gt;
&lt;li&gt;Docker image identifiers.&lt;/li&gt;
&lt;li&gt;Component relationships.&lt;/li&gt;
&lt;li&gt;Consistency between SBOMs and provenance evidence.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One important design concern was avoiding blind trust in identifiers supplied by the artifact being verified.&lt;/p&gt;

&lt;p&gt;For example, when a Docker image reports an identifier, validation should compare it against an independently established expectation.&lt;/p&gt;

&lt;p&gt;Otherwise, an altered artifact could present an equally altered identifier and appear internally consistent.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two Concepts That Must Not Be Confused
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Integrity:&lt;/strong&gt; Does the content match what was established as expected?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Authenticity:&lt;/strong&gt; Is there trustworthy evidence about who produced or signed that content?&lt;/p&gt;

&lt;p&gt;A hash can demonstrate that content matches an expected digest.&lt;/p&gt;

&lt;p&gt;However, if an attacker can replace both the artifact and its reference hash, that comparison alone does not establish trust in the artifact's origin.&lt;/p&gt;

&lt;p&gt;Likewise, producing a document that follows the SLSA provenance structure does not automatically establish compliance with a particular SLSA level.&lt;/p&gt;

&lt;p&gt;InfraPulse does not claim a specific SLSA level or independently established build-producer authenticity.&lt;/p&gt;

&lt;h3&gt;
  
  
  FIGURE 1 — CycloneDX SBOM and Provenance Evidence
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Figure 1A — CycloneDX SBOM&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fib2kmyucb2aukcg3d0uy.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fib2kmyucb2aukcg3d0uy.png" alt="Figure 1A — CycloneDX SBOM" width="663" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1A. Real SBOM evidence from InfraPulse Sprint 06. A CycloneDX 1.7 document generated by Trivy 0.76.1, containing 50 component entries from the Python dependency inventory.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Figure 1B — in-toto/SLSA Provenance&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchw6xjm92cws74o5gxxo.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchw6xjm92cws74o5gxxo.png" alt="Figure 1B — in-toto/SLSA Provenance" width="800" height="394"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1B. Real provenance evidence from InfraPulse Sprint 06. An in-toto Statement v1 with a SLSA Provenance v1 predicate, a SHA-256 reference to &lt;code&gt;python.cdx.json&lt;/code&gt;, and a declared &lt;code&gt;COVERAGE_PASS&lt;/code&gt; status. The &lt;code&gt;local-untrusted&lt;/code&gt; context does not independently establish producer authenticity. The coverage status applies specifically to the Python inventory, not to the container images.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Together, Figures 1A and 1B demonstrate the relationship between a generated software component inventory and the structured provenance metadata describing its production.&lt;/p&gt;

&lt;p&gt;However, a valid CycloneDX SBOM and a structurally correct provenance statement do not automatically establish complete artifact coverage or trusted build provenance.&lt;/p&gt;

&lt;p&gt;This example illustrates why &lt;strong&gt;integrity, authenticity, and completeness must be evaluated separately&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Cryptographic Signatures and Trust in the Signer
&lt;/h2&gt;

&lt;p&gt;After establishing integrity validation, the next step was cryptographic signing.&lt;/p&gt;

&lt;p&gt;For this, I used &lt;strong&gt;Cosign&lt;/strong&gt;, a tool from the Sigstore ecosystem.&lt;/p&gt;

&lt;p&gt;The implementation uses asymmetric cryptographic signatures and offline verification, with a previously established trusted public-key reference.&lt;/p&gt;

&lt;p&gt;The validation model distinguishes three properties:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Property&lt;/th&gt;
&lt;th&gt;What it represents&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;INTEGRITY_VERIFIED&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Content and materials satisfy the integrity checks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;SIGNATURE_VALID&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The cryptographic signature has been verified&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;TRUSTED_SIGNER&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The verified public key matches the identity authorized by policy&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These properties answer different questions.&lt;/p&gt;

&lt;p&gt;A mathematically valid signature does not necessarily mean the signer is trusted.&lt;/p&gt;

&lt;p&gt;If a verifier accepts a public key supplied exclusively by the same package being verified, an attacker could generate a new key pair and sign modified content.&lt;/p&gt;

&lt;p&gt;The signature would be valid, but trust would not be established.&lt;/p&gt;

&lt;p&gt;That is why InfraPulse uses an independent trusted reference for the authorized public key, including fingerprint verification.&lt;/p&gt;

&lt;p&gt;Negative tests were also introduced to reject altered content, tampered bundles, unauthorized keys, and material inconsistencies.&lt;/p&gt;

&lt;h3&gt;
  
  
  FIGURE 2 — Integrity, Signature, and Trust
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fagvu1wra2kkjpij6qusp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fagvu1wra2kkjpij6qusp.png" alt="FIGURE 2 — Integrity, Signature, and Trust" width="800" height="1704"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 2. Conceptual evidence-validation model in InfraPulse: content integrity, cryptographic signature validity, and trust in the authorized public key. These checks were tested with disposable keys and do not represent operational production-build authentication.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  What Was Actually Validated?
&lt;/h3&gt;

&lt;p&gt;The implementation was tested with disposable cryptographic keys, including an integrated execution on a GitHub-hosted runner.&lt;/p&gt;

&lt;p&gt;That environment performed signing and verification operations, negative tests, and validation of previously generated evidence.&lt;/p&gt;

&lt;p&gt;The tested workflow completed successfully.&lt;/p&gt;

&lt;p&gt;However, &lt;strong&gt;a disposable test key is not an operational production identity&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;InfraPulse does not yet have an operational signing process that establishes production-build authenticity through a trusted institutional signer.&lt;/p&gt;

&lt;p&gt;The tests demonstrated that the mechanisms work under the evaluated conditions.&lt;/p&gt;

&lt;p&gt;They did not establish that the entire production supply chain is authenticated.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. Turning CI into an Evidence Producer
&lt;/h2&gt;

&lt;p&gt;By this stage, the pipeline was already executing tests, generating inventories, and validating materials.&lt;/p&gt;

&lt;p&gt;But there was an opportunity to improve traceability.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Instead of producing only a green status, CI could publish structured evidence describing what it actually executed.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This idea guided the implementation of a dedicated evidence-generation stage.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;ci-evidence (unsigned)&lt;/code&gt; job began producing artifacts containing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;SBOMs.&lt;/li&gt;
&lt;li&gt;Provenance statements.&lt;/li&gt;
&lt;li&gt;Component manifests.&lt;/li&gt;
&lt;li&gt;Hashes and file sizes.&lt;/li&gt;
&lt;li&gt;Execution references.&lt;/li&gt;
&lt;li&gt;Information about analyzed materials.&lt;/li&gt;
&lt;li&gt;Known coverage limitations.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The architecture deliberately separates two responsibilities.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Evidence production:&lt;/strong&gt; performed by CI without operational signing keys.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Signing and trust establishment:&lt;/strong&gt; performed separately, under its own controls.&lt;/p&gt;

&lt;p&gt;This separation reduces the need to expose sensitive signing credentials to the workflow that builds and tests the software.&lt;/p&gt;

&lt;p&gt;It also prevents signatures from becoming an automatic property of any artifact a CI job can produce.&lt;/p&gt;

&lt;h3&gt;
  
  
  FIGURE 3 — CI Evidence Production and Validation Flow
&lt;/h3&gt;

&lt;p&gt;*Figure 3&lt;br&gt;
&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5ng4nzbjyuzrgm218e74.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5ng4nzbjyuzrgm218e74.png" alt="FIGURE 3 — CI Evidence Production and Validation Flow" width="540" height="1582"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;. Conceptual flow of evidence generation, independent validation, and offline signing in InfraPulse. Signing is separate from the evidence-producing CI workflow and was validated with disposable keys rather than operational production credentials.*&lt;/p&gt;
&lt;h3&gt;
  
  
  Validating Evidence Outside the Producer
&lt;/h3&gt;

&lt;p&gt;During the next phase, I used a disposable GitHub-hosted runner to execute an integrated validation.&lt;/p&gt;

&lt;p&gt;The process retrieved evidence from a specific CI execution, verified materials, processed OCI files, imported images into a disposable environment, and performed signing and verification with temporary keys.&lt;/p&gt;

&lt;p&gt;It also executed negative tests designed to detect tampering and unauthorized identities.&lt;/p&gt;

&lt;p&gt;The integrated validation completed successfully.&lt;/p&gt;

&lt;p&gt;This demonstrated that the verification workflow could run outside the environment that originally produced the evidence.&lt;/p&gt;

&lt;p&gt;However, independent execution does not automatically prove the authenticity of the original producer.&lt;/p&gt;

&lt;p&gt;Container image inventory coverage also remains partial.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The value of the process is making security claims verifiable while keeping their limitations explicit.&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  FIGURE 4 — Real GitHub Actions Execution
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmablfg0hqgtonibv0w6r.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmablfg0hqgtonibv0w6r.png" alt="FIGURE 4 — Real GitHub Actions Execution" width="800" height="458"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 4. Real InfraPulse GitHub Actions execution showing successful unsigned evidence generation (&lt;code&gt;ci-evidence&lt;/code&gt;), informational vulnerability auditing (&lt;code&gt;vulnerability-audit&lt;/code&gt;), and the mandatory aggregate gate (&lt;code&gt;ci-required&lt;/code&gt;). The workflow completed successfully and published 10 artifacts. This result does not imply zero vulnerabilities or complete container-image coverage.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The screenshot provides evidence of a specific successful CI execution.&lt;/p&gt;

&lt;p&gt;It should not be interpreted as proof that all vulnerability findings have been remediated or that every generated artifact has complete coverage.&lt;/p&gt;


&lt;h2&gt;
  
  
  7. The Next Challenge: Proving OCI Image Coverage
&lt;/h2&gt;

&lt;p&gt;One of the most technically challenging problems emerged while evaluating Docker image inventories.&lt;/p&gt;

&lt;p&gt;An OCI image consists of ordered filesystem layers.&lt;/p&gt;

&lt;p&gt;One layer may introduce a file. Another may replace it. A later layer may remove it.&lt;/p&gt;

&lt;p&gt;Therefore, simply combining all files found across layers does not necessarily represent the image's final filesystem.&lt;/p&gt;
&lt;h3&gt;
  
  
  Example: A File Removed by a Later Layer
&lt;/h3&gt;

&lt;p&gt;Consider an image with two layers.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Layer 1&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/app/config.json
/app/server.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Layer 2&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/app/.wh.config.json
/app/requirements.txt
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;.wh.config.json&lt;/code&gt; entry represents a removal mechanism known as a &lt;em&gt;whiteout&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;In the final filesystem view, &lt;code&gt;config.json&lt;/code&gt; should no longer be present simply because it appeared in the first layer.&lt;/p&gt;

&lt;p&gt;This behavior must be interpreted correctly when reconstructing the image's virtual filesystem.&lt;/p&gt;

&lt;p&gt;Other cases include opaque directories, hardlinks, symbolic links, path collisions, and the order in which filesystem operations are applied.&lt;/p&gt;

&lt;h3&gt;
  
  
  FIGURE 5 — OCI Layers and Whiteout Semantics
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvtk4cvf06039u2pew5xv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvtk4cvf06039u2pew5xv.png" alt="FIGURE 5 — OCI Layers and Whiteout Semantics" width="799" height="449"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 5. Conceptual OCI filesystem reconstruction example. A whiteout in a later layer logically removes a file introduced by an earlier layer. Inspecting layers independently does not establish the completeness of the final filesystem inventory.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Why Does This Matter for Security?
&lt;/h3&gt;

&lt;p&gt;An incorrect filesystem inventory can produce incorrect conclusions about which components are actually present.&lt;/p&gt;

&lt;p&gt;It may report files that were removed by later layers or fail to interpret the final state of the image correctly.&lt;/p&gt;

&lt;p&gt;To address this problem, Sprint 06 introduced:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A structured coverage-state contract.&lt;/li&gt;
&lt;li&gt;A safe OCI/USTAR layer parser.&lt;/li&gt;
&lt;li&gt;Validation of paths, metadata, hashes, and resource limits.&lt;/li&gt;
&lt;li&gt;Negative tests for invalid inputs and unexpected behavior.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These foundations have been implemented and validated.&lt;/p&gt;

&lt;p&gt;However, full virtual filesystem reconstruction and independent inventory reconciliation remain incomplete.&lt;/p&gt;

&lt;p&gt;The pending work includes applying whiteout semantics, handling opaque directories and links, and reconciling the reconstructed filesystem against component inventories.&lt;/p&gt;

&lt;p&gt;For that reason, the current policy does not automatically promote container images to &lt;code&gt;COVERAGE_COMPLETE&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Acknowledging partial coverage is more trustworthy than claiming completeness that has not been demonstrated.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  8. How This Changed My Approach to Security
&lt;/h2&gt;

&lt;p&gt;InfraPulse's evolution reinforced a change in perspective.&lt;/p&gt;

&lt;p&gt;Initially, the main question was:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Did the pipeline pass?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Then it became:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which checks passed, and what does each one actually demonstrate?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Now the question is broader:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which security claims can we support with verifiable, independent, and sufficiently complete evidence?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;These questions are not equivalent.&lt;/p&gt;

&lt;p&gt;A pipeline can pass because all mandatory checks executed correctly.&lt;/p&gt;

&lt;p&gt;A scanner can report findings without every occurrence representing an exploitable vulnerability.&lt;/p&gt;

&lt;p&gt;An SBOM can be valid without fully covering an artifact.&lt;/p&gt;

&lt;p&gt;A signature can be cryptographically valid without the signer being authorized.&lt;/p&gt;

&lt;p&gt;A provenance statement can have the correct structure without establishing the authenticity of the build environment.&lt;/p&gt;

&lt;p&gt;Each property must be evaluated separately.&lt;/p&gt;

&lt;h3&gt;
  
  
  Five Practical Lessons
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;1. Don't confuse successful execution with the absence of risk.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A green CI job demonstrates that its acceptance criteria were satisfied. It does not automatically answer every security question.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Preserve findings before automating decisions.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Vulnerability findings require context, correlation, classification, and remediation criteria.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Separate integrity, authenticity, and completeness.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;These properties are related, but none can replace the others.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Test failure paths, not only successful execution.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Security tools should reject invalid inputs, tampered evidence, unauthorized identities, and unverifiable conditions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5. Document what has not yet been proven.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A known and documented limitation supports better engineering decisions than an unsupported claim of complete trust.&lt;/p&gt;




&lt;h2&gt;
  
  
  9. What Still Remains in InfraPulse
&lt;/h2&gt;

&lt;p&gt;Despite the progress, the software supply chain security work is not finished.&lt;/p&gt;

&lt;p&gt;The next engineering activities include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Completing whiteout, opaque-directory, and link semantics in virtual OCI filesystem reconstruction.&lt;/li&gt;
&lt;li&gt;Developing inventory verification that is more independent of the primary scanner.&lt;/li&gt;
&lt;li&gt;Reconciling identified components with the reconstructed filesystem.&lt;/li&gt;
&lt;li&gt;Expanding negative coverage tests.&lt;/li&gt;
&lt;li&gt;Establishing final completeness criteria.&lt;/li&gt;
&lt;li&gt;Advancing vulnerability triage and prioritization.&lt;/li&gt;
&lt;li&gt;Designing an operational signing and trust policy appropriate for a real delivery environment.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are future activities, not completed capabilities.&lt;/p&gt;

&lt;p&gt;It is also important to recognize that successful tests with disposable keys do not replace operational key management, rotation, revocation, or signer authorization.&lt;/p&gt;

&lt;p&gt;The goal is not to make every security tool report green results at any cost.&lt;/p&gt;

&lt;p&gt;The goal is to build a process in which every result has a clear technical meaning, known limitations, and evidence that can be independently examined.&lt;/p&gt;




&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;In Part 1, the 422 findings demonstrated that a pipeline with 12 successful jobs could still reveal significant potential security risks.&lt;/p&gt;

&lt;p&gt;In Part 2, the challenge evolved.&lt;/p&gt;

&lt;p&gt;The focus expanded from detecting problems to building mechanisms for verifying inventory integrity, establishing trust in signatures, preserving CI evidence, and understanding coverage limitations.&lt;/p&gt;

&lt;p&gt;Throughout this journey, InfraPulse incorporated CycloneDX SBOMs, provenance structures, cryptographic verification with Cosign, structured CI evidence, and integrated validation in disposable environments.&lt;/p&gt;

&lt;p&gt;These mechanisms improved the project's ability to investigate and verify results.&lt;/p&gt;

&lt;p&gt;But they did not eliminate every uncertainty.&lt;/p&gt;

&lt;p&gt;Container image coverage remains partial. Vulnerability triage still requires further work. Operational build-producer authenticity has not been established.&lt;/p&gt;

&lt;p&gt;And that may be the most important lesson from this stage:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Security is not about making every indicator green. It is about knowing exactly what each indicator proves, which risks remain, and what evidence supports our decisions.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A trustworthy pipeline does not need to claim that everything is secure.&lt;/p&gt;

&lt;p&gt;It needs to demonstrate what has been verified — and acknowledge what has not.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The journey continues.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;There is still much to explore, validate, and improve. I'll continue sharing the engineering challenges, lessons learned, and progress behind InfraPulse.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Until next time!&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  References and Tools
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://docs.github.com/en/actions" rel="noopener noreferrer"&gt;GitHub Actions Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://cyclonedx.org/" rel="noopener noreferrer"&gt;CycloneDX — SBOM Standard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://owasp.org/www-project-software-component-verification-standard/" rel="noopener noreferrer"&gt;OWASP Software Component Verification Standard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://trivy.dev/" rel="noopener noreferrer"&gt;Trivy Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/pypa/pip-audit" rel="noopener noreferrer"&gt;pip-audit — PyPA&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.npmjs.com/cli/commands/npm-audit" rel="noopener noreferrer"&gt;npm audit Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://in-toto.io/" rel="noopener noreferrer"&gt;in-toto — Supply Chain Attestations&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://slsa.dev/" rel="noopener noreferrer"&gt;SLSA — Supply-chain Levels for Software Artifacts&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.sigstore.dev/cosign/" rel="noopener noreferrer"&gt;Sigstore Cosign Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/opencontainers/image-spec" rel="noopener noreferrer"&gt;Open Container Initiative — Image Specification&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>devops</category>
      <category>sre</category>
      <category>security</category>
      <category>devsecops</category>
    </item>
    <item>
      <title>12 Green CI Jobs, 422 Security Findings: Lessons from Building an Observability Platform</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Sat, 31 Oct 2026 03:04:09 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/12-green-ci-jobs-422-security-findings-lessons-from-building-an-observability-platform-4hk4</link>
      <guid>https://dev.to/jacivaldocarvalho/12-green-ci-jobs-422-security-findings-lessons-from-building-an-observability-platform-4hk4</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;An engineering journey through Python, React, Docker, GitHub Actions, observability, and software supply chain security.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;Does a green CI pipeline mean your application is secure?&lt;/p&gt;

&lt;p&gt;That question became much more meaningful while developing &lt;strong&gt;InfraPulse&lt;/strong&gt;, a monitoring and observability platform I'm building as a hands-on engineering and technical portfolio project.&lt;/p&gt;

&lt;p&gt;Throughout development, I implemented automated tests, infrastructure validation, PostgreSQL integration, end-to-end testing, observability checks, and software supply chain security controls.&lt;/p&gt;

&lt;p&gt;Eventually, the project reached &lt;strong&gt;12 successful GitHub Actions jobs&lt;/strong&gt;, including dependency integrity checks, secret detection, and Docker image validation.&lt;/p&gt;

&lt;p&gt;Everything looked promising.&lt;/p&gt;

&lt;p&gt;Then I introduced dedicated vulnerability scanning.&lt;/p&gt;

&lt;p&gt;The scanners reported &lt;strong&gt;422 findings&lt;/strong&gt;, including one classified as critical and 95 as high severity.&lt;/p&gt;

&lt;p&gt;That doesn't mean InfraPulse has 422 exploitable vulnerabilities. It means the scanners produced 422 findings that still require analysis, correlation, and classification.&lt;/p&gt;

&lt;p&gt;That distinction matters.&lt;/p&gt;

&lt;p&gt;In this article, I'll share how the project evolved, the engineering decisions behind its architecture, and what I learned about integrating security into the development lifecycle.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. InfraPulse: From an Application to an Engineering Platform
&lt;/h2&gt;

&lt;p&gt;InfraPulse started with a relatively straightforward goal: build an application capable of monitoring services and endpoints, recording results, and exposing operational information.&lt;/p&gt;

&lt;p&gt;However, I didn't want to build just another functional dashboard.&lt;/p&gt;

&lt;p&gt;I wanted a project that would allow me to practice engineering approaches commonly used in professional DevOps, SRE, and Platform Engineering environments.&lt;/p&gt;

&lt;p&gt;That meant answering questions such as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;How can I prevent backend changes from breaking frontend API contracts?&lt;/li&gt;
&lt;li&gt;How can I validate real application behavior against PostgreSQL?&lt;/li&gt;
&lt;li&gt;How should observability behave when an infrastructure component fails?&lt;/li&gt;
&lt;li&gt;How can I verify that Docker images contain the expected artifacts?&lt;/li&gt;
&lt;li&gt;How can I prevent dependencies and base images from changing silently?&lt;/li&gt;
&lt;li&gt;How can security be introduced without making CI unreliable?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These questions directly influenced the architecture.&lt;/p&gt;

&lt;h3&gt;
  
  
  Technology Stack
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Layer&lt;/th&gt;
&lt;th&gt;Technologies&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Backend&lt;/td&gt;
&lt;td&gt;Python, FastAPI, SQLAlchemy, Alembic&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Frontend&lt;/td&gt;
&lt;td&gt;React, TypeScript, Vite, Mantine&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Database&lt;/td&gt;
&lt;td&gt;PostgreSQL 17&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Containers&lt;/td&gt;
&lt;td&gt;Docker, Docker Compose, Nginx&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CI/CD&lt;/td&gt;
&lt;td&gt;GitHub Actions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Testing&lt;/td&gt;
&lt;td&gt;Pytest, Vitest, Playwright&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Metrics&lt;/td&gt;
&lt;td&gt;Prometheus&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Distributed tracing&lt;/td&gt;
&lt;td&gt;OpenTelemetry, Tempo&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Visualization&lt;/td&gt;
&lt;td&gt;Grafana&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Alerting&lt;/td&gt;
&lt;td&gt;Alertmanager&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Security&lt;/td&gt;
&lt;td&gt;Gitleaks, integrity policies, pip-audit, npm audit, Trivy&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;An important architectural decision was to keep components organized around clear responsibilities.&lt;/p&gt;

&lt;p&gt;This made it possible to validate individual layers independently while also testing their integrated behavior.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. The First Challenge: Building Trust in CI
&lt;/h2&gt;

&lt;p&gt;Creating a GitHub Actions workflow that runs tests and displays a green checkmark is relatively straightforward.&lt;/p&gt;

&lt;p&gt;Making sure that green checkmark represents meaningful verification is much harder.&lt;/p&gt;

&lt;p&gt;InfraPulse's CI pipeline evolved incrementally.&lt;/p&gt;

&lt;p&gt;I started with backend quality checks and unit tests.&lt;/p&gt;

&lt;p&gt;Then I expanded coverage to include frontend validation, PostgreSQL integration, API contracts, end-to-end tests, and observability integration.&lt;/p&gt;

&lt;p&gt;The next step was validating the Docker images produced by the project.&lt;/p&gt;

&lt;p&gt;Finally, I introduced foundational software supply chain security controls.&lt;/p&gt;

&lt;h3&gt;
  
  
  The 12-Job CI Pipeline
&lt;/h3&gt;

&lt;p&gt;In the reference remote execution, all 12 jobs passed:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Job&lt;/th&gt;
&lt;th&gt;Responsibility&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;backend-quality&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Backend static quality checks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;backend-unit&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Unit tests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;api-contract&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;OpenAPI contract validation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;frontend-quality&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Frontend quality checks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;frontend-tests&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Automated frontend tests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;frontend-build&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Frontend production build&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;backend-postgres&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;PostgreSQL integration tests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;playwright-e2e&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;End-to-end tests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;observability-integration&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Real observability integration scenarios&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;docker-build&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Docker builds and image validation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;security-foundations&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Foundational security controls&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ci-required&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Mandatory aggregate CI gate&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The &lt;code&gt;ci-required&lt;/code&gt; job plays a particularly important role.&lt;/p&gt;

&lt;p&gt;It verifies the results of all mandatory validation jobs.&lt;/p&gt;

&lt;p&gt;This prevents the pipeline from being considered successful when a required job fails, is canceled, or is unexpectedly skipped.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A reliable CI gate must validate not only application behavior but also the integrity of the validation process itself.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;All 12 jobs passed in the reference execution.&lt;/p&gt;

&lt;h3&gt;
  
  
  Figure 1 — GitHub Actions CI Results
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkivyi651ksme7xg69z0d.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkivyi651ksme7xg69z0d.png" alt="Figure 1 — InfraPulse GitHub Actions pipeline showing 12 successful jobs" width="800" height="591"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1. InfraPulse CI pipeline: 12 successful jobs, covering quality, integration, end-to-end testing, observability, Docker image validation, and foundational security controls. Screenshot from a private repository.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Testing Observability Means Introducing Failure
&lt;/h2&gt;

&lt;p&gt;One of the most interesting lessons was realizing that instrumenting an application is not the same as validating its observability.&lt;/p&gt;

&lt;p&gt;Adding metrics, logs, and traces is only the beginning.&lt;/p&gt;

&lt;p&gt;The real challenge is understanding how these signals behave when infrastructure components become unavailable.&lt;/p&gt;

&lt;p&gt;In InfraPulse, I implemented integration scenarios involving the OpenTelemetry Collector.&lt;/p&gt;

&lt;p&gt;The tests cover three situations:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Normal operation:&lt;/strong&gt; The application runs while the Collector is available.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Outage:&lt;/strong&gt; The Collector becomes unavailable.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Recovery:&lt;/strong&gt; The Collector returns, and the system's behavior is observed again.&lt;/p&gt;

&lt;p&gt;These scenarios help validate how the application and its instrumentation behave under changing operational conditions.&lt;/p&gt;

&lt;p&gt;All three scenarios passed during the reference remote execution.&lt;/p&gt;

&lt;p&gt;This reinforced an important SRE principle:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Observability should be tested under failure conditions, not merely demonstrated through dashboards.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Of course, three successful scenarios do not prove complete system resilience.&lt;/p&gt;

&lt;p&gt;They provide evidence about specific behaviors under controlled conditions.&lt;/p&gt;

&lt;p&gt;And that is precisely what good engineering validation should do.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Docker: A Successful Build Is Not Enough
&lt;/h2&gt;

&lt;p&gt;Another important milestone was improving Docker image validation.&lt;/p&gt;

&lt;p&gt;At first, it might seem sufficient to execute &lt;code&gt;docker build&lt;/code&gt; and confirm that the command exits successfully.&lt;/p&gt;

&lt;p&gt;But that leaves several questions unanswered.&lt;/p&gt;

&lt;p&gt;Does the image contain the correct files?&lt;/p&gt;

&lt;p&gt;Does the generated frontend match the expected OpenAPI contract?&lt;/p&gt;

&lt;p&gt;Does the worker shut down gracefully?&lt;/p&gt;

&lt;p&gt;Can Nginx serve the expected assets?&lt;/p&gt;

&lt;p&gt;Are the runtime configurations behaving correctly?&lt;/p&gt;

&lt;p&gt;To address these questions, I expanded the pipeline with image inspections and smoke tests.&lt;/p&gt;

&lt;h3&gt;
  
  
  OpenAPI Contract and Frontend Consistency
&lt;/h3&gt;

&lt;p&gt;The frontend uses TypeScript types generated from the OpenAPI contract.&lt;/p&gt;

&lt;p&gt;During image validation, the generated types extracted from the frontend build were compared byte-for-byte against an independently generated reference.&lt;/p&gt;

&lt;p&gt;Both used the contract from the same CI execution and a pinned generator version.&lt;/p&gt;

&lt;p&gt;The verification did not merely check whether files existed or contained data.&lt;/p&gt;

&lt;p&gt;It compared their complete contents.&lt;/p&gt;

&lt;p&gt;This reduces the risk of shipping a frontend built with types that differ from the expected API contract.&lt;/p&gt;

&lt;h3&gt;
  
  
  Runtime Behavior
&lt;/h3&gt;

&lt;p&gt;The image validation process also checked:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The API &lt;code&gt;/health&lt;/code&gt; endpoint returning HTTP 200.&lt;/li&gt;
&lt;li&gt;Readiness returning HTTP 503 when the database was unavailable, as expected in that test scenario.&lt;/li&gt;
&lt;li&gt;Worker startup and graceful shutdown using SIGTERM.&lt;/li&gt;
&lt;li&gt;Nginx configuration, health checks, and static assets.&lt;/li&gt;
&lt;li&gt;Docker image layer inspection.&lt;/li&gt;
&lt;li&gt;Cleanup of temporary validation resources.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These checks do not replace production testing.&lt;/p&gt;

&lt;p&gt;However, they provide stronger evidence than a successful image build alone.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. When DevSecOps Became Part of the Architecture
&lt;/h2&gt;

&lt;p&gt;As the pipeline matured, another concern became increasingly important: the integrity of the components used to build and run the software.&lt;/p&gt;

&lt;p&gt;An application can pass every functional test while still depending on vulnerable packages, mutable container images, or insufficiently controlled build tools.&lt;/p&gt;

&lt;p&gt;That realization led me to introduce a dedicated software supply chain security phase.&lt;/p&gt;

&lt;p&gt;The first step focused on foundational controls.&lt;/p&gt;

&lt;h3&gt;
  
  
  Secret Detection
&lt;/h3&gt;

&lt;p&gt;I integrated Gitleaks to scan the repository history and working checkout for potentially exposed secrets.&lt;/p&gt;

&lt;p&gt;Beyond running the scanner, I added synthetic positive and negative test fixtures, operational failure handling, and sanitized output.&lt;/p&gt;

&lt;p&gt;The goal wasn't simply to execute a security tool.&lt;/p&gt;

&lt;p&gt;It was to verify that the tool detected known test cases and that operational failures could not silently become successful results.&lt;/p&gt;

&lt;h3&gt;
  
  
  Python Dependency Integrity
&lt;/h3&gt;

&lt;p&gt;Initially, the project contained 49 pinned Python requirements without package hashes.&lt;/p&gt;

&lt;p&gt;Pinning dependency versions improves predictability, but it does not independently verify the integrity of the downloaded artifacts.&lt;/p&gt;

&lt;p&gt;I introduced hash-verified installations and regression tests that deliberately reject tampered hashes.&lt;/p&gt;

&lt;p&gt;Build and bootstrap tools were also version-pinned.&lt;/p&gt;

&lt;h3&gt;
  
  
  Docker Images Pinned by Digest
&lt;/h3&gt;

&lt;p&gt;Another improvement involved replacing base-image references that relied only on mutable tags with digest-pinned references.&lt;/p&gt;

&lt;p&gt;A tag can point to different content over time.&lt;/p&gt;

&lt;p&gt;A digest identifies specific content, helping prevent silent changes to the image base.&lt;/p&gt;

&lt;p&gt;This improves reproducibility but introduces an additional responsibility: maintaining controlled updates so security fixes can still be incorporated.&lt;/p&gt;

&lt;h3&gt;
  
  
  GitHub Actions Security
&lt;/h3&gt;

&lt;p&gt;The workflow security policies also covered:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;GitHub Actions pinned to full commit SHAs.&lt;/li&gt;
&lt;li&gt;Least-privilege workflow permissions.&lt;/li&gt;
&lt;li&gt;Checkout without unnecessary credential persistence.&lt;/li&gt;
&lt;li&gt;Automated policies designed to detect regressions in these controls.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This work introduced the mandatory &lt;code&gt;security-foundations&lt;/code&gt; job.&lt;/p&gt;

&lt;p&gt;The reference CI execution passed all blocking foundational security policies with zero violations.&lt;/p&gt;

&lt;p&gt;But one question remained:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Were the dependencies and container images free from known vulnerabilities?&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  6. The Turning Point: 422 Vulnerability Findings
&lt;/h2&gt;

&lt;p&gt;After establishing foundational security controls, I started a dedicated vulnerability discovery phase.&lt;/p&gt;

&lt;p&gt;I used three tools:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;pip-audit&lt;/strong&gt; for Python dependencies.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;npm audit&lt;/strong&gt; for frontend dependencies.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Trivy&lt;/strong&gt; for Docker image vulnerability scanning.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The results were significant.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Target&lt;/th&gt;
&lt;th&gt;Findings&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Python — pip-audit 2.10.1&lt;/td&gt;
&lt;td&gt;2 advisories&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Frontend — npm audit 11.16.0&lt;/td&gt;
&lt;td&gt;15 occurrences across 14 packages&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Backend image — Trivy 0.76.1&lt;/td&gt;
&lt;td&gt;176 occurrences&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nginx image — Trivy&lt;/td&gt;
&lt;td&gt;229 occurrences&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;422 occurrences&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  Figure 2 — Sanitized Vulnerability Audit Summary
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fezieclkub78isf84ztgd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fezieclkub78isf84ztgd.png" alt="Figure 2 — Sanitized InfraPulse vulnerability audit summary showing 422 findings" width="800" height="192"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 2. Sanitized local vulnerability discovery summary. The 422 findings are scanner occurrences, not unique CVEs or confirmed exploitable vulnerabilities.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The consolidated severity distribution was:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Reported severity&lt;/th&gt;
&lt;th&gt;Occurrences&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Critical&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;High&lt;/td&gt;
&lt;td&gt;95&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Medium&lt;/td&gt;
&lt;td&gt;143&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Moderate&lt;/td&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Low&lt;/td&gt;
&lt;td&gt;159&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unknown&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These numbers require careful interpretation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;422 findings do not mean 422 unique CVEs, and they certainly do not prove 422 exploitable vulnerabilities.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The same advisory may appear across multiple images, packages, or scanning contexts.&lt;/p&gt;

&lt;p&gt;Different scanners may also use different severity classifications and remediation information.&lt;/p&gt;

&lt;p&gt;Furthermore, finding a vulnerable package inside a container image does not automatically demonstrate that the affected functionality is reachable or exploitable through the application.&lt;/p&gt;

&lt;h3&gt;
  
  
  A Concrete Example
&lt;/h3&gt;

&lt;p&gt;Trivy flagged &lt;strong&gt;&lt;a href="https://www.cve.org/CVERecord?id=CVE-2026-111497" rel="noopener noreferrer"&gt;CVE-2026-111497&lt;/a&gt;&lt;/strong&gt; in &lt;code&gt;brotli-libs&lt;/code&gt; version &lt;code&gt;1.2.0-r0&lt;/code&gt;, reporting &lt;code&gt;1.2.1-r0&lt;/code&gt; as the fixed version.&lt;/p&gt;

&lt;p&gt;The Python audit also reported advisories affecting &lt;code&gt;setuptools&lt;/code&gt;, with fixed versions indicated by the scanner.&lt;/p&gt;

&lt;p&gt;These findings deserve attention, but they still require technical triage.&lt;/p&gt;

&lt;p&gt;Important questions include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is the affected component present in the production runtime or only during the build?&lt;/li&gt;
&lt;li&gt;Is a fixed version available and compatible?&lt;/li&gt;
&lt;li&gt;Has the operating system distribution already applied a security backport?&lt;/li&gt;
&lt;li&gt;Is the vulnerable functionality actually exposed?&lt;/li&gt;
&lt;li&gt;Could the proposed update introduce regressions?&lt;/li&gt;
&lt;li&gt;Is the same underlying issue being counted across multiple targets?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;At the time of this analysis, those questions had not yet been fully resolved.&lt;/p&gt;

&lt;p&gt;Therefore, the vulnerability discovery phase was initially treated as &lt;strong&gt;informational&lt;/strong&gt;, rather than immediately turning every finding into a blocking CI failure.&lt;/p&gt;

&lt;p&gt;This was a deliberate engineering decision.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Why Not Block CI Immediately?
&lt;/h2&gt;

&lt;p&gt;It may sound contradictory to identify a critical-severity finding without immediately failing the entire pipeline.&lt;/p&gt;

&lt;p&gt;But detecting a potential vulnerability and designing a reliable blocking policy are two different activities.&lt;/p&gt;

&lt;p&gt;A useful security policy must account for evidence quality, applicability, remediation availability, and scanner behavior.&lt;/p&gt;

&lt;p&gt;Otherwise, CI can become unstable, and teams may start introducing broad exceptions simply to restore a green pipeline.&lt;/p&gt;

&lt;p&gt;This does not mean ignoring critical findings.&lt;/p&gt;

&lt;p&gt;It means prioritizing their investigation and defining verifiable remediation criteria.&lt;/p&gt;

&lt;p&gt;The next stage of InfraPulse will focus on classifying findings, deduplicating occurrences, assessing applicability, and establishing security policies with justified, time-limited exceptions.&lt;/p&gt;

&lt;p&gt;It is also important to distinguish between different audit outcomes:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PASS:&lt;/strong&gt; The check executed successfully and its acceptance criteria were satisfied.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;FINDINGS:&lt;/strong&gt; The audit completed and identified issues requiring evaluation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;SCANNER_ERROR:&lt;/strong&gt; The scanner failed to execute or collect results correctly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;NOT_RUN:&lt;/strong&gt; The audit was not executed.&lt;/p&gt;

&lt;p&gt;A scanner error must never be interpreted as evidence that no vulnerabilities exist.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. What I've Learned So Far
&lt;/h2&gt;

&lt;p&gt;Building InfraPulse has reinforced several lessons that I consider especially relevant to DevOps and SRE.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;First: software quality is built in layers.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Unit tests, integration tests, E2E tests, image validation, and security checks answer different questions. None completely replaces the others.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Second: pipelines should produce evidence.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A green status is useful, but engineering confidence also depends on knowing what was executed, which artifacts were tested, and which limitations remain.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Third: reproducibility and security are related, but they are not the same thing.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Hashes and digests help control the content being used. They do not independently guarantee that the content is vulnerability-free.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fourth: observability must include failure scenarios.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A working dashboard under normal conditions is valuable, but outage and recovery tests provide additional evidence about operational behavior.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fifth: automating detection does not automate engineering judgment.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Scanners identify potential problems. Determining applicability, priority, and remediation requires context.&lt;/p&gt;

&lt;p&gt;Perhaps the most important lesson is that &lt;strong&gt;security should not be treated as a separate activity performed only at the end of development&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;It should evolve alongside architecture, testing, infrastructure, and delivery practices.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;InfraPulse began as a monitoring project and evolved into a practical exercise in software engineering, reliability, and security.&lt;/p&gt;

&lt;p&gt;Reaching 12 successful GitHub Actions jobs was an important milestone.&lt;/p&gt;

&lt;p&gt;But discovering 422 vulnerability findings demonstrated that a mature pipeline does not mean the security work is finished.&lt;/p&gt;

&lt;p&gt;Instead, it can provide the foundation needed to identify and investigate additional risks.&lt;/p&gt;

&lt;p&gt;The next challenge is not simply making the scanners report zero findings.&lt;/p&gt;

&lt;p&gt;It is building a security policy capable of distinguishing meaningful risks, prioritizing remediation, and preserving a reliable delivery process.&lt;/p&gt;

&lt;p&gt;In Part 2, I plan to explore vulnerability triage, deduplication, applicability analysis, blocking policies, and auditable exceptions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A green pipeline is evidence of engineering quality. It is not a certificate of zero risk.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  References and Tools
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://docs.github.com/en/actions" rel="noopener noreferrer"&gt;GitHub Actions Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://owasp.org/www-project-software-component-verification-standard/" rel="noopener noreferrer"&gt;OWASP Software Component Verification Standard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/gitleaks/gitleaks" rel="noopener noreferrer"&gt;Gitleaks&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/pypa/pip-audit" rel="noopener noreferrer"&gt;pip-audit&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.npmjs.com/cli/commands/npm-audit" rel="noopener noreferrer"&gt;npm audit&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://trivy.dev/" rel="noopener noreferrer"&gt;Trivy&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.cve.org/CVERecord?id=CVE-2026-111497" rel="noopener noreferrer"&gt;CVE-2026-111497 — Official CVE Record&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://opentelemetry.io/" rel="noopener noreferrer"&gt;OpenTelemetry&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://slsa.dev/" rel="noopener noreferrer"&gt;SLSA — Supply-chain Levels for Software Artifacts&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;This article documents an ongoing engineering project. Vulnerability scan results represent a specific point-in-time assessment, not a definitive statement about exploitability or overall application security. Package and remediation versions cited in the case study reflect the local scanner output.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;InfraPulse is currently maintained in a private repository. The screenshots included in this article are sanitized excerpts of the project's validation results.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>devops</category>
      <category>devsecops</category>
      <category>sre</category>
      <category>cicd</category>
    </item>
    <item>
      <title>The Server Is Reachable, but the Application Is Down: Troubleshooting with JC SRE NetProbe</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Thu, 29 Oct 2026 14:17:05 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/the-server-is-reachable-but-the-application-is-down-troubleshooting-with-jc-sre-netprobe-4pn8</link>
      <guid>https://dev.to/jacivaldocarvalho/the-server-is-reachable-but-the-application-is-down-troubleshooting-with-jc-sre-netprobe-4pn8</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;A practical guide to troubleshooting DNS, TCP, TLS, and HTTP failures using a single Python CLI for network and service diagnostics.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;Imagine receiving an alert indicating that a web application is unavailable.&lt;/p&gt;

&lt;p&gt;The server is still running. The infrastructure appears to be operational. However, users cannot access the service.&lt;/p&gt;

&lt;p&gt;The first assumption might be a connectivity problem. But what if the TCP connection is working correctly?&lt;/p&gt;

&lt;p&gt;Does that mean the application is available?&lt;/p&gt;

&lt;p&gt;Not necessarily.&lt;/p&gt;

&lt;p&gt;A web service depends on several components working together. DNS resolution must identify the destination, a TCP connection must be established, TLS must meet the required security conditions, and the application must respond correctly to HTTP requests.&lt;/p&gt;

&lt;p&gt;A failure at any of these stages can affect the user experience.&lt;/p&gt;

&lt;p&gt;In my previous article, &lt;a href="https://dev.to/jacivaldocarvalho/building-jc-sre-netprobe-a-python-cli-for-network-health-checks-devops-and-sre-4l0f"&gt;Building JC SRE NetProbe: A Python CLI for Network Health Checks, DevOps, and SRE&lt;/a&gt;, I introduced JC SRE NetProbe, an open-source Python tool designed for IP network diagnostics and service health checks.&lt;/p&gt;

&lt;p&gt;That article focused on the project itself, its capabilities, and its applications in Networking, DevOps, and Site Reliability Engineering (SRE).&lt;/p&gt;

&lt;p&gt;Now, let's explore a different scenario.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can we use JC SRE NetProbe to investigate an application that appears reachable over the network but is not functioning correctly?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In this tutorial, we will use the tool to examine different stages of communication and interpret the results of an operational troubleshooting scenario.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The Problem: Connectivity Does Not Mean Availability
&lt;/h2&gt;

&lt;p&gt;Consider an HTTPS application hosted in a corporate infrastructure environment.&lt;/p&gt;

&lt;p&gt;A user attempts to access:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;https://api.example.com&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The browser displays an error or reports that the service is temporarily unavailable.&lt;/p&gt;

&lt;p&gt;The infrastructure team needs to determine where the problem originates.&lt;/p&gt;

&lt;p&gt;A simplified communication flow looks like this:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgzl0flsizjqcasdv52ro.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgzl0flsizjqcasdv52ro.png" alt="HTTPS Communication Flow" width="365" height="1026"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Figure 1. Simplified stages involved in establishing an HTTPS connection and receiving an application response.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Each stage represents a different condition.&lt;/p&gt;

&lt;p&gt;Successful DNS resolution does not guarantee that the TCP port is accessible.&lt;/p&gt;

&lt;p&gt;An established TCP connection does not guarantee that the TLS certificate is valid.&lt;/p&gt;

&lt;p&gt;And a successful TLS check does not guarantee that the application is responding correctly.&lt;/p&gt;

&lt;p&gt;This separation is what makes layered troubleshooting so useful.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Introducing JC SRE NetProbe
&lt;/h2&gt;

&lt;p&gt;JC SRE NetProbe is a Python command-line tool designed for IP connectivity diagnostics and service health checks.&lt;/p&gt;

&lt;p&gt;The project combines several capabilities into a single interface:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;DNS resolution checks.&lt;/li&gt;
&lt;li&gt;TCP connectivity tests with timing measurements.&lt;/li&gt;
&lt;li&gt;HTTP and HTTPS endpoint checks.&lt;/li&gt;
&lt;li&gt;TLS certificate validation and expiration information.&lt;/li&gt;
&lt;li&gt;IPv4 and IPv6 network information.&lt;/li&gt;
&lt;li&gt;Structured JSON output.&lt;/li&gt;
&lt;li&gt;Exit codes for automation.&lt;/li&gt;
&lt;li&gt;Multiple checks using YAML configuration files.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The tool is designed to support troubleshooting, automation, and basic availability verification across networking, telecommunications, DevOps, and SRE environments.&lt;/p&gt;

&lt;p&gt;The source code is available on GitHub:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/jacivaldocarvalho/jc-sre-netprobe" rel="noopener noreferrer"&gt;github.com/jacivaldocarvalho/jc-sre-netprobe&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Installing JC SRE NetProbe on Ubuntu 24.04 LTS
&lt;/h2&gt;

&lt;p&gt;Before starting the troubleshooting scenario, we need to prepare the environment.&lt;/p&gt;

&lt;p&gt;JC SRE NetProbe is distributed as a Python command-line application.&lt;/p&gt;

&lt;p&gt;On modern Linux distributions, including Ubuntu 24.04 LTS, installing Python packages directly into the operating system's managed Python environment may be restricted by &lt;strong&gt;PEP 668&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;This specification helps protect Python environments managed by the operating system's package manager, reducing potential conflicts between system-managed and user-installed dependencies.&lt;/p&gt;

&lt;p&gt;For standalone Python CLI applications, a recommended approach is to use &lt;code&gt;pipx&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;pipx&lt;/code&gt; installs Python applications in isolated virtual environments while making their commands available from the terminal without modifying Ubuntu's system-managed Python environment.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.1. Installing pipx
&lt;/h3&gt;

&lt;p&gt;Update the package index and install the required packages:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;sudo &lt;/span&gt;apt update
&lt;span class="nb"&gt;sudo &lt;/span&gt;apt &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-y&lt;/span&gt; pipx python3-venv
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Configure your PATH to include executables installed by &lt;code&gt;pipx&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pipx ensurepath
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Refresh your terminal session:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;exec&lt;/span&gt; &lt;span class="nv"&gt;$SHELL&lt;/span&gt; &lt;span class="nt"&gt;-l&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Verify that &lt;code&gt;pipx&lt;/code&gt; is available:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pipx &lt;span class="nt"&gt;--version&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  3.2. Installing JC SRE NetProbe
&lt;/h3&gt;

&lt;p&gt;Once &lt;code&gt;pipx&lt;/code&gt; is configured, run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pipx &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="s2"&gt;"jc-sre-netprobe&amp;gt;=0.3.0"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This command performs three main operations:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Creates an isolated virtual environment for the application.&lt;/li&gt;
&lt;li&gt;Installs the package and its dependencies inside that environment.&lt;/li&gt;
&lt;li&gt;Makes the application's published executables available in the user's command directory, typically &lt;code&gt;~/.local/bin/&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This allows you to run the tool directly from the terminal without manually activating a virtual environment.&lt;/p&gt;

&lt;p&gt;The version constraint &lt;code&gt;&amp;gt;=0.3.0&lt;/code&gt; allows installation of a compatible release equal to or newer than version 0.3.0. For strictly reproducible environments, pin a specific tested version.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.3. Verifying the Installation
&lt;/h3&gt;

&lt;p&gt;First, list the applications managed by &lt;code&gt;pipx&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pipx list
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Next, verify the executable location:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;command&lt;/span&gt; &lt;span class="nt"&gt;-v&lt;/span&gt; jc-sre-netprobe
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On a typical installation, the output should resemble:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/home/username/.local/bin/jc-sre-netprobe
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Finally, display the CLI help:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe &lt;span class="nt"&gt;--help&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If the tool displays its help information, the environment is ready for the examples in this tutorial.&lt;/p&gt;

&lt;p&gt;If your terminal reports &lt;code&gt;command not found&lt;/code&gt;, verify that &lt;code&gt;~/.local/bin&lt;/code&gt; is included in your PATH and that the package installed the expected executable:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pipx list
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;ls&lt;/span&gt; &lt;span class="nt"&gt;-l&lt;/span&gt; ~/.local/bin/ | &lt;span class="nb"&gt;grep &lt;/span&gt;netprobe
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  3.4. Alternative: Installing with venv
&lt;/h3&gt;

&lt;p&gt;For development environments or project-specific testing, you can also use a dedicated Python virtual environment.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;mkdir&lt;/span&gt; &lt;span class="nt"&gt;-p&lt;/span&gt; ~/projects/netprobe
&lt;span class="nb"&gt;cd&lt;/span&gt; ~/projects/netprobe

python3 &lt;span class="nt"&gt;-m&lt;/span&gt; venv .venv
&lt;span class="nb"&gt;source&lt;/span&gt; .venv/bin/activate

python &lt;span class="nt"&gt;-m&lt;/span&gt; pip &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="s2"&gt;"jc-sre-netprobe&amp;gt;=0.3.0"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Verify the installation:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe &lt;span class="nt"&gt;--help&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Deactivate the virtual environment when finished:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;deactivate
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Engineering note:&lt;/strong&gt; Avoid using &lt;code&gt;--break-system-packages&lt;/code&gt; to bypass Ubuntu's Python environment protections. For standalone CLI applications, &lt;code&gt;pipx&lt;/code&gt; provides a more appropriate installation approach.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Practical Scenario: Investigating an Unavailable API
&lt;/h2&gt;

&lt;p&gt;Let's consider a hypothetical scenario.&lt;/p&gt;

&lt;p&gt;An API is hosted at:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;api.example.com&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The infrastructure team has received reports of service unavailability, but it is not yet clear whether the problem involves DNS, TCP connectivity, TLS, or the application itself.&lt;/p&gt;

&lt;p&gt;Our objective is to perform independent checks to narrow down the investigation.&lt;/p&gt;

&lt;p&gt;The domain &lt;code&gt;api.example.com&lt;/code&gt; is used for demonstration purposes. Replace it with a real, authorized endpoint when reproducing this troubleshooting workflow.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 1 — Checking DNS Resolution
&lt;/h3&gt;

&lt;p&gt;The first step is to determine whether the service hostname can be resolved.&lt;/p&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe dns api.example.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This check helps determine whether DNS resolution is functioning from the environment where NetProbe is running.&lt;/p&gt;

&lt;p&gt;If resolution fails, possible causes include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;DNS resolver problems.&lt;/li&gt;
&lt;li&gt;Incorrect domain configuration.&lt;/li&gt;
&lt;li&gt;Missing or inconsistent DNS records.&lt;/li&gt;
&lt;li&gt;Connectivity issues affecting DNS infrastructure.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A successful resolution indicates that this stage of the diagnostic process worked.&lt;/p&gt;

&lt;p&gt;However, we still do not know whether the destination is running an accessible service.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Key takeaway:&lt;/strong&gt; Working DNS resolution does not mean the application is available.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2 — Checking TCP Connectivity
&lt;/h3&gt;

&lt;p&gt;After checking DNS, we need to determine whether the service's TCP port accepts connections.&lt;/p&gt;

&lt;p&gt;For an HTTPS application, we will use port 443:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tcp api.example.com 443
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;We can also configure a timeout:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tcp api.example.com 443 &lt;span class="nt"&gt;--timeout&lt;/span&gt; 3
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;NetProbe attempts to establish the connection and reports the result.&lt;/p&gt;

&lt;p&gt;Three situations are particularly important.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Successful connection&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The TCP connection was established.&lt;/p&gt;

&lt;p&gt;This indicates that the port is reachable from the environment where the check was performed.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Connection refused&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The destination or an intermediate component rejected the connection attempt.&lt;/p&gt;

&lt;p&gt;Possible causes include the absence of a listening service or a network policy that explicitly rejects connections.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Timeout&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The connection attempt did not complete within the configured timeout.&lt;/p&gt;

&lt;p&gt;This may indicate traffic filtering, connectivity problems, packet loss, or destination unavailability.&lt;/p&gt;

&lt;p&gt;The TCP check also provides timing information, but this measurement does not necessarily represent the application's complete response time.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Key takeaway:&lt;/strong&gt; A successful TCP connection confirms the tested transport connectivity, not application availability.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3 — Checking TLS
&lt;/h3&gt;

&lt;p&gt;A successful TCP connection does not guarantee that HTTPS communication is functioning correctly.&lt;/p&gt;

&lt;p&gt;The next step is to inspect the TLS certificate presented by the service.&lt;/p&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tls api.example.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also specify the port and timeout:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tls api.example.com &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--port&lt;/span&gt; 443 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--timeout&lt;/span&gt; 5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This check helps investigate TLS certificate conditions, including validation and expiration information.&lt;/p&gt;

&lt;p&gt;Potential problems include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Expired certificates.&lt;/li&gt;
&lt;li&gt;Certificate validation failures.&lt;/li&gt;
&lt;li&gt;TLS negotiation issues.&lt;/li&gt;
&lt;li&gt;Unavailable TLS services.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It is important to distinguish certificate validity from overall application functionality.&lt;/p&gt;

&lt;p&gt;A valid certificate does not guarantee that the API can process requests correctly.&lt;/p&gt;

&lt;p&gt;Likewise, a certificate check is not a substitute for a complete security assessment of the service's TLS configuration.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Key takeaway:&lt;/strong&gt; TLS checks provide evidence about the secure communication layer, but they do not establish application availability.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 4 — Checking HTTP
&lt;/h3&gt;

&lt;p&gt;We have now reached the application layer.&lt;/p&gt;

&lt;p&gt;The next step is to determine whether the HTTPS endpoint responds correctly.&lt;/p&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe http https://api.example.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Or configure a specific timeout:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe http https://api.example.com &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--timeout&lt;/span&gt; 5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;NetProbe performs the HTTP/HTTPS check and reports the endpoint's health status.&lt;/p&gt;

&lt;p&gt;During a real investigation, we may encounter different conditions:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Observed condition&lt;/th&gt;
&lt;th&gt;Possible interpretation&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Healthy HTTP response&lt;/td&gt;
&lt;td&gt;The endpoint passed the configured health check&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HTTP 500&lt;/td&gt;
&lt;td&gt;The application returned an internal server error&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HTTP 502&lt;/td&gt;
&lt;td&gt;A gateway or proxy received an invalid response from an upstream service&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HTTP 503&lt;/td&gt;
&lt;td&gt;The service reported that it was unavailable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Timeout&lt;/td&gt;
&lt;td&gt;The request did not complete within the expected interval&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Connection failure&lt;/td&gt;
&lt;td&gt;The required connection could not be established&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The exact interpretation depends on the service's expected behavior and the health-check rules implemented by the tool.&lt;/p&gt;

&lt;p&gt;An endpoint that responds successfully may still have failures in functionality not covered by the check.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Key takeaway:&lt;/strong&gt; HTTP checks bring the investigation closer to application behavior, but their results must be interpreted in the context of the endpoint being tested.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Interpreting the Results Together
&lt;/h2&gt;

&lt;p&gt;Now imagine that our checks produced the following results:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Check&lt;/th&gt;
&lt;th&gt;Hypothetical result&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;DNS&lt;/td&gt;
&lt;td&gt;Healthy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TCP 443&lt;/td&gt;
&lt;td&gt;Healthy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TLS&lt;/td&gt;
&lt;td&gt;Healthy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HTTP&lt;/td&gt;
&lt;td&gt;Failed&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;What can we conclude?&lt;/p&gt;

&lt;p&gt;First, DNS resolution worked.&lt;/p&gt;

&lt;p&gt;Second, the TCP connection was established.&lt;/p&gt;

&lt;p&gt;Third, the TLS check did not identify a failure condition.&lt;/p&gt;

&lt;p&gt;However, the HTTP check was not considered healthy.&lt;/p&gt;

&lt;p&gt;This suggests that the investigation should focus on HTTP behavior, the application, or components involved in processing the request.&lt;/p&gt;

&lt;p&gt;It does not mean that the root cause has already been identified.&lt;/p&gt;

&lt;p&gt;For example, an HTTP 503 response might be related to an unavailable dependency, an overloaded service, or an operational configuration issue.&lt;/p&gt;

&lt;p&gt;NetProbe provides evidence to guide the investigation. It does not replace internal logs, application metrics, or other information required to identify the exact root cause.&lt;/p&gt;

&lt;p&gt;This distinction is fundamental to effective troubleshooting and SRE.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Running Multiple Checks with YAML
&lt;/h2&gt;

&lt;p&gt;So far, we have executed each check individually.&lt;/p&gt;

&lt;p&gt;This approach is useful during manual troubleshooting, but it can become repetitive when multiple components need to be verified.&lt;/p&gt;

&lt;p&gt;Starting with version 0.3.0, JC SRE NetProbe supports bulk execution using YAML configuration files.&lt;/p&gt;

&lt;p&gt;Create a file named &lt;code&gt;api-checks.yaml&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;max_workers&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;4&lt;/span&gt;

&lt;span class="na"&gt;checks&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api-dns&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;dns&lt;/span&gt;
    &lt;span class="na"&gt;host&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api.example.com&lt;/span&gt;

  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api-tcp&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;tcp&lt;/span&gt;
    &lt;span class="na"&gt;host&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api.example.com&lt;/span&gt;
    &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;443&lt;/span&gt;
    &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;3&lt;/span&gt;

  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api-tls&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;tls&lt;/span&gt;
    &lt;span class="na"&gt;host&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api.example.com&lt;/span&gt;
    &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;443&lt;/span&gt;
    &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;

  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api-http&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http&lt;/span&gt;
    &lt;span class="na"&gt;url&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;https://api.example.com&lt;/span&gt;
    &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This configuration defines four independent checks.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;max_workers&lt;/code&gt; parameter controls the maximum number of checks that can run concurrently.&lt;/p&gt;

&lt;p&gt;Execute the configuration:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe run api-checks.yaml
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;NetProbe processes the checks and provides individual results along with an aggregated summary.&lt;/p&gt;

&lt;p&gt;An illustrative output might look like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Bulk Check Results
------------------
[OK] api-dns (dns)
[OK] api-tcp (tcp)
[OK] api-tls (tls)
[FAIL] api-http (http)

Total:   4
Healthy: 3
Failed:  1
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;This is a hypothetical result demonstrating an HTTP failure scenario. It does not represent an actual execution against &lt;code&gt;api.example.com&lt;/code&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The operational benefit is clear: multiple diagnostic checks can be organized into a single procedure.&lt;/p&gt;

&lt;p&gt;It is also important to note that the checks are independent. Bulk execution does not enforce a sequential troubleshooting process or automatically identify the root cause.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Using JSON Output for Automation
&lt;/h2&gt;

&lt;p&gt;In addition to human-readable output, JC SRE NetProbe supports structured JSON results.&lt;/p&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe run api-checks.yaml &lt;span class="nt"&gt;--json&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The output structure contains aggregated information and individual check results.&lt;/p&gt;

&lt;p&gt;A simplified example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"total"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"healthy"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"failed"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"results"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"api-http"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"http"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"healthy"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"details"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"error"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Illustrative HTTP check failure"&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This example shows only one item from the results array to keep the output concise.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;details&lt;/code&gt; field may contain information specific to each check type.&lt;/p&gt;

&lt;p&gt;This format allows other systems to process diagnostic results programmatically.&lt;/p&gt;

&lt;p&gt;For example, these checks can support automation workflows, infrastructure validation processes, or integrations with external monitoring systems.&lt;/p&gt;

&lt;p&gt;NetProbe also uses operational exit codes:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Exit code&lt;/th&gt;
&lt;th&gt;Meaning&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;0&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;All checks are healthy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;1&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;One or more checks failed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;2&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Invalid input or configuration&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These exit codes are particularly useful in operational scripts and CI/CD pipelines.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. How Does This Relate to Site Reliability Engineering?
&lt;/h2&gt;

&lt;p&gt;In SRE, the objective is not simply to verify whether a server is running.&lt;/p&gt;

&lt;p&gt;What matters is understanding whether a service meets its expected operating conditions.&lt;/p&gt;

&lt;p&gt;An API may be reachable over the network while still failing to serve users correctly.&lt;/p&gt;

&lt;p&gt;That is why an effective troubleshooting strategy must consider multiple signals.&lt;/p&gt;

&lt;p&gt;JC SRE NetProbe can contribute as an external diagnostic tool, using an approach commonly associated with &lt;strong&gt;black-box probing&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;It allows engineers to observe selected service behaviors without requiring direct access to the application's source code.&lt;/p&gt;

&lt;p&gt;This approach can support:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Initial incident diagnosis.&lt;/li&gt;
&lt;li&gt;Basic service availability checks.&lt;/li&gt;
&lt;li&gt;Post-deployment service validation.&lt;/li&gt;
&lt;li&gt;Automated operational checks.&lt;/li&gt;
&lt;li&gt;Identification of communication stages requiring further investigation.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;However, these checks do not replace internal observability, business metrics, distributed tracing, or a complete SLI and SLO strategy.&lt;/p&gt;

&lt;p&gt;Their main contribution is transforming individual network and service tests into a structured, repeatable diagnostic process.&lt;/p&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;A server can be reachable while its application remains unavailable.&lt;/p&gt;

&lt;p&gt;This situation demonstrates why infrastructure troubleshooting must go beyond a single connectivity check.&lt;/p&gt;

&lt;p&gt;By investigating DNS, TCP, TLS, and HTTP separately, we can identify which communication stages are functioning and which require additional attention.&lt;/p&gt;

&lt;p&gt;JC SRE NetProbe brings these checks together in a single Python CLI, allowing engineers to execute individual tests or groups of checks defined in YAML.&lt;/p&gt;

&lt;p&gt;In this article, we moved beyond the project's initial introduction. Instead of focusing only on its capabilities, we explored how to apply them to a practical troubleshooting scenario.&lt;/p&gt;

&lt;p&gt;For professionals working in networking, telecommunications, DevOps, and SRE, understanding the difference between connectivity and availability is essential for effective incident investigation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When an application fails, which layer do you usually investigate first: DNS, TCP, TLS, or HTTP?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Share your approach in the comments.&lt;/p&gt;




&lt;h3&gt;
  
  
  References
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/jacivaldocarvalho/jc-sre-netprobe" rel="noopener noreferrer"&gt;JC SRE NetProbe — GitHub Repository&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://dev.to/jacivaldocarvalho/building-jc-sre-netprobe-a-python-cli-for-network-health-checks-devops-and-sre-4l0f"&gt;Building JC SRE NetProbe — Original DEV.to Article&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://pypi.org/project/jc-sre-netprobe/" rel="noopener noreferrer"&gt;JC SRE NetProbe — PyPI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://peps.python.org/pep-0668/" rel="noopener noreferrer"&gt;PEP 668 — Externally Managed Environments&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://pipx.pypa.io/stable/" rel="noopener noreferrer"&gt;pipx — Official Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://sre.google/sre-book/monitoring-distributed-systems/" rel="noopener noreferrer"&gt;Google SRE — Monitoring Distributed Systems&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>python</category>
      <category>networking</category>
      <category>devops</category>
      <category>sre</category>
    </item>
    <item>
      <title>PHP2Shell: When the Vulnerability Is in the Runtime, Not Just the Application</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Fri, 23 Oct 2026 21:16:00 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/php2shell-when-the-vulnerability-is-in-the-runtime-not-just-the-application-4h7p</link>
      <guid>https://dev.to/jacivaldocarvalho/php2shell-when-the-vulnerability-is-in-the-runtime-not-just-the-application-4h7p</guid>
      <description>&lt;p&gt;&lt;strong&gt;What two critical PHP vulnerabilities teach us about SBOMs, containers, DevSecOps, and automated security patching.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In application security, we often focus our efforts on source code analysis, dependency management, and API protection.&lt;/p&gt;

&lt;p&gt;But what happens when the vulnerability exists in the runtime responsible for executing the application itself?&lt;/p&gt;

&lt;p&gt;On October 21, 2026, the PHP project released emergency security updates addressing two critical vulnerabilities, identified as &lt;strong&gt;CVE-2026-109618 and CVE-2026-109619&lt;/strong&gt;, collectively known as &lt;strong&gt;PHP2Shell&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Both received a CVSS v4.0 score of 9.2 and may allow unauthenticated remote code execution (RCE), depending on the conditions required for exploitation.&lt;/p&gt;

&lt;p&gt;This incident highlights an important security challenge: &lt;strong&gt;an application can have secure code and still be vulnerable because of the infrastructure running it.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The Technical Problem: Vulnerabilities in the PHP Core
&lt;/h2&gt;

&lt;p&gt;Unlike common vulnerabilities found in frameworks, libraries, or plugins, PHP2Shell involves internal mechanisms responsible for processing HTTP requests.&lt;/p&gt;

&lt;p&gt;The two vulnerabilities have distinct characteristics:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CVE-2026-109618 — Memory corruption during allocation failure handling.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Under certain out-of-memory conditions, PHP may interrupt request processing without properly restoring its internal state. Subsequent cleanup operations may then access uninitialized memory structures.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CVE-2026-109619 — Reuse of invalid global state.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The runtime may retain references to memory regions associated with previous requests. When this state is not properly reinitialized, subsequent requests may access memory that has already been freed.&lt;/p&gt;

&lt;p&gt;Potential consequences include remote code execution, sensitive information disclosure, and service disruption.&lt;/p&gt;

&lt;p&gt;The risk is not limited to a specific application.&lt;/p&gt;

&lt;p&gt;Environments using PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP, or LiteSpeed may be exposed, depending on their versions and configurations.&lt;/p&gt;

&lt;p&gt;This means that fixing application code alone does not eliminate the vulnerability.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Why Updating Dependencies Is Not Enough
&lt;/h2&gt;

&lt;p&gt;Consider an API developed with Laravel and deployed inside a Docker container.&lt;/p&gt;

&lt;p&gt;The development team uses static analysis, automated testing, dependency scanning, and CI/CD pipelines.&lt;/p&gt;

&lt;p&gt;Even with these practices in place, the base container image may still contain a vulnerable PHP version.&lt;/p&gt;

&lt;p&gt;The execution stack extends far beyond application code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;PHP / Laravel Application
        |
Composer Dependencies
        |
PHP Runtime
        |
System Libraries
        |
Container Base Image
        |
Operating System / Host
        |
Cloud Infrastructure
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A vulnerability in any of these layers can compromise the security of the service.&lt;/p&gt;

&lt;p&gt;For this reason, security must cover the entire execution environment.&lt;/p&gt;

&lt;p&gt;This is where &lt;strong&gt;Software Supply Chain Security&lt;/strong&gt; becomes essential.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. SBOM: Understanding Your Components Before Applying Fixes
&lt;/h2&gt;

&lt;p&gt;A Software Bill of Materials (SBOM) is a structured inventory of the software components used in an application.&lt;/p&gt;

&lt;p&gt;It can document packages, libraries, versions, and component identification information.&lt;/p&gt;

&lt;p&gt;When a critical vulnerability is disclosed, the operational question is no longer simply:&lt;/p&gt;

&lt;p&gt;"Which applications use PHP?"&lt;/p&gt;

&lt;p&gt;Instead, it becomes:&lt;/p&gt;

&lt;p&gt;"Which applications, containers, and servers are running vulnerable PHP versions, which are exposed to the internet, and which services depend on them?"&lt;/p&gt;

&lt;p&gt;Tools such as Syft, Trivy, and Grype help automate this process.&lt;/p&gt;

&lt;p&gt;A defensive example using Syft:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;syft my-api:latest &lt;span class="nt"&gt;-o&lt;/span&gt; cyclonedx-json &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; sbom.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This command generates an inventory of the components identified in the container image.&lt;/p&gt;

&lt;p&gt;Next, we can perform a vulnerability scan:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;trivy image my-api:latest
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;These checks help identify potentially affected components, but they do not replace validation against official vendor security advisories.&lt;/p&gt;

&lt;p&gt;It is also important to remember that Linux distributions may apply security fixes through &lt;em&gt;backporting&lt;/em&gt;, preserving version numbers that may still appear outdated.&lt;/p&gt;

&lt;p&gt;Therefore, vulnerability assessments must consider both the origin of the packages and their actual patch status.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Containers Do Not Eliminate Runtime Vulnerabilities
&lt;/h2&gt;

&lt;p&gt;A common misconception is that using Docker automatically makes an application secure.&lt;/p&gt;

&lt;p&gt;Containers provide isolation mechanisms, but they do not fix vulnerabilities in the components running inside them.&lt;/p&gt;

&lt;p&gt;If an image contains a vulnerable runtime, creating new containers from that image simply reproduces the problem.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fayvd1gy0x9gfmjmxdkyw.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fayvd1gy0x9gfmjmxdkyw.png" alt="Figure 1: Multiple containers created from the same vulnerable image inherit the affected PHP runtime. Container isolation does not fix vulnerabilities in the underlying software components." width="800" height="548"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Figure 1: Multiple containers created from the same vulnerable image inherit the affected PHP runtime. Container isolation does not fix vulnerabilities in the underlying software components.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;For PHP2Shell, the PHP project released the following patched versions:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;PHP Branch&lt;/th&gt;
&lt;th&gt;Patched Version&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PHP 8.2&lt;/td&gt;
&lt;td&gt;8.2.35&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PHP 8.3&lt;/td&gt;
&lt;td&gt;8.3.36&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PHP 8.4&lt;/td&gt;
&lt;td&gt;8.4.27&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PHP 8.5&lt;/td&gt;
&lt;td&gt;8.5.12&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Older, unsupported versions require additional attention, migration, or security patches maintained by specific vendors.&lt;/p&gt;

&lt;p&gt;One defensive approach is to update the base image to a patched runtime version:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="k"&gt;FROM&lt;/span&gt;&lt;span class="s"&gt; php:8.4.27-fpm&lt;/span&gt;

&lt;span class="k"&gt;WORKDIR&lt;/span&gt;&lt;span class="s"&gt; /var/www/html&lt;/span&gt;

&lt;span class="k"&gt;COPY&lt;/span&gt;&lt;span class="s"&gt; . .&lt;/span&gt;

&lt;span class="k"&gt;CMD&lt;/span&gt;&lt;span class="s"&gt; ["php-fpm"]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This example illustrates a runtime update but is not intended to represent a complete production-ready Dockerfile.&lt;/p&gt;

&lt;p&gt;After updating the runtime, the image must be rebuilt, tested, and deployed to replace existing containers.&lt;/p&gt;

&lt;p&gt;A basic workflow could look like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;docker build &lt;span class="nt"&gt;--pull&lt;/span&gt; &lt;span class="nt"&gt;--no-cache&lt;/span&gt; &lt;span class="nt"&gt;-t&lt;/span&gt; my-api:patched &lt;span class="nb"&gt;.&lt;/span&gt;
docker run &lt;span class="nt"&gt;--rm&lt;/span&gt; my-api:patched php &lt;span class="nt"&gt;-v&lt;/span&gt;
trivy image my-api:patched
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In production environments, verified images should be used, preferably pinned by digest. The exact artifact validated during testing should then be promoted to production.&lt;/p&gt;

&lt;p&gt;In Kubernetes, the process also requires verifying that Pods are actually running the updated image.&lt;/p&gt;

&lt;p&gt;Updating an image in the container registry without replacing running workloads does not guarantee that the vulnerability has been eliminated.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. DevSecOps: Turning Security Patching into an Automated Process
&lt;/h2&gt;

&lt;p&gt;Incidents such as PHP2Shell demonstrate that response speed is an essential part of operational security.&lt;/p&gt;

&lt;p&gt;A DevSecOps strategy can organize the remediation process into a structured workflow:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Inventory → Detection → Prioritization → Remediation → Validation → Monitoring&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Within a CI/CD pipeline, these activities can be automated.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Git Repository
      |
CI Pipeline
      |
Container Image Build
      |
SBOM Generation
      |
Vulnerability Scanning
      |
Automated Testing
      |
Security Policies
      |
Container Registry
      |
Controlled Deployment
      |
Observability
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A security policy may prevent images containing known critical vulnerabilities from being promoted, while considering exposure criteria, approved exceptions, and patch availability.&lt;/p&gt;

&lt;p&gt;Automation can also create dependency update requests and execute regression tests.&lt;/p&gt;

&lt;p&gt;However, &lt;strong&gt;automated remediation should not mean uncontrolled deployment&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Runtime updates may introduce compatibility issues.&lt;/p&gt;

&lt;p&gt;For this reason, security pipelines should include functional validation, health checks, progressive deployments, and rollback strategies.&lt;/p&gt;

&lt;p&gt;The goal is to reduce the exposure window without compromising service availability.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. A WAF Is a Protection Layer, Not a Permanent Fix
&lt;/h2&gt;

&lt;p&gt;During the PHP2Shell disclosure, vendors such as Cloudflare and AWS published guidance and protective measures to reduce exposure to exploitation attempts.&lt;/p&gt;

&lt;p&gt;These measures are particularly valuable when updating every affected system requires additional time.&lt;/p&gt;

&lt;p&gt;However, the PHP project made it clear that no complete mitigation can replace patching the vulnerable runtime.&lt;/p&gt;

&lt;p&gt;This distinction is essential:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Web Application Firewall (WAF):&lt;/strong&gt; Helps block potentially malicious traffic patterns.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Security patching:&lt;/strong&gt; Fixes the vulnerability in the affected component.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Observability:&lt;/strong&gt; Enables monitoring of exploitation attempts, errors, and abnormal behavior.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Incident response:&lt;/strong&gt; Establishes procedures when there are indications of compromise.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These controls complement one another.&lt;/p&gt;

&lt;p&gt;None should be treated as a universal replacement for the others.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Security should be part of the development process from the very first &lt;code&gt;git init&lt;/code&gt;.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Security should not begin when a vulnerability is discovered or when an application reaches production. It must be considered from the earliest stages of development, integrated into architecture decisions, dependency management, CI/CD pipelines, infrastructure provisioning, and runtime maintenance.&lt;/p&gt;

&lt;p&gt;This is the foundation of &lt;strong&gt;Security by Design&lt;/strong&gt; and the DevSecOps mindset: security is not a final checkpoint, but a continuous responsibility throughout the entire software lifecycle.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Because security should start with &lt;code&gt;git init&lt;/code&gt;, not with a critical CVE.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  7. The Role of DevOps and SRE During a Critical Vulnerability
&lt;/h2&gt;

&lt;p&gt;For DevOps and Site Reliability Engineering (SRE) teams, the challenge does not end when the security team identifies a vulnerability.&lt;/p&gt;

&lt;p&gt;Teams must determine which services are affected, assess the potential impact, and apply fixes safely.&lt;/p&gt;

&lt;p&gt;A structured response may include:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Identification:&lt;/strong&gt; Locate servers, containers, and images running affected versions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prioritization:&lt;/strong&gt; Evaluate internet exposure, service criticality, and potential exploitation paths.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Containment:&lt;/strong&gt; Apply temporary network and WAF controls when appropriate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Remediation:&lt;/strong&gt; Update packages and images, rebuild artifacts, and replace affected workloads.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Validation:&lt;/strong&gt; Run tests, verify runtime versions, and monitor operational indicators.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Investigation:&lt;/strong&gt; Analyze logs, events, and evidence of potential compromise. Applying a patch removes the known vulnerability, but it does not automatically resolve the consequences of a previous intrusion.&lt;/p&gt;

&lt;p&gt;From an SRE perspective, the response must balance security and reliability.&lt;/p&gt;

&lt;p&gt;Metrics such as time to identification, time to remediation, inventory coverage, and deployment success rate help assess operational maturity.&lt;/p&gt;

&lt;p&gt;It is also important to establish emergency patching procedures that do not depend exclusively on regular maintenance windows.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Automated Patching: Moving from Reaction to Prevention
&lt;/h2&gt;

&lt;p&gt;The most important lesson from PHP2Shell goes beyond the two vulnerabilities themselves.&lt;/p&gt;

&lt;p&gt;It highlights the need to transform security into a continuous operational capability.&lt;/p&gt;

&lt;p&gt;A mature organization should be able to answer questions such as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which vulnerable components are currently running in production?&lt;/li&gt;
&lt;li&gt;Which container images and services depend on those components?&lt;/li&gt;
&lt;li&gt;Is a patched version available?&lt;/li&gt;
&lt;li&gt;Which workloads need to be rebuilt?&lt;/li&gt;
&lt;li&gt;How can the fix be validated without causing downtime?&lt;/li&gt;
&lt;li&gt;How can we demonstrate that every affected environment has been updated?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Combining asset inventories, SBOMs, vulnerability scanners, CI/CD pipelines, security policies, and observability makes it possible to build this capability.&lt;/p&gt;

&lt;p&gt;AI-powered tools can also assist with vulnerability classification and the preparation of remediation changes.&lt;/p&gt;

&lt;p&gt;However, decisions with operational impact must follow authorization policies, testing requirements, and audit mechanisms.&lt;/p&gt;

&lt;p&gt;Automation should strengthen response capabilities, not eliminate the controls required to operate critical systems safely.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;PHP2Shell demonstrates how vulnerabilities in foundational software components can affect applications regardless of the quality of their source code.&lt;/p&gt;

&lt;p&gt;For DevOps and SRE professionals, this incident reinforces five key principles:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Application security also means runtime security.&lt;/li&gt;
&lt;li&gt;Containers must be continuously updated and verified.&lt;/li&gt;
&lt;li&gt;SBOMs and asset inventories are essential for identifying exposure.&lt;/li&gt;
&lt;li&gt;DevSecOps pipelines should incorporate vulnerability detection and remediation.&lt;/li&gt;
&lt;li&gt;Observability and automation must be part of the operational security response.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;The challenge is not simply discovering a vulnerability. It is knowing where it exists, understanding its impact, and being able to fix it quickly, verifiably, and safely.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This is one of the fundamental challenges of applying Site Reliability Engineering principles to modern cybersecurity.&lt;/p&gt;




&lt;h3&gt;
  
  
  Technical References
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;PHP Project:&lt;/strong&gt; Security Advisory — CVE-2026-109618 and CVE-2026-109619 (October 21, 2026). &lt;a href="https://www.php.net/" rel="noopener noreferrer"&gt;https://www.php.net/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Docker:&lt;/strong&gt; Security Update on PHP2Shell: Impact for Docker Customers (October 22, 2026). &lt;a href="https://www.docker.com/blog/security-update-on-php2shell-impact-for-docker-customers/" rel="noopener noreferrer"&gt;https://www.docker.com/blog/security-update-on-php2shell-impact-for-docker-customers/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cloudflare:&lt;/strong&gt; Cloudflare deploys protections against php2shell vulnerability (October 21, 2026). &lt;a href="https://blog.cloudflare.com/php-vulnerabilities-waf-protection/" rel="noopener noreferrer"&gt;https://blog.cloudflare.com/php-vulnerabilities-waf-protection/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AWS Security Blog:&lt;/strong&gt; Using AWS WAF to apply mitigations for PHP2Shell RCE vulnerabilities (October 21, 2026). &lt;a href="https://aws.amazon.com/blogs/security/using-aws-waf-to-apply-mitigations-for-php2shell-rce-vulnerabilities-cve-2026-109618-and-cve-2026-109619/" rel="noopener noreferrer"&gt;https://aws.amazon.com/blogs/security/using-aws-waf-to-apply-mitigations-for-php2shell-rce-vulnerabilities-cve-2026-109618-and-cve-2026-109619/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Red Hat:&lt;/strong&gt; RHSB-2026-013 — PHP request handling memory corruption. &lt;a href="https://access.redhat.com/security/vulnerabilities/RHSB-2026-013" rel="noopener noreferrer"&gt;https://access.redhat.com/security/vulnerabilities/RHSB-2026-013&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>devsecops</category>
      <category>cybersecurity</category>
      <category>devops</category>
      <category>php</category>
    </item>
    <item>
      <title>Building JC SRE NetProbe: A Python CLI for Network Health Checks, DevOps, and SRE</title>
      <dc:creator>JacivaldoCarvalho</dc:creator>
      <pubDate>Fri, 23 Oct 2026 03:40:13 +0000</pubDate>
      <link>https://dev.to/jacivaldocarvalho/building-jc-sre-netprobe-a-python-cli-for-network-health-checks-devops-and-sre-4l0f</link>
      <guid>https://dev.to/jacivaldocarvalho/building-jc-sre-netprobe-a-python-cli-for-network-health-checks-devops-and-sre-4l0f</guid>
      <description>&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;As a Telecommunications Engineer interested in Networking, DevOps, and Site Reliability Engineering (SRE), I've always been fascinated by how different layers of network infrastructure work together to deliver reliable services.&lt;/p&gt;

&lt;p&gt;When an application becomes unavailable, the problem isn't necessarily the application itself.&lt;/p&gt;

&lt;p&gt;It could be a DNS resolution issue, a TCP connection failure, an expired TLS certificate, or an HTTP service returning an unexpected response.&lt;/p&gt;

&lt;p&gt;Understanding where the failure occurs is an important part of troubleshooting.&lt;/p&gt;

&lt;p&gt;With that in mind, I built &lt;strong&gt;JC SRE NetProbe&lt;/strong&gt;, an open-source Python command-line tool designed to simplify network connectivity checks and basic service health diagnostics.&lt;/p&gt;

&lt;p&gt;🔗 &lt;strong&gt;GitHub:&lt;/strong&gt; &lt;a href="https://github.com/jacivaldocarvalho/jc-sre-netprobe" rel="noopener noreferrer"&gt;https://github.com/jacivaldocarvalho/jc-sre-netprobe&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What is JC SRE NetProbe?
&lt;/h2&gt;

&lt;p&gt;JC SRE NetProbe is a lightweight Python package that provides network diagnostic utilities through a command-line interface (CLI) and a Python API.&lt;/p&gt;

&lt;p&gt;The project brings together several common network checks into a single tool, making it useful for telecommunications professionals, network engineers, DevOps teams, and SRE practitioners.&lt;/p&gt;

&lt;p&gt;Its main capabilities include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;TCP connectivity checks with latency measurement&lt;/li&gt;
&lt;li&gt;DNS resolution checks&lt;/li&gt;
&lt;li&gt;HTTP/HTTPS endpoint health checks&lt;/li&gt;
&lt;li&gt;IPv4 and IPv6 network information&lt;/li&gt;
&lt;li&gt;TLS certificate validation and expiration information&lt;/li&gt;
&lt;li&gt;Configurable timeouts&lt;/li&gt;
&lt;li&gt;Structured JSON output&lt;/li&gt;
&lt;li&gt;Exit codes designed for automation&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The goal is straightforward: &lt;strong&gt;make network troubleshooting easier to execute, understand, and automate.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I Built It
&lt;/h2&gt;

&lt;p&gt;In network operations and infrastructure troubleshooting, engineers often need to perform multiple checks to identify why a service is unavailable.&lt;/p&gt;

&lt;p&gt;For example, consider an API endpoint that suddenly stops responding.&lt;/p&gt;

&lt;p&gt;Several questions immediately come to mind:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Is the hostname resolving correctly?&lt;/li&gt;
&lt;li&gt;Can a TCP connection be established?&lt;/li&gt;
&lt;li&gt;Is the TLS certificate valid?&lt;/li&gt;
&lt;li&gt;Is the HTTP endpoint responding as expected?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Each question investigates a different part of the service delivery process.&lt;/p&gt;

&lt;p&gt;I wanted to create a Python tool that could perform these checks consistently while also providing structured results suitable for scripting and automation.&lt;/p&gt;

&lt;p&gt;JC SRE NetProbe is a practical project that connects my telecommunications background with software development and SRE practices.&lt;/p&gt;

&lt;h2&gt;
  
  
  Getting Started
&lt;/h2&gt;

&lt;p&gt;JC SRE NetProbe requires &lt;strong&gt;Python 3.11 or newer&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Install the package using pip:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip &lt;span class="nb"&gt;install &lt;/span&gt;jc-sre-netprobe
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Once installed, the CLI is available directly from your terminal.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Checking TCP Connectivity
&lt;/h3&gt;

&lt;p&gt;To verify whether a remote service accepts TCP connections:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tcp github.com 443
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This checks connectivity to GitHub on TCP port 443.&lt;/p&gt;

&lt;p&gt;TCP connectivity checks are useful when investigating service availability, firewall restrictions, and network connectivity problems.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Checking DNS Resolution
&lt;/h3&gt;

&lt;p&gt;DNS plays a critical role in connecting applications to network services.&lt;/p&gt;

&lt;p&gt;To check hostname resolution:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe dns github.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This helps determine whether a hostname can be resolved before investigating higher-level protocols.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Checking HTTP/HTTPS Services
&lt;/h3&gt;

&lt;p&gt;A successful TCP connection doesn't necessarily mean that an application is healthy.&lt;/p&gt;

&lt;p&gt;To perform an HTTP health check:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe http https://github.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This provides an application-layer check of the endpoint.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Inspecting TLS Certificates
&lt;/h3&gt;

&lt;p&gt;TLS certificates are essential for secure communication.&lt;/p&gt;

&lt;p&gt;Expired or invalid certificates can cause application failures even when the underlying network is operational.&lt;/p&gt;

&lt;p&gt;To inspect a server's TLS certificate:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tls github.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also configure a timeout:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tls github.com &lt;span class="nt"&gt;--timeout&lt;/span&gt; 3
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  5. Working with IPv4 and IPv6 Networks
&lt;/h3&gt;

&lt;p&gt;The tool also provides network information for IPv4 and IPv6 address ranges.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe network 192.168.1.0/24
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This functionality can be useful when working with IP addressing and network infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  Designed for Automation
&lt;/h2&gt;

&lt;p&gt;One of the important aspects of JC SRE NetProbe is its ability to integrate with scripts and operational workflows.&lt;/p&gt;

&lt;h3&gt;
  
  
  JSON Output
&lt;/h3&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe &lt;span class="nt"&gt;--json&lt;/span&gt; tls github.com
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Structured output makes it easier to consume results programmatically and integrate checks into other tools.&lt;/p&gt;

&lt;h3&gt;
  
  
  Operational Exit Codes
&lt;/h3&gt;

&lt;p&gt;The CLI uses exit codes that can be interpreted by automation systems.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Exit Code&lt;/th&gt;
&lt;th&gt;Meaning&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;Target is healthy or check succeeded&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;Target is unhealthy or unavailable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Invalid CLI usage or input&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;jc-sre-netprobe tcp github.com 443
&lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="nv"&gt;$?&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This behavior makes the tool useful in shell scripts, CI/CD pipelines, and operational checks.&lt;/p&gt;

&lt;h2&gt;
  
  
  Using JC SRE NetProbe with Python
&lt;/h2&gt;

&lt;p&gt;In addition to its CLI, the package provides a Python API.&lt;/p&gt;

&lt;p&gt;For example, a TCP connectivity check can be performed directly from Python:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;jc_sre_netprobe&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;tcp_check&lt;/span&gt;

&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;tcp_check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;github.com&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;443&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;TLS checks are also available:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;jc_sre_netprobe&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;tls_check&lt;/span&gt;

&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;tls_check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;github.com&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This allows developers to reuse the network probing functionality inside their own applications and automation scripts.&lt;/p&gt;

&lt;h2&gt;
  
  
  Development and Code Quality
&lt;/h2&gt;

&lt;p&gt;Beyond implementing network checks, I wanted this project to follow good Python development practices.&lt;/p&gt;

&lt;p&gt;The repository includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Ruff&lt;/strong&gt; for linting&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mypy&lt;/strong&gt; for static type checking&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pytest&lt;/strong&gt; for automated testing&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Coverage&lt;/strong&gt; for test coverage analysis&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;GitHub Actions&lt;/strong&gt; for CI/CD&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PyPI Trusted Publishing&lt;/strong&gt; for package releases&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The CI pipeline validates the project against Python 3.11, 3.12, and 3.13.&lt;/p&gt;

&lt;p&gt;These practices help make the project more maintainable and provide a foundation for future improvements.&lt;/p&gt;

&lt;h2&gt;
  
  
  Networking Meets Site Reliability Engineering
&lt;/h2&gt;

&lt;p&gt;One of the aspects I enjoy most about this project is how it connects traditional networking concepts with modern SRE practices.&lt;/p&gt;

&lt;p&gt;In telecommunications and network engineering, troubleshooting frequently involves understanding protocols, connectivity, addressing, and service behavior.&lt;/p&gt;

&lt;p&gt;In SRE, these same concepts are essential for investigating reliability and availability.&lt;/p&gt;

&lt;p&gt;JC SRE NetProbe brings these perspectives together through lightweight black-box checks.&lt;/p&gt;

&lt;p&gt;It isn't intended to replace comprehensive monitoring and observability platforms. Instead, it provides focused diagnostic utilities that can complement existing operational workflows.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's Next?
&lt;/h2&gt;

&lt;p&gt;I plan to continue improving JC SRE NetProbe as I explore new ideas in network automation, Python development, DevOps, and SRE.&lt;/p&gt;

&lt;p&gt;Some areas worth exploring include additional diagnostic capabilities, improved automation integrations, and more examples of real-world usage.&lt;/p&gt;

&lt;p&gt;As an open-source project, feedback, suggestions, and contributions are welcome.&lt;/p&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Building JC SRE NetProbe has been an opportunity to combine my telecommunications engineering background with my interest in software development and infrastructure reliability.&lt;/p&gt;

&lt;p&gt;I believe that building practical tools is one of the best ways to deepen technical knowledge while contributing something useful to the community.&lt;/p&gt;

&lt;p&gt;If you work with networking, telecommunications, DevOps, or SRE, I'd love to hear your thoughts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What network diagnostic checks do you use most frequently in your daily work?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Feel free to explore the repository, open an issue, or contribute.&lt;/p&gt;

&lt;p&gt;⭐ &lt;strong&gt;GitHub:&lt;/strong&gt; &lt;a href="https://github.com/jacivaldocarvalho/jc-sre-netprobe" rel="noopener noreferrer"&gt;https://github.com/jacivaldocarvalho/jc-sre-netprobe&lt;/a&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Thanks for reading!&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Jacivaldo Carvalho&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Telecommunications Engineer | Networking | DevOps | SRE&lt;/em&gt;&lt;/p&gt;

</description>
      <category>python</category>
      <category>devops</category>
      <category>sre</category>
      <category>networking</category>
    </item>
  </channel>
</rss>
