Technology
›
Semiconductor & Chip Design
›
Automotive Chip Design
Driver Assistance Chip Design (ADAS)
Long-cycle design programs where IP, foundry, and ecosystem partnerships execute against tapeout and market windows.
Example organizations in this space:
Mobileye
Qualcomm
NVIDIA
NXP
This interactive experience is the shipped product itself — the same application code customers run in production, mounted read-only in your browser over a real sample journey. Not a video, not a mockup: because the demo and the product are one codebase, it can never drift from the real thing.
Inside this journey
-
Pre-Sales
Qualify and diagnose stakeholder needs, technical constraints, and success criteria before formal evaluation.
-
Qualification
Confirm budget window, decision authority, program timeline, and high-level technical constraints before investing in full discovery.
Qualification Questions
High-level technical constraints (quick readiness check)
- Which of these best describes your peak inference throughput requirement for perception and planning?
- What is the hard end-to-end latency requirement for your safety‑critical path (perception → planning → actuation)?
- Please summarize any explicit power or thermal budget per compute module we should assume (Watt range or vehicle thermal constraint).
Budget window (brief)
- Is there an allocated budget range per unit for the compute platform at this stage?
Decision authority (who to involve)
- Who signs the final purchase or supply agreement for this program (role/title is fine)?
- Please list any technical approvers or integration owners we should include in a full discovery (role and title is fine).
Program timeline (decision-driving dates)
- Which best matches your target start-of-production or decision milestone driving this timeline?
- What single timing constraint should we know about (OEM approval window, funding gate, or similar)?
-
Outcome Discovery
Map desired vehicle-level outcomes, current compute and algorithm constraints, stakeholder roles, and measurable success signals.
Discovery Questions
Program snapshot in one sentence
- Give a one-sentence summary of this ADAS or autonomy program, including target SAE level and planned start of production year
- Estimate the active headcount focused on perception, sensor fusion, and planning for this program
- Name the vehicle domains in scope for this compute selection, for example highway pilot, urban pilot, parking
- Identify the role at the OEM that holds final approval authority for the Tier 1's compute selection
- Select the budget band allocated per vehicle for compute hardware for this program
Outcome targets that will determine success
- What single performance shortfall would make you walk away from a candidate compute platform immediately
- List the top three measurable outcomes you must hit for perception and planning to consider a platform acceptable
- Provide your target end-to-end deterministic latency for the safety-critical path, expressed in milliseconds
- Select which operational signals you will use during evaluation to accept or reject a candidate
- If the evaluation reproduces the performance numbers you need, what internal obstacle would still prevent you from signing within 30 days
Where your current architecture strains under real conditions
- Identify the component or stage in your current compute pipeline that most frequently causes dropped frames or missed deadlines in vehicle tests
- Describe your sensor mix and per-sensor data rates you plan to process in production
- Estimate peak model compute needs for your largest networks, in approximate TOPS or inferences per second
- Specify the steady-state power or thermal envelope you must stay within for the compute ECU
- Identify any legacy interfaces or ECU functions that the new compute must preserve or emulate
- Is there a hardware constraint that would disqualify a candidate immediately, for example package size, automotive qualification level, or supplier location
Integration realities people defer until late
- Which single integration dependency, if missing on day one, would block your team for months
- Indicate who owns the vehicle integration APIs and where those specifications are documented
- Do you have representative, calibrated sensor rigs and labelled datasets available for initial benchmarking
- Estimate how many full-time engineers can be assigned to an initial two-month integration sprint
- Select the model training and deployment frameworks your team uses that we must support during evaluation
- If the required APIs or datasets are only partially available, what contingency plan will your team execute and how long would it add to integration
Approval gates and schedule pressure
- Point to the single sign-off step at the OEM most likely to cause a hard stop or multi-quarter delay
- Select your target date for the vendor selection decision
- List the internal roles expected to participate in the final decision, for example procurement, systems architecture, safety, software lead
- Describe the evidence the OEM requires for technical approval, for example lab pass criteria, aging tests, or functional safety artefacts
- If a pilot proves the technical thresholds you need, what remaining business or contractual approvals would still block an immediate commitment
Known risks and the unknowns that matter
- Which single integration or qualification risk would cause you to stop the program today
- Rate the likelihood that supply chain or AEC-Q automotive qualification will introduce schedule slips
- Provide examples of past field regressions after software or hardware updates and the business impact of those regressions
- Select regulatory or compliance approvals you anticipate for this compute change
- Specify the contingency budget or schedule buffer you have allocated to absorb an unexpected redesign
Alternatives you are actively weighing
- If you were to stay with your current supplier, what measurable outcome would have to be true to justify no change
- Choose all alternatives you are actively evaluating right now
- Name any internal proposal to design compute in-house and indicate who is sponsoring that option
- What would need to be true about your incumbent for you to retain them rather than switch to a new supplier
- If an external supplier matches your top three technical criteria, would OEM re-evaluation be required or could the Tier 1 finalize selection
Operational readiness and hard constraints
- Do you have the dedicated owners and headcount to execute an initial integration and benchmark within the next 3 months
- Identify the integration owners we should expect to work with and the typical weekly availability they can commit
- Are HIL rigs, sensor labs, and vehicle test seats available for vendor-led validation
- Is your production dataset labelled and accessible for benchmarking under NDAs
- Are there contractual, export control, or IP constraints that could prevent us from shipping evaluation samples or toolchains to your locations
- If required prerequisites are not met within 8 weeks, will you pause vendor selection or extend the timeline
What would make a decision simple and fast
- What single objective benchmark result in an initial hands-on test would cause procurement to sign within 30 days
- Select the acceptance thresholds you require for throughput, latency, power, and functional safety documentation
- Identify which role or title will sign the technical acceptance report after evaluation
- Specify any commercial or supply terms you need to see before committing, for example allocation guarantees, lead time caps, or price bands
- Assuming pilot results meet your thresholds, list the remaining approvals and an estimated timeline for each
-
-
Platform Evaluation
Run hands-on benchmarks and integration tests against the buyer's neural models, real-time latency, and power/thermal budgets to validate fit-for-program acceptance criteria.
- desired_state
- current_state
- decision_readiness
- stakeholders
- gaps
- success_criteria
- stakeholders
- decision_readiness
- current_state
- desired_state
- success_criteria
- gaps
- current_state
- decision_readiness
- decision_readiness
- decision_readiness
- decision_readiness
- decision_readiness
-
Solution Scope
Define the multi-chip or single-chip configuration, software toolchain deliverables, safety targets, responsibilities, and measurable acceptance criteria.
Scope Configuration
- Automotive-Qualified SoC Silicon Shipment
- Evaluation Board with Multi-Sensor Interfaces
- Board Support Package and RTOS Integration
- SDK with Sensor and Inference APIs
- Neural Network Compiler and Runtime Package
- On-target Model Compilation and Quantization
- Sensor Fusion Middleware Stack Delivery
- Computer Vision Engine Reference Implementations
- ASIL-B and ASIL-D Safety Subsystem Delivery
- Deterministic Real-Time Scheduling Engine
- Power and Thermal Management Firmware
- Production Supply Commitment and Lifecycle Package
Scope Questions
Automotive-Qualified SoC Silicon Shipment
- Confirm the AEC-Q100 grade and ISO 26262 automotive safety integrity level (ASIL) target required for the SoC.
- Which electrical and EMC qualifications must be included for the silicon delivery (for example HBM ESD thresholds, conducted/radiated EMC levels, IEC/ISO test profiles)?
- List the production sample sizes and production part approval documents you require (for example PPAP level, first article inspection report, lot sample counts).
- What acceptance tests will validate the delivered automotive-qualified SoC for your program (name specific pass thresholds such as thermal soak, electrical margin, and acceptable failure ppm)?
- How many pre-production silicon runs and engineering change iterations do you require and over what timeframe (quarters)?
- Identify the environmental temperature range and thermal derating targets we must validate (ambient °C, junction limits, and power cap points).
Evaluation Board with Multi-Sensor Interfaces
- Which sensor interfaces must the evaluation board expose (MIPI-CSI-2 lanes, Automotive Ethernet, CAN FD, FPD-Link, domain-specific connectors)?
- Specify the camera resolutions and frame rates you will test on the board (for example 4× 2MP @30fps, 6× 1080p @60fps, 3× 4K @30fps).
- Are you validating lidar and radar using raw point-cloud and FMCW/raw radar IQ feeds on the evaluation board?
- Provide the end-to-end target latency budget from sensor capture to algorithm input that the evaluation platform must demonstrate (milliseconds).
- Which vehicle power input profiles and harness connector types must the board support during integration testing (for example 12 V ignition-controlled, 48 V architecture)?
- Select required debug and trace features for the evaluation board (for example JTAG, Ethernet remote debug, CAN bus tap, UART).
Board Support Package and RTOS Integration
- Identify the RTOS or AUTOSAR configuration you will use on target (AUTOSAR Classic, AUTOSAR Adaptive, specific third-party RTOS or custom).
- What Board Support Package deliverables are required: kernel patches, device drivers, bootloader sequences, or board initialization scripts?
- Provide the kernel version or BSP branch tag that must be maintained for vehicle compliance and traceability.
- Which fault management hooks, watchdog configurations, and safe-state transitions must be integrated to meet ASIL-B/D targets?
- How should we validate boot time and time-to-first-inference on your reference hardware (target in milliseconds)?
- Are secure boot, signed firmware, and cryptographic module requirements tied to your OEM cybersecurity standard that we must implement?
SDK with Sensor and Inference APIs
- Which sensor abstraction APIs must the SDK provide to match your middleware stack (camera timestamping, IMU synchronization, radar metadata schemas)?
- List the inference APIs and model formats you need supported out of the box (for example ONNX, TensorFlow SavedModel, vendor runtime package).
- What sample applications or reference pipelines do you want included with the SDK (for example single-camera detection, multi-sensor fusion pipeline, planning integration demo)?
- How should backward compatibility for SDK updates be handled across vehicle software updates and production branches?
- Estimate the maximum concurrent inference sessions the SDK must support and the typical thread/core counts for your use cases.
- Are there licensing constraints, export control or cryptography restrictions for SDK components we must follow?
Neural Network Compiler and Runtime Package
- Which model topologies will you benchmark on the compiler (for example ResNet50, MobileNet, PointPillars, CenterPoint)?
- Specify the target numeric precisions and quantization strategies you will accept for each model class (for example FP16, INT8, mixed precision).
- What throughput targets in inferences-per-second or TOPS are required for each model or pipeline under evaluation?
- How must the runtime handle dynamic batching, priority scheduling and real-time priority for the planning thread?
- Are there runtime flash or RAM footprint limits for model runtime components (specify MB limits)?
- Provide your expected model update cadence and maximum OTA package size constraints for runtime-delivered models.
On-target Model Compilation and Quantization
- For each safety-critical model, specify the maximum allowable top-1 accuracy drop after quantization (percentage points) and the maximum latency increase (milliseconds) that still constitutes acceptance.
- Which representative datasets and validation scripts should be used for on-target accuracy validation (dataset names and validation splits)?
- How many model variants must be compiled on-target and what are their input shapes and frame-rate targets?
- Do you require quantization-aware training, post-training calibration, or both to meet on-target accuracy objectives?
- Specify numerical calibration tolerances and per-layer precision constraints you will accept (for example max per-layer drift in activations).
- Who will own label correction and validation for any on-target accuracy regressions discovered during compilation and quantization tests?
Sensor Fusion Middleware Stack Delivery
- Which fusion architecture do you plan to validate in scope (late object-level fusion, early raw-data fusion, Kalman-based tracker, other)?
- List the sensor time-sync strategy and tolerances you require (for example PTP IEEE1588 target microsecond accuracy or camera timestamp tolerance).
- Provide the object-level interface schema required for fusion output including fields, units and coordinate frames (for example bounding box, class, velocity, frame_id).
- What tracking latency budget must fusion meet for the decision-making path (milliseconds)?
- Are deterministic memory allocation and bounded execution times required for ASIL-D fusion components?
- Specify calibration file formats and update mechanisms for extrinsic/intrinsic calibration (for example YAML extrinsics, JSON, binary blob).
Computer Vision Engine Reference Implementations
- Which perception demos should be delivered as reference implementations (for example object detection, semantic segmentation, depth estimation, tracking)?
- Specify source datasets and scenario coverage you want used for reference testing (for example urban day, urban night, highway, rain/fog).
- Provide frame-rate and latency targets for each demo on the target evaluation board (for example 30 fps @ <50 ms end-to-end).
- Are you expecting reference code with permissive licensing that can be reused in production, or reference-only examples?
- List required sensor modalities per demo (for example mono camera, stereo, lidar, radar).
- What level of documentation and step-by-step reproduction guides are required for your integration team (for example quickstart, full integration guide, API reference)?
ASIL-B and ASIL-D Safety Subsystem Delivery
- Identify which software components must be delivered with ASIL-B or ASIL-D evidence and the exact scope for each named component.
- What safety artifacts do you require with delivery (for example FMEDA, safety plan, hazard analysis and risk assessment HARA, traceability matrix)?
- Provide the target safety goals and failure rate thresholds you will enforce (for example PFH, SFF, target ASIL numeric limits).
- Which tool qualification reports, unit test traces and integration test artifacts must accompany code for ISO 26262 audits?
- Are independent safety audits or third-party certification reports required prior to OEM submission?
- Who is your accountable safety signer and which specific sign-off document do you require for delivered safety artifacts?
Deterministic Real-Time Scheduling Engine
- Which closed-loop real-time deadline must the scheduler guarantee for planning and control (for example 10 ms control loop)?
- Specify priority inversion protections, lock-free data path requirements and real-time IPC semantics required for perception-to-planning handoff.
- Provide maximum allowed jitter and worst-case execution time (WCET) budgets in milliseconds for critical tasks that the scheduler must respect.
- Are CPU core isolation and preemption policies required according to AUTOSAR or your internal scheduling guideline?
- How should schedulability proofs, WCET traces and latency histograms be delivered for OEM determinism audits?
- List the telemetry channels and determinism evidence you require to be collected during validation (for example hardware timers, trace buffers, RTOS logs).
-
Mutual Commit
Finalize commercial and supply commitments, contract modules, program milestones, and OEM approval dependencies.
Agreement Modules
- Master Purchase Agreement
- Initial Order Confirmation
- Long-Term Supply & Forecasting Agreement
- Program Milestones & Delivery Schedule (Annex)
- OEM Approval & Vehicle Qualification Dependencies
- Pricing & Payment Schedule
- Acceptance Test & Qualification Protocol
- Warranty, Support & Product Lifecycle Commitment
- Non-Recurring Engineering (NRE) & Customization Agreement
- Automotive Safety & Quality Addendum
-
Deployment
Lock readiness facts and configuration values, execute integrations, and validate production safety acceptance.
-
Pre-Deployment Readiness
Capture integration owners, test environments, data access, and production timeline constraints the deployment depends on.
Pre-Deployment Questions
Environment and site access
- List each environment the deployment will touch (production, staging, validation lab, OTA test lane). Provide the environment common name — one per line. (We use these names to map test cases to environments.)
- For the environments listed above, indicate current accessibility from the seller's integration infrastructure.
- Who is the environment/network owner responsible for granting access (role and contact email)? (Used to request credentials, firewall exceptions, and lab reservations.)
Data and configuration
- Which production data feeds must be available for deployment? Select all that apply.
- Are legal/data transfer/privacy approvals in place for the feeds you selected? (so we can schedule data ingestion and validation)
- Is the canonical source of configuration and mapping (sensor-to-interface mapping, bus IDs, signal mappings) finalized? If not, who owns finalizing it? (role and contact)
People and ownership
- Provide the named owner (role and email) for each deployment workstream: integration, firmware/toolchain, system validation, and OEM approvals — enter as 'workstream: role, name, email' per line.
- Will the buyer provide on-site engineers during the initial integration and first week of deployment?
- Are there authorized approvers who can sign test reports and production acceptance certificates? Provide role(s) and escalation contact.
Timing and constraints
- What is the target production cutover date? (use YYYY-MM-DD). (We use this to schedule gating milestones and resource allocation.)
- Are there blackout windows, vehicle testing freezes, or regulatory gates during the proposed rollout window that would block deployment?
- Are there known supply, component, or qualification timing constraints that could delay the cutover (e.g., multi-chip module availability, AEC/Q or ASIL qualification milestones)?
-
Configuration Details
Lock exact configuration values the integration team will use — build variants, firmware versions, toolchain settings, and interface mappings.
Configuration Details
Configuration Snapshot — lock the exact identifiers your integration build will read
- Target deployment environment label (enter the exact environment name your build will consume). Default: production.
- SoC build variant to lock (select one; if you select 'Custom', you will provide the exact identifier below).
Build & Toolchain — exact artifacts and releases
- If you selected 'Custom' build variant, enter the exact build variant identifier to lock (format: <variant-name>-<build-id>; leave blank if not applicable).
- Firmware image version tag to lock (format: vMAJOR.MINOR.PATCH — Default: v1.0.0). Enter the exact tag the integration build will fetch.
- Toolchain release to use for model compilation and packaging (select one).
- If you selected 'Custom' toolchain, enter the exact toolchain identifier or artifact name the build will consume (leave blank if not applicable).
Interfaces & Mappings — the build's I/O mappings and artifacts
- Primary vehicle sensor interface to map (select one — choose the category your vehicle uses).
- Interface mapping artifact path or artifact ID the build will consume (format example: configs/mapping_v2.json or artifact:mapping-1234). Enter exact path or artifact ID.
Operational Constraints & Release — thresholds the integration will enforce
- Safety target ASIL level to lock for this integration (select one — default is ASIL-D).
- Sustained power budget to enforce during integration (numeric, watts) — Default: 30. Enter numeric value only.
- Minimum sustained neural inference throughput to accept (numeric, TOPS) — Default: 100.0. Enter numeric value only.
- Latency budget for the safety-critical inference path to enforce (numeric, milliseconds) — Default: 20. Enter numeric value only.
- Firmware update channel to use for integration testing (select one).
-
Integration & Production Deployment
Execute integration, validation, and production-enablement tasks with clear owners, sequencing, and verification checkpoints.
-
Production Readiness Validation
Verify safety validations, performance targets, and OEM sign-off criteria are met before declaring the program production-ready.
Checklist items
- Receive signed safety case acceptance from the buyer's functional safety engineer
- Obtain OEM production acceptance sign-off
- Deliver final vehicle-level validation report demonstrating performance targets
- Receive signed production release of software and firmware (versioned) with SBOM and toolchain artifacts
- Complete first-article / pilot-run test and obtain signed first-article inspection (FAI) report
- Receive environmental and reliability qualification report sign-off
- Obtain executed production supply and lifecycle support agreement
- Lock production configuration with signed change control
- Establish and document rollback and emergency patch procedure with verification
- Complete vehicle energization and on-vehicle safety gate (including LOTO) with sign-off
-
-
Success
Track program outcomes, supply and lifecycle commitments, and maintain a shared channel for issues, firmware updates, and enhancements.
Success Reviews
- Go-live health check
- First measurement review
- Acceptance gate decision
- Monthly operational review
- Firmware and enhancements sync
- Quarterly supply and lifecycle review
Issues & Enhancements
- Publish the monthly operational dashboard with annotated variance explanations and next-step owners.
- Schedule targeted triage sessions for tickets blocking production or safety validations.
- Review recent release outcomes
- Publish the quarterly supply performance report with variance analysis against Mutual Commit targets.
- Agree the validation and rollback plan for the next release window.
- Confirm the release met its OTA success and fleet uptake targets or document corrective release steps.
- Confirm telemetry and integration endpoints are delivering reproducible data and that owners for each acceptance criterion recorded in Solution Scope are named.
- Document all critical blockers with remediation actions and target dates for stabilization.
- Verify the incumbent system is either decommissioned or formally retained-read-only with the archival status recorded.
- Deliver the week-1 telemetry dump and error log bundle to the shared channel for diagnostics.
- Execute the approved hotfix or configuration rollback for any critical blocker within the agreed stabilization window.
- Confirm and publish the incumbent decommission checklist and archival proof to the shared workspace.
- Present measured inference throughput
- Reconfirm acceptance criteria owners
- Establish a risk mitigation plan with clear trigger conditions and action owners for the next quarter.
- Agree lifecycle support activities and any contract amendments required to preserve OEM approval dependencies.
- Validate that supply on-time delivery and production coverage meet Mutual Commit targets or define remedial procurement actions.
- Establish whether inference throughput and 99th percentile latency are tracking to the Solution Scope targets or require remediation.
- Document a clear remediation plan with completion dates that enables the program to reach the acceptance gate.
- Verify telemetry and benchmark methodology are validated and repeatable for acceptance evidence.
- Run targeted benchmarks with the updated runtime configuration and publish results to the shared folder.
- Deliver a firmware/runtime patch addressing the identified bottleneck and schedule a validation window.
- Populate the acceptance-readiness tracker with evidence links and estimated completion dates for each remediation item.
- Restate acceptance criteria and numeric targets
- Schedule follow-up for any lifecycle commitment changes that require OEM re-approval or documentation updates.
- Supply performance vs Mutual Commit
- Update the enhancement backlog priority list for the next release cycle.
- Open engineering tasks for any rollbacks or hotfixes and set target delivery dates.
- Produce a documented acceptance decision that references the Solution Scope targets and linked evidence.
- Assign remediation tasks and timelines for any failed criteria to reach an agreed re-evaluation date.
- Archive the signed acceptance record and evidence to the program workspace for auditability.
- Publish the formal acceptance decision document with links to measurement artifacts and signatory details.
- Open remediation workstreams for any failed criteria with sprint goals and completion dates.
- Schedule the follow-up validation window and define pass criteria for the re-evaluation.
- Update the supply forecast and confirm any needed escalation to procurement channels.
- Field telemetry dashboard review
- Initiate procurement escalations or alternate-source qualification when coverage falls below committed thresholds.
- Publish the release validation report including OTA success rate and fleet uptake percentages.
- Assign owners and timelines for any critical post-release remediation actions.
- Confirm OTA success rate and MTTR are within tolerance or have an agreed mitigation plan.
- Identify any supply shortfalls versus Mutual Commit targets and agree mitigation or contingency steps.
- Ensure critical tickets have resolution owners and target resolution dates documented in the shared tracker.
- Production unit health and field failure trends
- Deployment and integration verification
- Present 99th percentile safety-path latency
- Present evidence against each criterion
- Production defects and safety incident review
- Field rollback and anomaly review
- Telemetry sanity and early signals
- Prioritized enhancement backlog and risk assessment
- Supply and fulfillment checkpoint
- Document pass or fail per criterion
- Lifecycle and long‑term support commitments
- Power and thermal margin review
- Capture formal acceptance decision and signatory
- Risk register and mitigation roadmap
- Root-cause diagnosis for any gaps
- Open ticket triage and escalation
- Agree next release content and validation plan
- Incumbent system wind-down check