Sales Engineering Fundamentals Questions
The presales function in a technical sale and how it partners with sales to win. Covers the presales engineering role (responsibilities across sales stages, technical depth versus commercial awareness), working with an account executive (coaching on technical credibility, joint customer calls and live-meeting coordination, holding the line when asked to promise unbuilt features, custom work or aggressive dates, aligning sales, product and engineering on commitments and roadmap gaps), writing technical proposals and RFP/RFI responses (structure, scope and assumptions, estimates and resource plans, delivery risks, acceptance criteria, SLA language, change control, executive summaries, using the clarification window, SOW, pilot agreements and contract appendices), handoff from presales to delivery, and running the presales function (CRM hygiene, presales metrics such as demo-to-win, win/loss analysis, prioritising scarce SE capacity, feeding field feedback to product, SE onboarding, demo quality programs, partner enablement). Hands-on discovery, POC and demo execution, price negotiation and buyer objection handling are covered elsewhere; this topic owns the role and the proposal and handoff craft around them.
While drafting a proposal you realise it rests on several unstated assumptions about the customer's environment. How do you surface them, and how do you write them into the proposal so they cannot turn into a dispute later?
Sample Answer
Direct answer
I treat unstated assumptions as unpriced risks. I surface them by walking the delivery path from the customer's side (access, network, data, people, environment, timeline) and by asking the customer to confirm each in writing; I then record every one in an assumptions register where each item has an owner, a confirm-by date, and a stated consequence if false. In the proposal they become numbered clauses linked to the acceptance criteria (the written tests that decide whether delivered work is accepted) and to the change-control process (the agreed way to request, price and approve a change to scope), so an assumption proving untrue triggers a priced change, not an argument.
How I surface them
- Walk the delivery path: ask at each step what must be true for the work to proceed (can we reach the customer's API; is there a test environment; who approves; how much network bandwidth).
- Pre-mortem (an exercise where the team imagines the project has failed and lists why): ten minutes with the delivery team yields most hidden dependencies.
- Customer validation call: read the list back and have the customer's technical owner confirm or correct each.
- Review past projects: the three most common causes of past overruns become standing assumptions.
How I write them so they cannot become a dispute
| ID | Assumption | Owner who confirms | Confirm by | If false | Linked criterion |
|---|---|---|---|---|---|
| A-01 | We have read access to the customer's API with a rate of at least 50 requests per second (derived by asking the customer's engineers for their peak load, say 10 requests per second, and multiplying by 5 for headroom: 10 x 5 = 50) | Customer IT | Week 1 | Integration effort rises; change request | Acceptance test 3 |
| A-02 | Network capacity of 1 Gbps (derived from the data volume to move divided by the allowed migration window: for example 4.5 terabytes in a 10-hour window is 450 gigabytes per hour, which is 1 gigabit per second at full line rate, so the assumption is a link that sustains at least that and is not shared) between the data centre and the cloud region | Customer network team | Week 2 | Migration window extends | Migration milestone |
| A-03 | Single-region deployment is acceptable | Customer security | Before contract | Redesign for multi-region, priced separately | Architecture sign-off |
| The contract language: "The estimate and timeline assume the conditions in Schedule B (the contract attachment that lists the assumptions). If an assumption is found untrue, either party may raise a change request, and the parties will agree revised price and dates before affected work continues." Each assumption is traceable: it appears in the register, in the proposal, in the acceptance criteria and in the contract schedule, with the same ID. |
Scenario: a 48-hour RFP where the pitch already promised unbuilt features
Setup: an RFP (request for proposal, the buyer's formal written questionnaire) is due in 48 hours, and in an earlier pitch the sales lead told the customer that real-time analytics and a mobile app were included, but neither exists yet. I cannot undo the promise, but I can keep the proposal honest and competitive:
- Sort each promised feature: available now, available through configuration, on the roadmap with a date, or not offered.
- Write a phased delivery plan: what ships in phase one with the standard product, and what follows with dates.
- Attach acceptance criteria to phase one, and roadmap items only as non-binding intent unless engineering signs a date.
- Give an effort and risk estimate for each unbuilt item, as a range.
- Tell the sales lead before submission which promises I have reworded and why.
Example rewrite. Pitch promise: "Real-time analytics dashboards are included." Honest sentence: "Phase one includes the standard daily-refresh dashboards. Real-time dashboards are on our roadmap for Q4 and are not part of the phase one price or acceptance criteria; we will confirm a delivery date once engineering has signed one."
A response that is slightly less impressive but true is more competitive than one that wins and fails delivery.
Trade-offs and pitfalls
- Too many assumptions look like hedging: keep to those that change cost or timeline materially.
- An assumption with no owner and no date is a wish.
- What would change my approach: a fixed-price contract (the vendor bears the cost of overruns) needs tighter assumptions than time-and-materials (the customer pays for the hours actually used).
Write the acceptance criteria for a data-integration proposal so that both sides know when the work is done, and explain why you chose them.
Sample Answer
Direct answer
Acceptance criteria are the written, testable conditions that, once met, oblige the customer to sign off and the vendor to stop and invoice. I write each one so that a person who was not in the sales cycle can run a check and say pass or fail, and I attach the evidence that will be shown. Vague phrases like "data syncs reliably" are the usual source of disputes, so every criterion needs a number, a method and an owner.
Acceptance template (one page)
Each criterion states what is measured, the threshold, the test method and the evidence filed; the customer's named approver and the test dates are set once for the whole milestone rather than per row. The one-page header looks like this (illustrative):
Milestone: Nightly sync live
Customer approver: Head of Data (named person)
Entry condition: vendor's written "ready for acceptance testing", environment frozen
Test window: 7 consecutive nights, dates agreed in advance
Sign-off: within 5 business days of the last test night
The table below then fills in one row per criterion.
Worked example: nightly data-sync milestone
Scenario (illustrative): the project copies customer orders from the customer's on-premises Oracle database into a cloud data warehouse every night. The milestone is "Nightly sync live".
| # | Criterion | Threshold | Test method | Evidence filed |
|---|---|---|---|---|
| 1 | Completeness | Row count in target equals source for all 28 in-scope tables, 0 missing rows | Reconciliation script comparing counts per table after each run | Reconciliation report, 7 consecutive nights |
| 2 | Accuracy | Sum of order_total per day matches source to the cent; column checksums match on a 1% random sample | Control-total query (a query that adds up a money column in source and target so the two totals can be compared) plus sampled checksum (a short fingerprint calculated from a column's values; equal fingerprints mean equal data) | Query output with run ID |
| 3 | Timeliness | Each nightly run finishes inside the agreed 4 hour window | Scheduler logs | Run log for 7 consecutive nights |
| 4 | Volume headroom | A run at 1.2 times the current nightly volume (2.4 million rows when today is 2.0 million, illustrative) still finishes in the window | Load test in the pre-production environment | Test log with row counts and duration |
| 5 | Failure recovery | After a deliberately killed run, the next run resumes with no duplicates and no gaps | Fault-injection test (deliberately breaking something, here killing a run, to prove recovery works) witnessed by both sides | Before/after row counts |
| 6 | Operability | Failed runs raise an alert to the named customer on-call group within 15 minutes; runbook delivered | Trigger a test alert; walk the runbook | Alert screenshot, runbook version |
The seven consecutive nights in rows 1 to 3 are deliberate: one good night proves little, and a week covers the weekend and a month-end batch if the dates are chosen well.
How acceptance is verified and documented before sign-off
- Entry condition: the vendor declares the milestone "ready for acceptance testing" in writing, with the test environment frozen.
- Test types: automated reconciliation (completeness, accuracy), performance test (timeliness, headroom), fault-injection test (recovery), and a short user acceptance test (UAT: the customer's own staff try the result with real tasks) where the customer's analysts run their own agreed queries against the new data.
- Evidence: every test produces a dated artifact (report, log or screenshot) stored in a shared folder both sides can open. The acceptance certificate lists the criteria numbers and links to each artifact. In its simplest form (illustrative): "Milestone Nightly sync live. Criteria 1 to 6: PASS. Evidence: links to reconciliation reports for nights 1-7, load test log, fault-injection before/after counts. Signed: [named approver], [date]. Vendor may now invoice milestone 2."
- Sign-off rule: the named customer approver has 5 business days to accept or send a written list of failed criteria. Only a failed criterion in the signed list can block acceptance; new requests go through change control (a written process to price and approve anything outside the signed list). Without a response, acceptance is deemed given (treated as accepted automatically) only if the contract says so, so the proposal must state this clearly.
- Defects: classify them (blocks acceptance, or fix within 30 days) in advance so a cosmetic issue cannot hold up the milestone.
Why these choices
- Measurable and observable: both sides can reproduce the check with no opinion involved.
- Bounded: every threshold has an upper limit (4 hours, 5 days), so the customer cannot move the goalposts and the vendor cannot declare victory on a soft target.
- Tied to risk: the criteria cover the ways a sync fails in practice (missing rows, wrong money totals, overruns, bad restarts, silent failure).
- Evidence-first: a signed certificate that links to artifacts survives staff changes on both sides.
Trade-offs and pitfalls
- Too many criteria slows sign-off; keep to the handful that map to business risk (here 6).
- Criteria that depend on things the vendor does not control (customer source data quality, network) need an explicit assumption in the proposal, for example "source data is clean as of the agreed snapshot date".
- Do not copy an SLA (service-level agreement) number into acceptance without checking whether it is a launch test or an ongoing target.
- Where a threshold is uncertain, define it as "baseline measured in week 1, then agreed", not as a guess.
You own the technical section of a formal RFP response. What goes into it, and how do you decide how much detail each part gets?
Sample Answer
Direct answer
The technical section of a request for proposal (RFP, a formal buyer document that vendors answer in writing, usually scored against a rubric; this section is written by the pre-sales team, the technical people who support the sale before signature) answers three things: can you meet each stated requirement, how will it work, and how will you deliver it with acceptable risk. I decide detail by one rule: depth follows scoring weight, risk, and where we genuinely differ from competitors, not where the content is easiest to write. Mandatory requirements get a precise yes, no or partly, with the evidence; the high-weight differentiators get the most space; boilerplate gets a short reference to an appendix.
What goes in (ten sections)
- Compliance matrix (the table that answers every numbered requirement; this is the centre of the response and the first thing evaluators score): every requirement answered (meets, meets with configuration, roadmap, does not meet), each with a one-line explanation and a reference. Example rows: "R-12 Single sign-on: Meets. Standard SAML support, see Security Guide section 4." "R-31 Data kept in the EU: Meets with configuration. Needs the EU region selected at setup; no extra cost." "R-47 Offline mode: Roadmap. Planned for Q4, not a commitment; interim: scheduled exports." "R-58 On-premises hosting: Does not meet. Cloud-only; we propose the dedicated regional instance instead."
If time is short, the must-haves are the compliance matrix, the architecture section with the context diagram, and the security section; the rest are scaled by the rule below. - Solution overview and architecture, with the context diagram.
- Security, privacy and compliance controls.
- Integration and data migration.
- Deployment model and hosting (cloud, on-premises or hybrid, meaning part on the customer's own servers and part in the cloud).
- Performance, scalability and availability (the non-functional requirements: qualities such as speed and uptime rather than features).
- Implementation approach, plan and milestones.
- Support, service levels (SLA, the contractual uptime and response-time promises) and operations.
- Assumptions, dependencies and exclusions.
- Team, experience and references.
Supporting artifacts and diagram types
If I could keep only two, I would keep the context diagram (so the evaluator sees the whole picture) and the data flow diagram (so the security reviewer sees where data goes). The others are supporting.
| Artifact | What it shows |
|---|---|
| Context diagram | The product and the customer's systems around it |
| Logical architecture | Components and responsibilities |
| Deployment or network diagram | Where things run, trust boundaries (the lines where data passes between zones of different trust, such as the internet and an internal network), regions |
| Data flow diagram | How data moves, where it is stored and encrypted |
| Sequence diagram | One critical integration step by step, as messages between systems in time order |
| Security control mapping | A table pairing each security requirement with the control we operate and proof of it |
| Implementation plan | Phases, owners, milestones |
How I decide how much detail each part gets
Score each section on three questions: how many evaluation points does it carry, how much risk does it hold for the customer, and is it something we do uniquely well? High on two or more: long and specific, with a diagram. High on one: moderate. None: a paragraph and an appendix reference. Example (illustrative): if scoring gives security 30 percent and integration 25 percent, those two sections together are over half the score and deserve over half the effort.
Scenario: regulated multinational bank
Compliance, regional latency and a cost-neutral migration pull against each other, and I say so in the response:
- Keeping data inside each regulatory region satisfies compliance but adds latency for reports that span regions. I name the option chosen (regional data stores with an aggregated, anonymised reporting layer) and its cost.
- "Cost-neutral migration" means run costs (what the bank pays each month to operate the service) after migration at or below current, not that migration is free. I state what is included, what the bank must fund, and the assumptions behind the claim.
- I give the trade-off table, my recommendation, and what changes it. Evaluators trust a response that shows its trade-offs.
Hybrid on-premises and cloud pre-sales: communication plan (short)
One named technical contact per side, a weekly architecture sync, a shared decision log, and a written answer to every clarification question within two business days.
Artifact set for a named enterprise evaluation
Architecture pack, security whitepaper (a document describing in detail how the product protects data) and control mapping, reference architecture for their scale, sample project plan, a scripted demo environment, and references from similar customers.
An honest paragraph from a junior author
When the team is newer than a competitor, say so and show strengths:
"Our delivery team for this engagement has three engineers who have each run two migrations of this type, supported by a senior architect from the product team who is available through the design phase. We have not yet delivered a deployment at your scale in a single phase, so we propose a pilot at the first site, with scale-up gated on measured results."
Assumptions and dependencies are written as conditions the customer controls ("assumes read-only access to the source system by week 2"), never as delivery guarantees we cannot control.
Trade-offs and pitfalls
- Answering "yes" to every row of the matrix wins a score and loses a contract later.
- Copy-pasted text from past responses leaks other customers' names and stale claims.
- What would change my allocation: an evaluation rubric that weights price or references more than technical depth.
A customer asks for a 99.995% availability SLA with financial penalties. How do you decide whether you can sign it, and how much downtime per year does that target actually allow?
Sample Answer
Direct answer
99.995% allows 26.28 minutes of downtime per year (about 2.16 minutes in a 30-day month). I would sign only if three things hold: our measured last-twelve-months availability already meets it, the architecture has no single point of failure (one component whose failure takes the whole service down) and no component whose own availability is below the target, and the penalty exposure is capped at a level the business accepts. If any fails, I counter-propose rather than sign.
The downtime arithmetic
A year has 365 x 24 x 60 = 525,600 minutes. Allowed downtime = 525,600 x (1 - availability).
MIN_PER_YEAR = 365 * 24 * 60 # 525,600 minutes
for target in (99.9, 99.99, 99.995, 99.999):
down = MIN_PER_YEAR * (1 - target/100)
month = 30*24*60 * (1 - target/100)
print(f"{target}%: {down:7.2f} min/year, {month:5.2f} min per 30-day month")
# series availability multiplies
chain = [0.9999, 0.9999, 0.9995] # load balancer, app tier, database
a = 1.0
for x in chain: a *= x
print(f"chain: {a*100:.3f}% -> {MIN_PER_YEAR*(1-a):.1f} min/year")
99.9%: 525.60 min/year, 43.20 min per 30-day month
99.99%: 52.56 min/year, 4.32 min per 30-day month
99.995%: 26.28 min/year, 2.16 min per 30-day month
99.999%: 5.26 min/year, 0.43 min per 30-day month
chain: 99.930% -> 367.9 min/year
One 5-minute failover (the switch to a standby copy when the primary fails) consumes 5 / 26.28 = 19% of the annual budget. A single 30-minute incident breaches it.
Can the architecture meet it?
Components in series multiply. A load balancer and app tier at 99.99% each and a database at 99.95% give 99.930%, which is 367.9 minutes a year, about 14 times the 26.28-minute budget. Redundancy in independent failure domains (parts that cannot fail from the same cause, such as separate regions) is the only way up. Two independent copies each at 99.9% would give 1 - 0.001 x 0.001 = 99.9999% in theory: independent means one copy failing does not make the other more likely to fail, so the chance both are down at once is the product, 0.000001, but real deployments share a deploy pipeline, DNS, identity and configuration, so I would never quote the theoretical figure. Also check the providers underneath: a cloud region's own published SLA (service-level agreement, the provider's contractual availability promise) below 99.995% caps a single-region design.
Decision checklist
| Check | Evidence | Pass if |
|---|---|---|
| History | Incident minutes for the in-scope service, last 12 months | 26.28 minutes or fewer, with margin |
| Architecture | Failure-domain review, deploy and failover tests | No single point of failure; failover under 1 minute tested |
| Scope | Which endpoints, measured how, which exclusions | Defined, narrow, measurable |
| Exposure | Credit schedule and cap versus fees | Max loss acceptable to finance |
Reducing penalty exposure
- Scope it. Offer 99.995% on one named core path and a lower figure on the rest.
- Measure annually or quarterly instead of monthly: a monthly window leaves 2.16 minutes, so one 3-minute incident fails the month. A longer window smooths noise (the customer may resist).
- Credits, not penalties, as the sole remedy, with a cap. Illustrative: fee $50,000 a month ($600,000 a year), credits 10% for a small miss and capped at 25% of the monthly fee, so worst-case exposure is 25% x $50,000 = $12,500 a month or $150,000 a year, 25% of annual fees.
- Exclusions: planned maintenance, customer-caused faults, upstream outages outside our control, force majeure (events beyond anyone's control, such as a natural disaster).
- Price it: engineering for this level (multi-region, automated failover, on-call) costs real money; the premium should cover it.
My call
If history shows more than 26.28 minutes of incident time, or the design is single-region, I do not sign 99.995%. I counter with 99.99% (52.56 minutes a year) on the core path, backed by credits and a cap, and propose a roadmap commitment to reach 99.995% after the architecture work, because a penalty clause you expect to pay is a discount in disguise: if we expect to miss slightly every month, a 10% credit costs 10% x $50,000 = $5,000 a month, $60,000 a year, which is the same as granting a 10% discount.
A customer wants to start with a 10-user pilot and reach 10,000 users within 18 months. How do you lay out the implementation roadmap in the proposal, and what has to be true before each phase starts?
Sample Answer
Direct answer
I lay out the roadmap as gated phases where each phase grows the user base about tenfold (10, 100, 1,000, 10,000) and the next phase starts only when written entry criteria are met. Each phase has an objective, deliverables, entry criteria (conditions that must be true before the phase starts) and exit criteria (what must be demonstrated to proceed), and the proposal says who is accountable for each. Eighteen months is a target, not a promise; the gates are what the customer is actually buying.
The roadmap: four gated phases
| Phase | Months | Users | Objective | What must be true before it starts |
|---|---|---|---|---|
| 1. Pilot | 0 to 2 | 10 | Prove the core use case with a small champion group (a few enthusiastic, influential users who will give honest feedback) | Contract signed, success criteria (the measurable results that count as a pass) agreed, test environment ready, named business owner |
| 2. First wave | 3 to 6 | 100 | Prove it works across one department and its integrations | Pilot success criteria met; single sign-on (one login shared with the company's identity system) and key integration working; support process defined |
| 3. Second wave | 7 to 12 | 1,000 | Prove operations and support at scale | Load tested (run under simulated heavy use) at twice the expected peak of this phase; training and support staffed; data migration plan approved |
| 4. Full rollout | 13 to 18 | 10,000 | Complete rollout and handover to the customer's operations | Security review complete; capacity and cost confirmed for 10,000; change management plan (how users are told, trained and supported through the change) in place |
| The count is four phases; the 10 to 100 to 1,000 to 10,000 steps give three expansion gates after the pilot. |
What a gate looks like
Each exit criterion is a measurable fact, not a feeling: for example, "at least 8 of the 10 pilot users complete the target workflow weekly", "the system sustains the agreed response time at twice the expected peak users in a load test", "support tickets are resolved within the agreed time". If a criterion is missed, the proposal says the phase extends until it is met. Neither side pays a penalty (a contractual charge for delay) for that extension unless the delay was caused by that side's own failure: for example, the customer owes the vendor extra fees if it was slow to provide test data, and the vendor owes the customer a credit if its software missed the performance target. For scale: if the 8-of-10 pilot criterion is met by only 6 users after 2 months, the pilot might extend 4 weeks to fix the blocking issue, which moves every later phase back by 4 weeks and the 18-month target to about 19 months.
Commercial structure
Price the pilot as a paid, time-boxed engagement with its fee credited if the customer proceeds. Agree the per-user price at 10,000 up front (tiered: the price per user falls as user counts reach set levels) so growth does not trigger renegotiation. Tie later milestone payments to gate approval.
Applying the same method to a shorter, nine-month deployment
The question is about an 18-month roadmap, but the same phase, objective, deliverables and exit-criteria format applies to any length. As a contrast, a nine-month plan is about 38 weeks, split into five phases:
| Phase | Weeks | Objective | Key deliverables | Exit criteria |
|---|---|---|---|---|
| Discovery | 4 | Agree scope and design | Requirements, architecture, risk register | Signed scope and design |
| Proof of concept (POC, a short build to prove the key technical risk) | 6 | Prove the riskiest requirement | Working prototype, test results | Agreed success criteria met |
| Pilot | 8 | Real users, real data, limited scope | Configured environment, trained pilot group | Pilot acceptance sign-off |
| Rollout | 16 | Deploy to all users or sites in waves | Migrated data, trained users, runbooks | Each wave accepted; go-live approved |
| Hypercare (intensive support just after go-live) | 4 | Stabilise | Daily triage, defect fixes, handover to support | Defects below the agreed level; handover signed |
| 4 + 6 + 8 + 16 + 4 = 38 weeks. |
Trade-offs and pitfalls
- Gates add schedule risk but remove the bigger risk of rolling out something unproven.
- Each phase's entry criteria should include customer-side tasks, since delays usually come from there.
- What would change my plan: a hard business deadline (a contract expiry, a regulatory date) would compress phases and I would say which assurance I am giving up.
Unlock Full Question Bank
Get access to all 14 Sales Engineering Fundamentals interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.