JOBWAVE VERIFIED

CAD Software Engineer

Company: Not specified in the provided description
Job ID: 71750
Location: Chennai, Tamil Nadu, India
Work Mode: Hybrid
Experience: Around 5+ years
Education: Bachelor's degree or equivalent
Preferred Degree: Bachelor of Engineering
Employment Type: Full-time
Job Category: Enterprise Technology
Posting Date: October 9, 2026
Application Deadline: October 11, 2026, 12:00 AM (as listed in the posting)
Salary: Not specified
Core Domain: CAD/CAM Engineering, PLM, CAE, Engineering Software Development
Primary Stack: C, C++, Proprietary CAD SDKs, CATIA V5, 3DEXPERIENCE, CAA/RADE or equivalent, Microsoft Visual Studio
Related Platforms: Siemens NX, PTC Creo, SolidWorks, ENOVIA, Teamcenter, Windchill
Core Specialization: Native CAD customization, geometric modeling, feature modeling, data structures and algorithms

────────────────────

JOBWAVE INSIGHTS

Who Is This Role For?

This role is designed for an experienced C++ engineer who has worked directly on proprietary CAD/CAM or PLM platforms and developed custom engineering applications, plugins, commands, or extensions.

The ideal candidate combines strong native C++ programming skills with knowledge of CAD document structures, geometry and topology, feature modeling, SDK development, and debugging complex desktop engineering applications.

The key differentiator: This is not a general C++ developer position. Practical experience developing and debugging customizations inside an OEM or proprietary CAD platform is a core requirement.

Key Skills

• Programming: C, C++, object-oriented programming, design patterns
• Data Structures and Algorithms: Trees, graphs, linked lists, stacks, queues, hash maps, custom containers, complexity analysis
• CAD Platforms: CATIA V5, 3DEXPERIENCE, NX, Creo, SolidWorks, or proprietary equivalents
• CAD SDKs: CAA, RADE, vendor-specific APIs, platform development frameworks
• Object Modeler: Interfaces, implementation classes, object lifecycles, QueryInterface-style patterns
• CAD Data Models: Parts, assemblies, drawings, containers, specification trees, feature trees
• Geometry and Topology: B-Rep, bodies, faces, edges, wires, surfaces, geometric operators
• CAD Kernels: ACIS, Parasolid, or equivalent solid-modeling technologies
• Native Debugging: Visual Studio, runtime attachment, DLL debugging, memory leak diagnosis
• Mathematics: Linear algebra, vectors, rotations, transformations, trigonometry, interpolation
• Automation: VBA, CATScript, or equivalent scripting languages
• Engineering Practices: Git, regression testing, CI/CD, code quality scanning, JIRA

Priority Skills

Highest Priority

1. C++ and Native Programming — Pointers, memory management, object lifecycles, object-oriented design, debugging, and maintainable code.
2. Proprietary CAD Platform Development — Demonstrable experience creating custom commands, plugins, extensions, or applications using a CAD vendor's SDK.
3. Data Structures and Algorithms — Ability to select, implement, and optimize structures for engineering data and performance-critical operations.
4. CAD Object Modeler and Data Model — Understanding interfaces, implementation classes, document objects, feature trees, and platform-specific object patterns.
5. Geometric and Topological Modeling — B-Rep, bodies, faces, edges, wires, transformations, extrusions, fillets, and Boolean operations.
6. Native Debugging and Memory Management — Diagnosing crashes, memory leaks, dangling pointers, DLL issues, and runtime failures.
7. CAD SDK Build Environment — Working with platform workspaces, frameworks, modules, dependencies, and Visual Studio or equivalent tools.

Strong Advantages

• Direct experience with CATIA CAA/RADE or equivalent proprietary CAD development frameworks.
• Feature Modeler and knowledge-based engineering experience.
• PLM integrations using ENOVIA, Teamcenter, Windchill, or equivalent APIs.
• CAD drafting automation, drawing generation, dimensions, and annotations.
• VBA or platform-specific scripting for batch automation.
• Regression testing frameworks such as ODTT/mkodt or equivalents.
• Jenkins, GitLab CI, GitHub Actions, CMake, and static analysis tools.
• Automotive or aerospace CAD experience, including BIW, powertrain, or harness engineering.

What to Prepare

• Practise C++ pointers, references, smart pointers, object lifecycles, inheritance, polymorphism, and design patterns.
• Review trees, graphs, hash maps, linked lists, and algorithm complexity.
• Prepare an example of a CAD plugin or customization you developed.
• Explain the architecture of a CAD command, interface-based component, or feature extension.
• Review CAD document structures, specification trees, feature trees, and object relationships.
• Study B-Rep, geometric topology, transformations, Boolean operations, fillets, and extrusion.
• Practise debugging native applications, including crash dumps, memory leaks, and DLL loading problems.
• Prepare examples of SDK workspace configuration, module dependencies, builds, and deployment.
• Understand PLM lifecycle, document persistence, versioning, and session management.
• Prepare a real example of improving performance or resolving a difficult CAD customization issue.

What to Focus On

1. C++ Fundamentals and Memory Management

Expect detailed questions about pointers, references, object ownership, constructors and destructors, virtual functions, inheritance, RAII, smart pointers, and memory errors.

The interviewer may expect you to explain why a CAD application crashes when a custom object is destroyed or why a plugin creates a memory leak.

2. Data Structures and Algorithms

The role explicitly emphasizes data structures. Be ready to choose appropriate structures for representing CAD objects, feature dependencies, geometry relationships, and engineering hierarchies.

You should understand time and space complexity and how inefficient algorithms affect large assemblies or complex models.

3. Proprietary CAD SDK Development

Be able to explain how you create a custom command, define an interface, implement a component, integrate it into a CAD framework, configure dependencies, compile it, and debug it within the CAD application's runtime.

Platform-specific experience is important. General C++ knowledge alone may not satisfy this requirement.

4. Geometry, Topology, and CAD Kernels

Understand the distinction between geometry and topology, and how solid models represent faces, edges, wires, shells, and bodies.

Prepare to explain transformations, coordinate systems, extrusion, filleting, Boolean operations, and geometric tolerances at a conceptual and practical level.

5. Native Debugging

Know how to attach a debugger to a running CAD executable, inspect call stacks, set breakpoints, trace object lifetimes, investigate access violations, and diagnose custom DLL loading issues.

6. PLM Integration and Engineering Automation

Understand how CAD applications interact with PLM systems, including document opening and saving, session management, lifecycle state, versioning, and engineering metadata.

Automation and drafting APIs are useful additional areas to review.

────────────────────

JOB DETAILS

Original Role Information

Role Overview

The CAD Software Engineer will design, develop, customize, test, and maintain engineering software built on proprietary CAD/CAM, PLM, or CAE platforms.

The work combines native C/C++ programming, vendor-specific SDKs, geometry and topology operations, feature-modeling extensions, custom data structures, engineering automation, and PLM-integrated applications.

The engineer will also contribute to debugging, build management, testing, software quality, and engineering process compliance.

Responsibilities

CAD Application Development

• Develop and maintain custom applications using C/C++, vendor SDKs, and platform frameworks.
• Create custom commands, dialogs, interface-based components, state-machine workflows, and reusable modules.
• Extend CAD functionality using object-modeler and feature-modeler concepts.
• Maintain customizations across proprietary or OEM engineering platforms.

Data Structures and Algorithms

• Design and optimize trees, graphs, hash maps, linked lists, and custom containers.
• Represent and manipulate geometry, topology, feature relationships, and engineering data.
• Apply complexity analysis to improve performance and maintainability.

Geometry and Feature Modeling

• Implement functionality involving bodies, faces, edges, wires, and B-Rep representations.
• Work with transformations, extrusion, filleting, Boolean operations, and surface projections.
• Support feature parameters, rules, checks, catalogs, and user-defined features.
• Automate drafting tasks where applicable, including drawing views, dimensions, and annotations.

CAD Framework and Build Management

• Configure workspaces, frameworks, modules, and dependencies.
• Develop and build native components using Microsoft Visual Studio or equivalent environments.
• Manage platform-specific build systems and custom DLLs.
• Work with file-based and PLM/database-driven architectures.

Debugging and Testing

• Debug native applications using platform runtime executables.
• Investigate crashes, memory leaks, dangling pointers, and DLL-related issues.
• Support automated tests, regression testing, CI/CD, and static code analysis.
• Maintain software quality and engineering documentation.

Engineering Process and Collaboration

• Follow defined software development process models.
• Maintain JIRA artifacts.
• Support version control and release workflows.
• Collaborate with engineering teams working on CAD, PLM, and related systems.

────────────────────

REQUIREMENTS

Experience

• Around 5+ years of CAD/CAM engineering software development experience.
• Hands-on experience with customizations, plugins, or extensions on a proprietary CAD platform.
• Experience with native C++ development and debugging.
• Familiarity with CAD SDK environments, build processes, and engineering data models.

Programming and Software Design

• Strong C++ proficiency.
• C and native application development knowledge.
• Object-oriented design and design patterns.
• Pointers, memory management, object lifecycle handling, and debugging.
• Interface-based programming, implementation classes, and QueryInterface-style patterns.
• Efficient, reusable, and maintainable software components.

Data Structures and Algorithms

• Arrays, linked lists, stacks, queues, trees, graphs, hash maps, and sets.
• Custom containers and data structure implementation.
• Time and space complexity.
• Algorithm selection and performance optimization.

CAD Platform Development

• CATIA V5, 3DEXPERIENCE, Siemens NX, PTC Creo, SolidWorks, or equivalent proprietary systems.
• Vendor-specific SDKs, CAA/RADE, or equivalent development frameworks.
• Object Modeler and Data Model concepts.
• Feature Modeler.
• Geometric and Topological Modeler concepts.
• Platform workspaces, frameworks, modules, and dependency management.

Geometry and Mathematics

• B-Rep and solid-modeling concepts.
• Bodies, faces, edges, wires, and surfaces.
• Geometric operators, extrusion, fillets, Boolean operations, and transformations.
• Linear algebra, vectors, rotations, coordinate systems, trigonometry, and interpolation.
• Knowledge of CAD kernels such as ACIS or Parasolid.

Debugging and Build Systems

• Native debugging with Visual Studio or equivalent tools.
• Attaching debuggers to the CAD platform's runtime executable.
• Diagnosing memory leaks, dangling pointers, crashes, and custom DLL issues.
• Building and managing modules and dependencies in the vendor-specific environment.

Automation and Engineering Practices

• VBA, CATScript, or equivalent scripting.
• Git and version control.
• Regression testing and test automation.
• CI/CD build automation.
• Static code analysis.
• JIRA and software process compliance.

Preferred Additional Skills

• Java or JavaScript for PLM-related extensions.
• Knowledge-based engineering, rules, checks, parameters, catalogs, and UDFs.
• Drafting APIs and drawing automation.
• ENOVIA, Teamcenter, Windchill, or equivalent PLM APIs.
• ODTT/mkodt or equivalent CAD regression testing frameworks.
• Jenkins, GitLab CI, GitHub Actions, CMake, and static analysis tooling.
• Automotive or aerospace engineering domain experience.

────────────────────

QUALIFICATIONS

• Bachelor's degree or equivalent; a Bachelor of Engineering is preferred.
• Around 5+ years of CAD/CAM engineering development experience.
• Strong native C++ development skills.
• Demonstrated experience developing custom software on a proprietary CAD platform.
• Understanding of object-modeler architecture and CAD data models.
• Practical knowledge of CAD geometry, topology, and solid modeling.
• Ability to debug and maintain complex native engineering applications.
• Strong problem-solving skills and understanding of algorithm efficiency.

────────────────────

POTENTIAL GAPS TO CHECK

Evaluate your experience against these areas before applying:

• No proprietary CAD development: This is the most significant potential gap. General C++ or desktop software experience may not replace hands-on CAD platform customization.
• Limited SDK experience: Be prepared to show that you have worked with vendor frameworks, APIs, build systems, and platform-specific objects.
• Weak native C++ fundamentals: Pointers, memory management, object lifecycles, and debugging are emphasized throughout the description.
• Limited geometry knowledge: A developer without familiarity with B-Rep, topology, CAD kernels, and transformations may find the technical interview challenging.
• Weak data structures and algorithms: The job explicitly requires practical implementation and complexity analysis, not just theoretical familiarity.
• No CAD runtime debugging: Experience diagnosing native crashes and custom DLL problems is a key advantage.
• Limited PLM integration: This is a nice-to-have rather than the central requirement, but it can strengthen your profile.
• No CI/CD or regression testing: These are supporting skills and may be learnable, but production-quality engineering practices matter.

Important: The description allows experience with different proprietary CAD platforms; it does not require deep expertise in one specific named tool. However, it does require demonstrated experience developing customizations or extensions on a proprietary platform. A candidate with five years of general C++ experience but no CAD SDK work may not be a strong match.

────────────────────

INTERVIEW PREPARATION

Phase 1 — C++ and Data Structures

• Explain pointer versus reference, stack versus heap, and raw pointers versus smart pointers.
• Review constructors, destructors, virtual destructors, inheritance, polymorphism, and RAII.
• Practise linked lists, trees, graphs, hash maps, and custom container problems.
• Explain time and space complexity for common operations.
• Discuss memory leaks, dangling pointers, access violations, and object ownership.

Phase 2 — CAD Platform and SDK Architecture

• Describe the CAD platform you have worked with and the customizations you built.
• Explain how commands, dialogs, interfaces, and implementation classes are structured.
• Discuss object-modeler and feature-modeler concepts.
• Explain how parts, assemblies, containers, and specification trees relate to one another.
• Describe how you configure SDK workspaces, frameworks, modules, and dependencies.
• Prepare to explain a complete plugin development and debugging workflow.

Phase 3 — Geometry, Topology, and Native Debugging

• Explain the difference between geometric and topological representations.
• Review B-Rep, bodies, faces, edges, wires, shells, and solid models.
• Discuss coordinate transformations, rotations, vectors, and matrix operations.
• Explain extrusion, filleting, Boolean operations, and surface projections.
• Describe how you diagnose a native crash inside a CAD application.
• Explain how you investigate memory corruption, leaks, and custom DLL failures.

Phase 4 — PLM, Automation, and Engineering Quality

• Explain CAD-to-PLM integration and document lifecycle management.
• Review open/save operations, versioning, session management, and lifecycle states.
• Prepare examples of scripting-based CAD automation.
• Explain regression testing for CAD customizations.
• Discuss CI/CD builds, Git workflows, static analysis, and release management.
• Review how you track engineering work and technical issues in JIRA.

Final Interview Focus

Prepare project-based answers to these questions:

1. Describe a CAD customization or plugin you developed using a proprietary SDK.
2. How does the object-modeler architecture work in your CAD platform?
3. How would you create a custom command and integrate it into a CAD application?
4. Explain the role of interfaces, implementation classes, and QueryInterface-style patterns.
5. How would you select a data structure to represent a feature tree or dependency graph?
6. What is B-Rep, and how are faces, edges, and wires related?
7. How would you implement or automate a geometric operation such as extrusion or a Boolean operation?
8. How do you debug a crash in a CAD application's runtime executable?
9. How would you identify a memory leak or dangling pointer in a native plugin?
10. How do you manage SDK workspaces, dependencies, modules, and custom DLLs?
11. How would you integrate a CAD customization with a PLM system?
12. How do you test a CAD customization without breaking existing engineering workflows?

Recommended preparation order: C++ and memory management → data structures and algorithms → proprietary CAD SDK experience → geometry and topology → native debugging → PLM integration and automated testing.

Final recommendation: Treat this as a specialized CAD platform engineering role rather than a conventional software development position. Your strongest evidence will be a real CAD customization project where you can explain the platform architecture, your C++ implementation, the geometry or engineering problem solved, the debugging challenges, and the final result.