C/VC++ Technical Architect

Infomagnus•Huntington Beach, CA

About The Position

With 12+ years of extensive experience as C/VC++ Technical Architect in native software engineering and application architecture, delivering complex Windows applications, modernization strategies, production C/C++ development, and technically demanding software solutions. Architected C/VC++ applications using Microsoft Visual C++, Visual Studio, Windows APIs, DLLs, multithreading, memory management, resource management, debugging, profiling, and performance optimization for complex production software environments. Designed application and component architectures for brownfield and legacy systems, establishing interfaces, technical roadmaps, modernization strategies, reusable components, compatibility approaches, and maintainable implementation patterns across evolving software platforms. Developed native Windows desktop applications with C++, VC++, Qt, and OpenGL-oriented visualization components, combining hands-on implementation with architecture decisions, technical troubleshooting, integration, diagnostics, and production engineering responsibilities. Established architecture documentation using UML, component diagrams, sequence diagrams, interface specifications, technical design documents, and architectural decision records to communicate technical solutions and implementation direction across engineering teams. Led design reviews, code reviews, framework evaluations, architecture trade-off discussions, debugging sessions, and technical mentoring while remaining hands-on with C/VC++ production code and complex engineering problems. Applied structured verification, configuration management, diagnostics, testing, cybersecurity considerations, and controlled release practices to long-lived software systems, strengthening reliability, maintainability, compatibility, and operational readiness across development lifecycles. Collaborated with engineering, product, and technical stakeholders to translate requirements into application architecture, component interfaces, implementation plans, modernization roadmaps, testing strategies, and sustainable production solutions for complex software environments.

Requirements

12+ years of extensive experience as C/VC++ Technical Architect in native software engineering and application architecture
Delivering complex Windows applications
Modernization strategies
Production C/C++ development
Technically demanding software solutions
Architected C/VC++ applications using Microsoft Visual C++, Visual Studio, Windows APIs, DLLs, multithreading, memory management, resource management, debugging, profiling, and performance optimization for complex production software environments
Designed application and component architectures for brownfield and legacy systems
Establishing interfaces, technical roadmaps, modernization strategies, reusable components, compatibility approaches, and maintainable implementation patterns across evolving software platforms
Developed native Windows desktop applications with C++, VC++, Qt, and OpenGL-oriented visualization components
Combining hands-on implementation with architecture decisions, technical troubleshooting, integration, diagnostics, and production engineering responsibilities
Established architecture documentation using UML, component diagrams, sequence diagrams, interface specifications, technical design documents, and architectural decision records to communicate technical solutions and implementation direction across engineering teams
Led design reviews, code reviews, framework evaluations, architecture trade-off discussions, debugging sessions, and technical mentoring while remaining hands-on with C/VC++ production code and complex engineering problems
Applied structured verification, configuration management, diagnostics, testing, cybersecurity considerations, and controlled release practices to long-lived software systems, strengthening reliability, maintainability, compatibility, and operational readiness across development lifecycles
Collaborated with engineering, product, and technical stakeholders to translate requirements into application architecture, component interfaces, implementation plans, modernization roadmaps, testing strategies, and sustainable production solutions for complex software environments
Architected C/VC++ native Windows applications using Microsoft Visual C++, Visual Studio, Windows APIs, DLL interfaces, and component boundaries, establishing maintainable structures for complex production engineering software.
Defined brownfield modernization strategies for tightly coupled C++ components, evaluating compatibility, dependencies, interfaces, and implementation sequencing to improve maintainability while protecting stable legacy application behavior.
Designed Qt desktop application architecture with reusable C++ components, event-driven interfaces, service boundaries, and native Windows integration, creating consistent foundations for engineering workflows and future application enhancements.
Engineered OpenGL visualization components by defining rendering interfaces, graphics data flows, visualization services, and diagnostic hooks, enabling maintainable presentation of complex technical information within native Windows applications.
Optimized multithreaded C/VC++ processing through profiling, debugging, synchronization analysis, memory inspection, and resource lifecycle review, improving runtime responsiveness and strengthening application stability under demanding workloads.
Established UML component diagrams, sequence diagrams, architecture decision records, interface specifications, and technical roadmaps, providing engineering teams with consistent guidance for implementation, verification, integration, and controlled releases.
Led C/VC++ design reviews and code reviews, evaluating architecture trade-offs, framework choices, interface quality, memory management, debugging approaches, and maintainability while mentoring engineers through difficult technical decisions.
Coordinated testing, diagnostics, verification, configuration management, cybersecurity considerations, and controlled release activities, aligning native software implementation with disciplined engineering processes and long-term production reliability.
Led C/VC++ application engineering using Microsoft Visual C++, Visual Studio, Windows APIs, DLL interfaces, and multithreading patterns, improving component maintainability across interconnected production software.
Designed modernization increments for legacy C++ modules by assessing dependencies, separating reusable services, preserving compatibility interfaces, and sequencing implementation changes to reduce disruption across established application workflows.
Developed native Windows components in VC++ using Visual Studio, applying memory management, resource management, exception handling, and debugging techniques to resolve difficult integration defects and improve application reliability.
Implemented Qt desktop components with reusable controls, C++ service abstractions, event-driven interactions, and native Windows integration, improving consistency across technical application workflows and maintainability of interface logic.
Optimized multithreaded C++ processing by analyzing synchronization, resource contention, memory behavior, and execution paths through profiling and debugging, improving responsiveness and predictable runtime behavior.
Supported OpenGL visualization integration by organizing rendering interfaces, graphics data preparation, application services, and diagnostic instrumentation for maintainable desktop visualization capabilities.
Led architecture and code reviews, evaluating C/VC++ implementation quality, component boundaries, framework suitability, technical trade-offs, and testability while mentoring engineers on modernization and integration decisions.
Created technical architecture documentation covering UML flows, component relationships, sequence interactions, interface dependencies, verification considerations, configuration requirements, and controlled release activities for distributed engineering teams.
Engineered native Windows applications in C/VC++ using Microsoft Visual C++, Visual Studio, Windows APIs, and reusable components, improving maintainability across precision-oriented technical software.
Developed Qt desktop components and C++ services, organizing event handling, data exchange, interface boundaries, and error management to provide consistent application behavior across technical workflows.
Integrated OpenGL visualization structures with C++ application services, coordinating rendering data, graphics interfaces, and lifecycle management to support responsive technical visualization and maintainable display capabilities.
Analyzed VC++ performance issues using debugging and profiling techniques, examining memory management, resource usage, multithreading behavior, and execution paths to improve runtime stability and responsiveness.
Modernized legacy C++ modules by identifying dependencies, defining cleaner component interfaces, refactoring implementation paths, and preserving compatibility with established application behavior and integrations.
Created UML component diagrams, sequence diagrams, interface documentation, and architecture decision records to clarify technical behavior, dependencies, implementation assumptions, and design direction for engineering teams.
Participated in C/VC++ design reviews and code reviews, identifying maintainability concerns, integration risks, debugging opportunities, and implementation improvements while providing technical guidance to development teams.
Applied verification, integration testing, diagnostics, configuration management, and controlled release practices to native applications, strengthening traceability and production stability across evolving technical software.
Developed C/VC++ Windows components using Visual Studio, Windows APIs, reusable modules, interface contracts, and resource management practices to support reliable application enhancement.
Implemented multithreading and synchronization patterns in C++, troubleshooting execution conflicts and resource behavior through structured debugging to improve application stability during production workflows.
Built Qt interface components and native C++ services, connecting user interactions with application logic to simplify desktop workflows and maintain consistent functionality across related features.
Supported OpenGL-oriented visualization components by integrating graphics processing, rendering interfaces, and application data flows for responsive technical displays and maintainable visualization behavior.
Resolved legacy C++ integration issues by tracing dependencies, reviewing component boundaries, correcting resource-handling defects, and validating changes through focused integration and regression testing.
Prepared technical documentation covering C/VC++ component interfaces, sequence behavior, implementation assumptions, testing considerations, and release dependencies for developers and technical reviewers.
Participated in code reviews and design discussions, identifying VC++ maintainability concerns, integration risks, performance issues, and debugging opportunities while following established engineering standards.
Supported verification, configuration management, diagnostics, and controlled releases for native Windows software, preserving compatibility while introducing incremental application improvements.
Implemented C++ and VC++ enhancements for Windows applications, maintaining established components and resolving defects through debugging, testing, and code review practices.
Developed reusable C++ modules and interface changes using Visual Studio, following established design patterns, memory management, resource handling, and coding standards.
Supported Qt desktop functionality by integrating application logic, validating user workflows, troubleshooting interface behavior, and documenting defects through focused testing.
Assisted with multithreaded C++ troubleshooting by tracing execution behavior, synchronization issues, memory usage, and resource handling to resolve application reliability defects.
Maintained legacy Windows components by analyzing dependencies, correcting implementation issues, reviewing compatibility concerns, and validating changes before controlled releases.
Prepared technical documentation describing component changes, interface behavior, test results, implementation considerations, and release dependencies for senior engineers and development teams.
Participated in C++ code reviews and integration testing, applying team standards to improve implementation consistency, identify defects, and reduce regression risk.
Supported diagnostics and release activities by reproducing issues, documenting findings, validating fixes, and coordinating confirmed resolutions with senior engineers before production deployment.

Responsibilities

Architected C/VC++ native Windows applications using Microsoft Visual C++, Visual Studio, Windows APIs, DLL interfaces, and component boundaries, establishing maintainable structures for complex production engineering software.
Defined brownfield modernization strategies for tightly coupled C++ components, evaluating compatibility, dependencies, interfaces, and implementation sequencing to improve maintainability while protecting stable legacy application behavior.
Designed Qt desktop application architecture with reusable C++ components, event-driven interfaces, service boundaries, and native Windows integration, creating consistent foundations for engineering workflows and future application enhancements.
Engineered OpenGL visualization components by defining rendering interfaces, graphics data flows, visualization services, and diagnostic hooks, enabling maintainable presentation of complex technical information within native Windows applications.
Optimized multithreaded C/VC++ processing through profiling, debugging, synchronization analysis, memory inspection, and resource lifecycle review, improving runtime responsiveness and strengthening application stability under demanding workloads.
Established UML component diagrams, sequence diagrams, architecture decision records, interface specifications, and technical roadmaps, providing engineering teams with consistent guidance for implementation, verification, integration, and controlled releases.
Led C/VC++ design reviews and code reviews, evaluating architecture trade-offs, framework choices, interface quality, memory management, debugging approaches, and maintainability while mentoring engineers through difficult technical decisions.
Coordinated testing, diagnostics, verification, configuration management, cybersecurity considerations, and controlled release activities, aligning native software implementation with disciplined engineering processes and long-term production reliability.
Led C/VC++ application engineering using Microsoft Visual C++, Visual Studio, Windows APIs, DLL interfaces, and multithreading patterns, improving component maintainability across interconnected production software.
Designed modernization increments for legacy C++ modules by assessing dependencies, separating reusable services, preserving compatibility interfaces, and sequencing implementation changes to reduce disruption across established application workflows.
Developed native Windows components in VC++ using Visual Studio, applying memory management, resource management, exception handling, and debugging techniques to resolve difficult integration defects and improve application reliability.
Implemented Qt desktop components with reusable controls, C++ service abstractions, event-driven interactions, and native Windows integration, improving consistency across technical application workflows and maintainability of interface logic.
Optimized multithreaded C++ processing by analyzing synchronization, resource contention, memory behavior, and execution paths through profiling and debugging, improving responsiveness and predictable runtime behavior.
Supported OpenGL visualization integration by organizing rendering interfaces, graphics data preparation, application services, and diagnostic instrumentation for maintainable desktop visualization capabilities.
Led architecture and code reviews, evaluating C/VC++ implementation quality, component boundaries, framework suitability, technical trade-offs, and testability while mentoring engineers on modernization and integration decisions.
Created technical architecture documentation covering UML flows, component relationships, sequence interactions, interface dependencies, verification considerations, configuration requirements, and controlled release activities for distributed engineering teams.
Engineered native Windows applications in C/VC++ using Microsoft Visual C++, Visual Studio, Windows APIs, and reusable components, improving maintainability across precision-oriented technical software.
Developed Qt desktop components and C++ services, organizing event handling, data exchange, interface boundaries, and error management to provide consistent application behavior across technical workflows.
Integrated OpenGL visualization structures with C++ application services, coordinating rendering data, graphics interfaces, and lifecycle management to support responsive technical visualization and maintainable display capabilities.
Analyzed VC++ performance issues using debugging and profiling techniques, examining memory management, resource usage, multithreading behavior, and execution paths to improve runtime stability and responsiveness.
Modernized legacy C++ modules by identifying dependencies, defining cleaner component interfaces, refactoring implementation paths, and preserving compatibility with established application behavior and integrations.
Created UML component diagrams, sequence diagrams, interface documentation, and architecture decision records to clarify technical behavior, dependencies, implementation assumptions, and design direction for engineering teams.
Participated in C/VC++ design reviews and code reviews, identifying maintainability concerns, integration risks, debugging opportunities, and implementation improvements while providing technical guidance to development teams.
Applied verification, integration testing, diagnostics, configuration management, and controlled release practices to native applications, strengthening traceability and production stability across evolving technical software.
Developed C/VC++ Windows components using Visual Studio, Windows APIs, reusable modules, interface contracts, and resource management practices to support reliable application enhancement.
Implemented multithreading and synchronization patterns in C++, troubleshooting execution conflicts and resource behavior through structured debugging to improve application stability during production workflows.
Built Qt interface components and native C++ services, connecting user interactions with application logic to simplify desktop workflows and maintain consistent functionality across related features.
Supported OpenGL-oriented visualization components by integrating graphics processing, rendering interfaces, and application data flows for responsive technical displays and maintainable visualization behavior.
Resolved legacy C++ integration issues by tracing dependencies, reviewing component boundaries, correcting resource-handling defects, and validating changes through focused integration and regression testing.
Prepared technical documentation covering C/VC++ component interfaces, sequence behavior, implementation assumptions, testing considerations, and release dependencies for developers and technical reviewers.
Participated in code reviews and design discussions, identifying VC++ maintainability concerns, integration risks, performance issues, and debugging opportunities while following established engineering standards.
Supported verification, configuration management, diagnostics, and controlled releases for native Windows software, preserving compatibility while introducing incremental application improvements.
Implemented C++ and VC++ enhancements for Windows applications, maintaining established components and resolving defects through debugging, testing, and code review practices.
Developed reusable C++ modules and interface changes using Visual Studio, following established design patterns, memory management, resource handling, and coding standards.
Supported Qt desktop functionality by integrating application logic, validating user workflows, troubleshooting interface behavior, and documenting defects through focused testing.
Assisted with multithreaded C++ troubleshooting by tracing execution behavior, synchronization issues, memory usage, and resource handling to resolve application reliability defects.
Maintained legacy Windows components by analyzing dependencies, correcting implementation issues, reviewing compatibility concerns, and validating changes before controlled releases.
Prepared technical documentation describing component changes, interface behavior, test results, implementation considerations, and release dependencies for senior engineers and development teams.
Participated in C++ code reviews and integration testing, applying team standards to improve implementation consistency, identify defects, and reduce regression risk.
Supported diagnostics and release activities by reproducing issues, documenting findings, validating fixes, and coordinating confirmed resolutions with senior engineers before production deployment.