CDG / ENGINEERINGContactSign in ↗

EXPERIENCE & DELIVERY

From a business problem
to a working platform.

Explore the responsibilities, technologies, and implementation work behind independent products and client engagements.

Application delivery. Infrastructure. Business systems. Automation. The thread through my work is ownership across the stack—from understanding the workflow to implementing the platform.

Experience spans municipal security operations, industrial IoT and robotics, complete business ecosystems, and independent Rust systems. Historical screenshots, current synthetic demonstrations, and architecture summaries are labeled throughout.

Security operations

July 2025–present

City of Coral Gables

Network Security Analyst · Security Engineering & Automation

Engineer municipal security workflows across telemetry, identity, endpoints and incident response, with custom automation and Rust tooling that connect system design to operational use.

Security EngineeringRustPythonSIEMSOARREST APIsWebhooksIdentityMicrosoft Entra IDIntuneLog NormalizationLinuxAutomation
City of Coral Gables engineering workflow summaryView image ↗
Illustrated role scope: a simplified architecture summary, not an employer screenshot or production network diagram.
Architecture & responsibilities

Security platform integration

Designed telemetry and automated-response workflows that connect a SIEM/SOAR platform with endpoint, identity and service-management systems. Built the integration layer with Python, REST APIs and webhooks.

From raw events to operational decisions

Built log parsers and normalization pipelines for identity, endpoint and core infrastructure signals. Connected detections to controlled response steps, analyst workflows and ticket creation rather than leaving alerts as disconnected records.

Rust tools for sensitive workflows

Designed Rust desktop tooling for encrypted evidence handling and a separate security-diagnostics platform. The work combined analyst usability, system integration and explicit handling of protected information.

Identity and endpoint engineering

Integrated Microsoft 365, Entra ID and Intune into security workflows, including identity actions and endpoint response. Worked across authentication behavior, permissions, telemetry and administrative APIs.

Reliability and diagnostic depth

Developed service-health monitoring and automated escalation workflows. Used log analysis and Linux runtime configuration to investigate system behavior and improve the repeatability of diagnostic work.

AI and automation boundaries

Reviewed security controls around coding agents, local model tooling, API automation and endpoint execution. Focused on the boundary between an automation capability and the authority required to use it.

    Platform & systems engineering

    August 2021–July 2025

    El Viejo Foods Inc.

    Lead Staff DevSecOps Software Engineer

    Connected enterprise application delivery with warehouse infrastructure, edge telemetry and robotics—bringing software, cloud services and physical devices into one operating model.

    RustGoC++ArduinoIoTRoboticsDistributed SystemsPythonReactTerraformKubernetesAWSGCPProxmox VECI/CD
    El Viejo Foods Inc. engineering workflow summaryView image ↗
    Illustrated role scope: a simplified architecture summary, not an employer screenshot or production network diagram.
    Architecture & responsibilities

    Hybrid-cloud systems design

    Designed a DevOps-oriented platform across GCP, AWS, Proxmox VE and Kubernetes. Used Terraform and version-controlled delivery workflows to define repeatable environments, workload placement, ingress, networking, secrets and configuration.

    Services that can evolve independently

    Separated supply-chain REST APIs, background workers and event streams into clear service boundaries. Designed synchronization and event-driven integration layers to reduce tight coupling between applications and operational systems.

    Rust and Go at the edge

    Designed Rust- and Go-based edge-to-cloud IoT architecture for cold-storage and truck-temperature telemetry. Connected device firmware, warehouse networks, backend APIs and centralized monitoring, spanning the boundary between physical measurements and business software.

    Robotics and embedded control

    Programmed warehouse robotics using C++ and Arduino, including low-level device behavior and interrupt handling. Worked across embedded systems, data processing and autonomous rover designs rather than limiting the solution to a web interface.

    Datacenter and device security

    Designed and operated Proxmox VE compute, storage and virtualization. Segmented warehouse edge devices, integrated camera and surveillance pipelines, and automated firewall controls to constrain communication across device and application boundaries.

    The operational interface

    Built Python/React applications, REST APIs and shared UI components around operational workflows. Connected application data and telemetry with interfaces that staff could use alongside warehouse and logistics processes.

      Platform & systems engineering

      August 2016–July 2021

      El Sembrador Foods Inc.

      Lead Software Platform Architect

      Designed and built a complete food-distribution technology ecosystem from the ground up, spanning the application platform, operational workflows, cloud architecture, and the infrastructure underneath them.

      Systems ArchitecturePlatform EngineeringReactNode.jsPHPMySQLGCPAWSKubernetesDockerProxmox VEREST APIsData Synchronization
      Current Atlas architecture: connected components and trust boundaries, synthetic demonstration.View image ↗
      Current Atlas architecture: connected components and trust boundaries, synthetic demonstration.
      Current Atlas routing interface: fictional dispatch routes and simulated driver positions.View image ↗
      Current Atlas routing interface: fictional dispatch routes and simulated driver positions.
      Architecture & responsibilities

      Whole-system architecture

      Owned the design across business workflows, services, data movement and infrastructure. Defined service boundaries and deployment patterns so the ecosystem could evolve beyond tightly coupled applications.

      Cloud platform and technical collaboration

      Developed the GCP platform architecture through design sessions with Google engineers, then connected AWS and GCP services through automated synchronization pipelines. The work included topology, data flows, availability and migration decisions.

      Application and integration engineering

      Built application workflows using React and Node.js alongside secure REST APIs and the earlier PHP/MySQL operational portal. Connected staff access, data administration, inventory and QR-oriented processes with distribution workflows.

      Delivery and isolation

      Designed Docker and Kubernetes deployment boundaries, ingress, namespace isolation and scaling patterns. Separated services so application changes, recovery and capacity decisions could be handled independently.

      Compute and operational foundations

      Led local datacenter and virtualized compute work, including Proxmox VE. Worked across backend execution paths, API handling and data access to support the software platform as its operational demands changed.

      A public demonstration of the engineering

      Northstar Atlas presents the ecosystem through a current, sanitized implementation and synthetic operational journeys. It makes service boundaries, governed changes and cross-functional workflows inspectable without publishing the original business systems or operational records.

        Explore Northstar Atlas / El Sembrador Ecosystem →Explore El Sembrador / Food Distribution Ecosystem →
        Independent practice

        Founded April 2013 · documented through March 2023

        MRGInnovations Inc.

        Creator & Software Engineer

        Led client application delivery across the software stack: infrastructure, APIs, data systems, and user interfaces.

        RustSystems ArchitecturePlatform EngineeringFull-Stack DevelopmentGoPythonReactKubernetesDockerNGINXMongoDBMySQLJenkins
        Archived MRGInnovations Inc. public interfaceView image ↗
        Archived MRGInnovations website from the original public portfolio.
        Architecture & responsibilities

        Engineering ownership across the stack

        Translated client business processes into application interfaces, APIs, data services and deployment environments. The scope covered implementation as well as the infrastructure needed to operate it.

        Delivery across technology generations

        Worked across Go, Python, PHP, JavaScript and React applications, with Linux/NGINX hosting, container platforms, databases and delivery tooling. Chose integration approaches around the business workflow rather than a single framework.

        Rust systems and security architecture

        My independent engineering practice now includes Athernex’s Rust SIEM, durable endpoint telemetry, DNS and browser policy enforcement, and edge-control models. The public implementations make decisions about persistence, replay identity, authorization and failure recovery available to inspect and test.

        • Launched web applications for clients using Go, Python, PHP, JavaScript and React.
        • Worked across Linux and NGINX hosting, Docker/Kubernetes deployments, databases and delivery tooling.
        • Connected application behavior to business processes through custom APIs and data services.
        Explore Athernex →Explore Crustacian →Explore MRGI Web Fabric / What’s the Point →Explore Apex-Kinetic →Public résumé reference ↗
        Client engineering

        March–May 2022

        Wolasky Law P.A.

        Software Engineer

        Automated email sorting and archiving for a legal-services workflow.

        AutomationPythonFlaskPowerShell.NETXML
        Wolasky Law P.A. engineering workflow summaryView image ↗
        Illustrated role scope: a simplified architecture summary, not an employer screenshot or production network diagram.
        Architecture & responsibilities

        Automation inside an existing environment

        Built custom email sorting and archival scripting around an established server workflow, connecting Python and Flask with PowerShell, .NET and XML interfaces.

        Operational workflow design

        Turned a repeated administrative process into a software workflow, accounting for the existing email and server boundaries instead of replacing the surrounding environment.

        • Developed custom scripting around email organization and archival tasks.
        • Used Python, Flask, PowerShell, .NET and XML to integrate with an existing server environment.
        • Translated a repetitive operational process into a maintainable automation workflow.
        Public résumé reference ↗
        Client engineering

        September 2021–February 2022

        Americas Professional Installers Network

        Software Engineer

        Built a custom CMS that brought vendor communication, contractor coordination and order management onto one platform.

        Full-Stack DevelopmentBusiness SystemsDjangoPythonSQLiteVue.jsAWS
        Archived Americas Professional Installers Network public interfaceView image ↗
        Archived APIN public website; the private vendor/contractor workflow is described separately.
        Architecture & responsibilities

        One application across multiple participants

        Built a custom CMS connecting vendors, contractors and order-management work. The role combined user workflows with the backend records and APIs needed to keep those participants coordinated.

        Application and data boundaries

        Implemented the platform with Django/Python, SQLite, Vue and JavaScript, using AWS and Git in development and delivery. The work spanned interface behavior, server-side processing and persistence.

        • Implemented a shared workflow for vendors and contractors.
        • Built application and data functionality with Django, Python, SQLite, Vue.js and JavaScript.
        • Used AWS and Git as part of development and delivery.
        Explore Professional Installers Network →Public résumé reference ↗
        Independent project

        June–October 2021

        Webplicity

        Creator

        Created an immersive portfolio interface to present previous work through interactive 3D experiences.

        XR/Immersive EngineeringReactNode.jsExpressA-FrameThree.js
        Archived Webplicity public interfaceView image ↗
        Archived Webplicity 3D portfolio scene, built with browser 3D frameworks.
        Architecture & responsibilities

        Spatial interaction as an application interface

        Designed an immersive portfolio that presents project information through an interactive browser-based 3D environment, using A-Frame and Three.js for rendering and interaction.

        Application structure behind the scene

        Connected the presentation layer with Node.js, React and Express. The engineering contribution is the experience and application integration; third-party rendering engines retain their own attribution.

        • Built interactive presentation workflows with Node.js, React and Express.
        • Used A-Frame and Three.js for browser-based 3D interaction.
        • Treated existing rendering frameworks as dependencies rather than independently authored engines.
        Explore Immersive Portfolio / Webplicity →Public résumé reference ↗
        Independent project

        First built 2021 · current suite 2026

        CharlesDerek.com

        Creator

        Built a portfolio and personal project-management interface backed by custom REST APIs.

        Full-Stack DevelopmentReactNode.jsExpressREST APIs
        Current Charles D. Gonzalez engineering portfolio showing the Athernex Rust SIEMView image ↗
        Current portfolio rebuild, 2026: real project evidence, structured content, search and interactive architecture.
        Architecture & responsibilities

        A product interface for technical work

        Built React interfaces and Node/Express REST APIs for a portfolio and personal project-management experience, joining presentation with structured project data.

        A continuing engineering artifact

        The current portfolio carries that work forward through generated HTML, shared structured content, local search, interactive architecture and tested synthetic demonstrations.

        • Developed application interfaces with React.
        • Implemented REST services with Node.js and Express.
        • Established a public home for technical work and project history.
        Explore Immersive Portfolio / Webplicity →Public résumé reference ↗
        Independent project

        March–August 2018

        HashtagShuffler

        Creator

        Developed a content-discovery tool that used fuzzy logic to find hashtags related to a user’s posts.

        Full-Stack DevelopmentSearchReactNode.jsMongoDBTestingAWS
        Archived HashtagShuffler public interfaceView image ↗
        Archived HashtagShuffler browser interface from the original portfolio.
        Architecture & responsibilities

        A complete discovery application

        Connected a React interface to a Node.js API and MongoDB persistence for hashtag discovery, with fuzzy matching described in the original project history.

        Behavior and verification

        Built and maintained unit tests around application behavior and used AWS in the development environment. Historical screenshots document the interface without claiming a currently operated service.

        • Built a React interface and Node.js API with MongoDB persistence.
        • Created and maintained automated unit tests.
        • Used AWS as part of the application environment.
        Explore Hashtag Shuffler →Public résumé reference ↗
        Client engineering

        January–April 2018

        Canero Tires LLC

        Software Engineer

        Developed a custom Go desktop accounting application and APIs to connect it with existing software.

        Business SystemsGoREST APIsMySQLMongoDBRedis
        Canero Tires LLC engineering workflow summaryView image ↗
        Illustrated role scope: a simplified architecture summary, not an employer screenshot or production network diagram.
        Architecture & responsibilities

        Accounting as a data-modeling problem

        Built a Go desktop accounting application around the business’s own workflows, then connected it to existing software through REST APIs.

        Integration beyond the desktop

        Worked across Go and JavaScript with MySQL, MongoDB and Redis. The engineering scope included application behavior, persistence and exchange between business systems.

        • Modeled accounting workflows in a custom desktop application.
        • Integrated the accounting platform with other systems through REST APIs.
        • Worked with Go, JavaScript, MySQL, MongoDB and Redis.
        Public résumé reference ↗
        Client engineering

        September–October 2017

        Focus On Imagination

        Developer

        Developed a business website with custom JavaScript integrations for forms and translation.

        Full-Stack DevelopmentJavaScriptjQueryAJAXAPI Integration
        Archived Focus On Imagination public interfaceView image ↗
        Archived Focus On Imagination website from the original portfolio.
        Architecture & responsibilities

        Custom integration in a client-facing site

        Implemented the interface with HTML, CSS, JavaScript, jQuery and AJAX, connecting site interactions to external services.

        Practical workflow delivery

        Integrated Google Drive Forms and Google Translate to support form submission and language access within the site experience.

        • Implemented the front end with HTML, CSS, JavaScript, jQuery and AJAX.
        • Integrated Google Drive Forms and Google Translate into the site experience.
        Explore Focus On Imagination →Public résumé reference ↗
        Independent project

        January–March 2017

        Timexecute

        Creator

        Developed a clock, timer, countdown and stopwatch application with configurable video-based alarms.

        Full-Stack DevelopmentJavaScriptNode.jsReactGeolocation
        Timexecute engineering workflow summaryView image ↗
        Illustrated role scope: a simplified architecture summary, not an employer screenshot or production network diagram.
        Architecture & responsibilities

        Interactive state and time

        Developed clock, countdown, timer and stopwatch interactions, including configurable video alarms, with JavaScript, Node.js and React.

        Context-aware behavior

        Integrated geolocation and time-zone detection so timing features could adapt to a user’s location context.

        • Built timing and alarm interactions with JavaScript, Node.js and React.
        • Integrated geolocation and time-zone detection into the user experience.
        Public résumé reference ↗
        Client engineering

        July 2010–April 2015

        The Recovery Units

        Software Engineer

        Developed a custom business platform covering content management, analytics, reporting and bookkeeping.

        Business SystemsRuby on RailsPostgreSQLReportingAWSDocker Compose
        Archived The Recovery Units public interfaceView image ↗
        Archived Recovery Units public site and product presentation.
        Architecture & responsibilities

        Business operations as a coherent application

        Built a Ruby on Rails and PostgreSQL platform covering content administration, reporting, analytics and bookkeeping, connecting the interface to day-to-day operational records.

        Data and service integration

        The original public portfolio also documents invoice management, API integration and S3 storage. The work joined business data, server-side application behavior and hosted services.

        • Implemented application workflows with Ruby on Rails and PostgreSQL.
        • Built reporting and administrative features around day-to-day business operations.
        • Worked with AWS, Apache and Docker Compose as part of the application environment.
        Explore RecoveryUnits Operations →Public résumé reference ↗

        See what that experience
        looks like in code.

        Explore systems →