ETRM & Trading Systems · Interview preparation

ETRM interview questions

5,470 questions. The ones that actually get asked.

Front Office, Middle Office and Back Office, organised by theme: trade capture and product modelling, curves and valuation, position and P&L, risk and limits, settlement, accounting, integration architecture and the scenario questions that separate an architect from an implementer.

5,470 questions · 15 groups · 275 sections

Get the ETRM Pro Bundle Browse the questions ETRM training
How to use this

Answer the why, not the what

Most of these questions have an obvious surface answer and a real one underneath. An interviewer asking how you model a physical and a financial trade is not testing whether you know the difference; they are testing whether you understand why one position model has to serve both. Prepare the reasoning, not the definition.

Every question below is free to read. If you want the underlying material rather than a list, the ETRM Pro Bundle is where it is taught.

The questions

5,470 questions across 15 groups

Front Office13 sections · 180 questions
1. Front Office and Trading Process10
  1. Explain the complete Front Office trade lifecycle from deal negotiation through trade capture, validation, position update and downstream processing.A trade begins with negotiation and execution, followed by capture in ETRM. ETRM validates economic terms, counterparty eligibility, limits and reference data. Once validated, it updates positions, exposure and P&L, then generates events for confirmation, scheduling, settlement, accounting and regulatory reporting.
  2. How does ETRM distinguish between a trade, transaction, instrument, leg, profile and cash flow?A trade is the overall commercial agreement, while a transaction is its system representation. The instrument defines product behaviour and valuation. Legs represent distinct payment or delivery components. Profiles distribute quantities or prices across periods, and cash flows represent the resulting financial payment obligations.
  3. How would you model physical and financial commodity trades within the same trading portfolio?I would use appropriate physical and financial instruments while aligning commodity, index, currency, unit, delivery period, location, portfolio and strategy dimensions. This enables consolidated exposure and P&L while preserving physical scheduling, nomination and settlement requirements that do not apply to financial derivatives.
  4. What information must be captured at trade entry to support accurate valuation, position and P&L?Required data includes instrument, buy or sell direction, quantity, unit, price formula, index, currency, delivery profile, pricing dates, payment terms, location, counterparty, portfolio and trader. Missing conversion factors, calendars, curves, fixings or settlement conventions can materially distort valuation, exposure and P&L.
  5. How do trade date, delivery date, pricing date, fixing date, settlement date and payment date differ?Trade date records execution. Delivery dates define when the commodity is supplied. Pricing dates specify the quotation period, while fixing dates determine when floating prices become known. Settlement date establishes the payable amount, and payment date identifies when cash is contractually transferred between counterparties.
  6. What are the respective responsibilities of traders, originators, schedulers, risk controllers and product control?Traders execute and manage market exposure. Originators develop structured commercial opportunities. Schedulers manage physical movements, nominations and actuals. Risk monitors limits and independent exposure measures. Product Control validates prices, explains P&L and supports valuation control. Clear segregation prevents traders from independently approving their results.
  7. How would you design Front Office workflows for high-volume versus structured transactions?High-volume trades require standard templates, automated ingestion, straight-through validation and exception-based processing. Structured trades need richer capture, specialist review, model approval and enhanced controls. Both should share governed reference data, auditability and downstream interfaces without forcing complex transactions through unsuitable standard workflows.
  8. What are the differences between exchange-traded, OTC-cleared and bilateral OTC transactions?Exchange-traded products use standard contracts and centralised execution and clearing. OTC-cleared trades are negotiated bilaterally but submitted to a clearing house. Bilateral OTC trades remain directly between counterparties, creating customised terms and greater counterparty, collateral, confirmation, valuation and settlement-management requirements.
  9. How do physical delivery obligations affect the Front Office trade model?Physical trades require delivery locations, quantity profiles, units, quality specifications, tolerances, transportation terms and operational dates. The model must connect commercial economics with nominations, scheduling and actual quantities. Operational changes may alter exposure, valuation, inventory, settlement and imbalance charges throughout the trade lifecycle.
  10. What controls should prevent incomplete or economically incorrect trades from reaching downstream systems?Controls should validate mandatory fields, product eligibility, trader mandates, counterparty status, credit availability, price reasonableness, units, currencies, calendars, delivery profiles and settlement instructions. Material exceptions should block validation; lower-risk exceptions may generate warnings, approvals or workflow tasks supported by a complete audit trail.
2. ETRM Trade Capture Architecture15
  1. Explain ETRM's instrument-builder architecture.ETRM's instrument architecture defines how a transaction captures economic terms, generates payment or delivery events, obtains market data and performs valuation. Standard instruments combine configurable parameters, profiles, formulas and event logic, allowing multiple products to be supported without creating separate custom code for every trade type.
  2. When should an existing instrument be configured instead of creating a custom instrument?Use an existing instrument when it can represent the contractual economics, cash flows, physical obligations and valuation correctly through supported configuration. Custom development is justified only when material requirements cannot be modelled reliably, because custom instruments increase testing, operational support, performance and upgrade risks.
  3. How do transaction and parameter structures influence valuation and reporting?The transaction stores contractual and organisational attributes, while parameters represent individual economic components such as fixed, floating or physical legs. Their profiles, indexes, dates and formulas drive cash-flow generation and valuation. Reporting depends on correctly aggregating these structures into positions, sensitivities, P&L and settlement events.
  4. Explain the purpose of deal templates and trade defaults.Deal templates prepopulate approved economic and operational attributes for recurring products. Defaults reduce manual entry, accelerate booking and promote consistent data. Templates should remain controlled by product, desk and legal entity, while users must verify transaction-specific terms rather than treating defaults as confirmed contractual information.
  5. How would you design trade templates for different desks, commodities and legal entities?I would establish reusable base templates by instrument and commodity, then apply controlled desk, portfolio, legal-entity, location and settlement defaults. The design should minimise duplication, restrict inappropriate products and maintain clear ownership, versioning, testing and approval for every template change introduced into production.
  6. How are portfolios, books, strategies and organisational units represented in ETRM?ETRM portfolios commonly represent controlled collections of transactions assigned to trading or operational responsibilities. Business units define organisational ownership, while strategies provide analytical classification. The exact hierarchy must support trader mandates, access control, risk aggregation, accounting treatment, reporting and organisational changes without duplicating transactions.
  7. How would you implement trader mandates and book-level product restrictions?I would combine user roles, personnel assignments, portfolio permissions, instrument eligibility, transaction limits and workflow validation. Controls should restrict who can view, enter, amend or validate trades and which products each book may hold. Exceptions require authorised approval and must remain visible in the audit trail.
  8. What is the difference between trade entry validation and workflow validation?Trade-entry validation checks field completeness, formats, reference data and basic economic consistency while the user captures a transaction. Workflow validation applies broader business controls before status progression, including credit, mandate, price reasonableness and approvals. Separating them supports usability without weakening governance.
  9. How would you introduce a new product without disrupting existing transactions?I would perform product analysis, reuse proven instruments, isolate configuration changes and test valuation, events, position, P&L, accounting and settlement. Regression testing would protect existing products. Deployment would use controlled migration, production-readiness approval, monitoring and a rollback plan covering configuration and custom components.
  10. What ETRM configuration objects would you assess before enabling a product for production?The assessment should cover instruments, transaction templates, portfolios, reference data, indexes, curves, calendars, units, currencies, settlement instructions, accounting rules, workflows, permissions, simulations, reports and interfaces. Every dependency must have an owner, test evidence, migration method, reconciliation control and production-support procedure.
  11. How would you manage amendments, cancellations, novations, terminations and partial unwinds?I would use supported lifecycle actions that preserve the original transaction's history and establish explicit relationships between affected deals. Each action must correctly reverse or transfer remaining economics, regenerate events, recalculate exposure and P&L, trigger confirmation and settlement changes, and retain authorised audit evidence.
  12. How do you preserve the economic and operational history of an amended trade?Trade changes should use controlled amendment workflows, transaction versions and audit logs rather than direct database updates. The system must retain previous economics, timestamps, user identity, approval and reason. Historical valuation should reproduce results using the trade version and market data valid at that time.
  13. How would you identify duplicate trades received from an external execution platform?I would enforce idempotency using a stable source-system identifier, execution identifier and version number. Additional matching could compare counterparty, product, direction, quantity, price and timestamp. Suspected duplicates should enter an exception queue instead of being silently rejected or creating additional ETRM transactions.
  14. What design decisions are required for block trades and trade allocations?The design must define whether the block or allocated child trades are authoritative, when allocation occurs, and how quantities, prices, fees and identifiers propagate. It must also address partial allocation, rounding, amendments, cancellations, confirmations, credit usage, position reporting, settlement and reconciliation with the execution venue.
  15. How would you model inter-book and intercompany transactions?Inter-book transfers should create balanced internal transactions that move exposure and P&L without creating external obligations. Intercompany trades require separate legal entities, agreements, transfer pricing, confirmations, accounting and settlement. Both designs need linked identifiers, symmetrical lifecycle processing and controls preventing unbalanced amendments or cancellations.
3. Commodity Product Modelling15
  1. How would you model a fixed-price physical crude-oil purchase?I would capture the crude grade, quantity, unit, fixed price, currency, delivery period, location, Incoterm, quality terms, tolerance and payment conditions. The transaction must generate physical delivery, scheduling and settlement events while exposing price, volume, location, currency and counterparty risks correctly.
  2. How would you represent a crude trade priced against monthly Brent plus a differential?I would model a floating-price physical trade referencing the appropriate Brent index, quotation period and averaging convention, then add the contractual differential. The configuration must include pricing-event dates, publication calendar, currency, unit conversions, provisional pricing and rules for unavailable or subsequently corrected index observations.
  3. How would you model provisional pricing followed by final invoice pricing?The transaction would initially calculate an invoice using an estimated or provisional index value. After all contractual fixings become available, ETRM would calculate the final price and generate an adjustment invoice. The design must preserve both calculations and prevent provisional amounts from being mistaken for final revenue.
  4. How would you represent pricing based on an average of multiple published index observations?I would configure a quotation-period price using the contractually specified observations, publication calendar and arithmetic or weighted-average method. The model must address excluded days, missing publications, pricing lags, corrections and rounding. Each fixing should remain traceable from the final price to its original market-data source.
  5. How would you model a pricing formula containing quotation periods, lags, premiums and FX conversion?I would decompose the formula into independently testable components: commodity index, quotation-period rules, publication lag, premium or discount, unit conversion and FX conversion. ETRM should evaluate these in contractual order, use governed market-data sources and retain enough detail to explain the resulting invoice price.
  6. How would you handle different units of measure between trading, delivery, risk and settlement?I would maintain a canonical quantity with governed conversions among commercial, physical, risk and invoicing units. Conversions may depend on density, calorific value, temperature or contractual factors. The original quantity and every conversion basis must remain visible, reproducible and consistently applied across valuation, scheduling and settlement.
  7. How do density, temperature and volume-conversion rules affect oil transactions?Oil volumes vary with temperature, while mass-to-volume conversion depends on density. ETRM must therefore apply contractual reference temperatures, density sources and conversion standards. Incorrect assumptions can create differences between traded quantity, delivered quantity, exposure and invoice quantity, producing unexplained position and settlement discrepancies.
  8. How would you model a natural-gas trade with daily delivery profiles?I would capture the delivery point, contract period, daily quantities, gas day, timezone, unit, price formula and nomination rules. The profile should support planned, nominated and actual volumes while valuation and position reporting aggregate daily exposure correctly across weekends, holidays and daylight-saving transitions.
  9. How would you represent take-or-pay, swing or tolerance provisions?I would separate base delivery obligations from contractual flexibility. Minimum, maximum, cumulative and daily constraints would govern permitted nominations, while shortfall, excess and make-up provisions generate appropriate valuation or settlement consequences. Material optionality requires a suitable valuation model rather than only operational validation rules.
  10. How would you model an LNG cargo containing multiple pricing components and delivery conditions?I would represent cargo quantity, loading and discharge windows, locations, boil-off assumptions, index-linked commodity pricing, slope, constant, FX, freight and operational costs. Components should remain separately explainable while supporting provisional pricing, quantity adjustments, diversions, delays and final settlement using actual delivered energy.
  11. How would you represent power trades with hourly, peak and off-peak delivery profiles?I would model delivery using timezone-aware hourly profiles and the market's official peak definitions, holiday calendar and settlement periods. Quantities and prices must map to each interval, enabling correct valuation and position aggregation while preserving distinctions among baseload, peak-load, off-peak and shaped products.
  12. How would you handle daylight-saving-time days containing 23 or 25 delivery hours?I would use the market's local timezone, official delivery calendar and uniquely identified settlement intervals. On clock-change days, the missing or repeated hour must be represented explicitly. Using simple hour numbers without timezone offsets can misstate volume, exposure, pricing, scheduling and settlement.
  13. How would you model renewable certificates or emissions allowances?I would capture certificate type, registry, jurisdiction, vintage, compliance period, quantity, delivery terms and price. The model must distinguish trading from surrender, retirement or cancellation and maintain registry identifiers where required. Position reporting should separate available, committed, delivered and retired environmental instruments.
  14. How would you represent freight as part of commodity economics?Freight can be captured as a separate charter transaction, a transportation component or a cost allocation linked to the commodity trade. The approach must support route, vessel, quantity, rate, demurrage, currency and timing while allowing landed-cost, exposure, P&L and settlement analysis.
  15. When should freight be embedded in the commodity trade, and when should it be captured separately?Embed freight when it is an inseparable pricing component and does not require independent lifecycle management. Capture it separately when the organisation contracts transportation independently, manages freight exposure, schedules vessels or settles freight-specific charges. Linked transactions can preserve combined cargo economics without obscuring operational ownership.
4. Market Data and Curves15
  1. Describe ETRM's market-data architecture from data acquisition through curve construction and valuation.ETRM receives prices, fixings, rates and reference data from approved sources. Data is validated and stored before curve-building processes transform market quotes into valuation curves. Pricing models consume those curves within controlled market-data scenarios to calculate valuations, sensitivities, positions and P&L.
  2. What is the difference between raw market data, reference data, derived data and a valuation curve?Raw market data includes vendor prices, rates and fixings. Reference data defines instruments, indexes, currencies, units and calendars. Derived data results from calculations or transformations. Valuation curves are constructed term structures used by pricing models to estimate future prices, discount cash flows and calculate risk.
  3. How would you design forward curves for crude oil, natural gas, LNG or power?I would define the curve's purpose, commodity, location, quality, currency, unit and granularity. Liquid market quotes would anchor observable periods, with governed interpolation and extrapolation elsewhere. The design must reflect seasonality, transport relationships, contract specifications, liquidity and independent validation requirements.
  4. How are spot prices, futures, swaps, forwards and seasonal instruments combined into a curve?Each instrument contributes information for specific points or periods along the curve. The construction process normalises units, currencies, locations and delivery periods, then resolves overlapping quotes using approved priorities. Bootstrapping and interpolation produce a continuous curve while retaining traceability to underlying market observations.
  5. Explain bootstrapping, interpolation and extrapolation.Bootstrapping derives successive curve points from quoted instruments. Interpolation estimates values between observable points using an approved mathematical method. Extrapolation estimates values beyond the liquid market horizon. Each introduces modelling assumptions that must reflect commodity behaviour and remain independently reviewed and documented.
  6. How would you determine the appropriate interpolation method for a particular commodity curve?I would evaluate instrument liquidity, delivery granularity, seasonality, storage economics and desired curve smoothness. Linear methods may suit simple products, while shaped commodities may require seasonality-aware approaches. Selection should be validated through back-testing, stability analysis and assessment of resulting valuation and sensitivity behaviour.
  7. What is the relationship between index definitions, reference sources, fixing data and forward curves?The index defines the contractual market reference and publication rules. The reference source supplies observations, while fixings store published historical values. Forward curves estimate unfixed future observations. Correct mapping ensures a floating trade transitions consistently from forecast valuation to realised contractual pricing as fixings become available.
  8. How would you handle multiple curve sets for trading, risk, accounting and independent price verification?I would create governed market-data scenarios for trading, risk, accounting and independent price verification, with explicit ownership and usage rules. Shared observable inputs should be reused where appropriate, while permitted adjustments remain transparent. Reports must identify the scenario and curve version behind every valuation.
  9. What is a market-data scenario, and how should scenarios be governed?A market-data scenario is a controlled collection of curves, prices, rates, fixings and modelling assumptions used for valuation. Scenarios support official close, intraday, stress and historical calculations. They require effective dates, versioning, approval, access controls and reproducibility to prevent inconsistent results across functions.
  10. How would you support intraday valuation without compromising official end-of-day results?I would maintain a clearly labelled intraday scenario refreshed from validated market feeds while preserving the official end-of-day scenario unchanged. Traders receive timely indicative P&L and exposure, whereas accounting and control processes use approved snapshots. Data timestamps and freshness indicators should remain visible.
  11. What happens to valuation when a required fixing is missing?The pricing formula cannot complete the contractual calculation reliably. ETRM may use an approved estimate or fallback for provisional valuation, but the missing fixing should generate an exception. The result must remain distinguishable from a final price and be recalculated when the observation becomes available.
  12. How would you design fallback rules without hiding market-data-quality problems?Fallbacks should follow contractual or governance-approved hierarchies, such as alternate sources, prior observations or authorised estimates. Every substitution must be flagged, time-limited and auditable. Controls should escalate material missing data and prevent fallback values from silently becoming official or permanent market observations.
  13. How would you investigate a large valuation change caused by a curve update?I would compare current and previous curve versions, underlying quotes, construction logs and validation exceptions. Next, I would isolate changed tenors and revalue affected cash flows. Sensitivity analysis helps determine whether the movement reflects legitimate markets, erroneous inputs, altered configuration or model behaviour.
  14. How would you implement historical market-data corrections while preserving reproducibility?I would preserve the original official snapshot and introduce the correction as a separately versioned market-data set. Any rerun should state its purpose and use the corrected version explicitly. Results must distinguish originally reported values from restated values and retain approvals, reasons and reconciliation evidence.
  15. How do you prevent future-dated data from leaking into an historical as-of valuation?Every valuation should enforce an as-of timestamp across trades, fixings, curves, reference data and configuration. Only information available by that timestamp may be selected. Versioned snapshots, effective dating and automated controls should reject later observations, backfilled records or subsequently corrected data unless explicitly authorised.
5. Valuation and Pricing15
  1. Explain the ETRM valuation pipeline for a newly captured trade.ETRM validates the trade economics, resolves the instrument and pricing configuration, generates projected cash flows, retrieves market data and applies the valuation model. Simulations then calculate present value, P&L and sensitivities, storing or displaying results according to the selected scenario and reporting definition.
  2. How does ETRM determine which pricing model and market data to use?The instrument, parameters, deal attributes and valuation configuration determine the pricing model. Index definitions and market-data mappings identify required curves, fixings, FX rates and discount factors. The selected simulation scenario and valuation date determine which approved versions are applied to the calculation.
  3. What is the difference between trade price, market price, model price and settlement price?Trade price is the contractually agreed price. Market price represents the observable current market level. Model price is calculated using curves and valuation assumptions, particularly when no direct quote exists. Settlement price is the contractually or externally determined value used to calculate the final payable amount.
  4. Explain discounting and the construction of discounted cash flows.Projected contractual cash flows are calculated from quantities, prices, fixings and payment terms. Each future cash flow is multiplied by a discount factor derived from the relevant currency curve. Summing discounted cash flows produces present value, reflecting both expected economics and the time value of money.
  5. How would you validate the valuation of a commodity swap independently?I would reconstruct each settlement period using contractual quantities, fixed prices, forward-index values, payment dates and discount factors. The independent result would be compared with ETRM at cash-flow level. Differences would then be traced to curves, calendars, units, fixings, rounding or discounting conventions.
  6. How are fixings incorporated into partially priced transactions?Published observations replace forward estimates for completed pricing dates, while remaining observations continue using the forward curve. The valuation therefore combines known and forecast index values. Each fixing must follow the contractual calendar and averaging rule, with missing or corrected observations managed through controlled exceptions.
  7. What happens to exposure as a floating-price trade progressively fixes?As observations fix, the trade's price uncertainty and sensitivity to the forward curve decline. Forecast exposure converts into known settlement value, although currency, volume, discounting and counterparty risks may remain. P&L reflects differences between earlier forward assumptions and subsequently published contractual fixing values.
  8. How would you value a trade containing multiple currencies?I would project cash flows in their contractual currencies, discount them using the corresponding currency curves and translate the resulting present values into the reporting currency using appropriate FX rates. The valuation should separately expose commodity, interest-rate and FX sensitivities and respect contractual conversion dates.
  9. How do discount curves, FX curves and commodity curves interact?Commodity curves forecast floating commodity prices, FX curves or rates convert cash flows across currencies, and discount curves translate future payments into present value. Their interaction depends on pricing currency, payment currency, reporting currency and payment timing, requiring consistent valuation dates and market-data conventions.
  10. How would you approach the valuation of optionality embedded in a physical contract?I would identify the exercise rights, operational constraints, nomination windows, volume limits and economic penalties. Material optionality may require simulation, optimisation or option-pricing techniques using appropriate volatility and correlation assumptions. The model must reflect feasible physical operations, not merely theoretical financial exercise behaviour.
  11. What are the risks of approximating a structured deal with several standard instruments?A replication may simplify implementation but can misrepresent optionality, dependencies, lifecycle events, settlement terms or physical constraints. It may also create fragmented positions, misleading sensitivities and difficult amendments. The approximation is acceptable only when differences are quantified, immaterial, documented and independently approved.
  12. When would a custom pricing model be justified?A custom model is justified when supported standard models cannot materially reproduce the contract's economics, optionality or risk profile. The expected benefit must exceed development, validation, performance, support and upgrade costs. Customisation should not compensate for misunderstood requirements, poor configuration or unnecessary product complexity.
  13. What governance should surround a custom valuation model?Governance should include documented methodology, assumptions, limitations, data requirements, independent model validation, benchmark testing, approval and version control. Production implementation also requires performance testing, access controls, monitoring, change management, fallback procedures and periodic review against observed behaviour and evolving market conditions.
  14. How would you reconcile ETRM valuation with a trader spreadsheet?I would first align trade version, valuation date, market-data timestamp, curves, fixings, calendars, units and discounting conventions. Next, I would compare projected cash flows and valuation components individually. The spreadsheet is diagnostic evidence, not automatically authoritative, and its formulas must also be validated.
  15. How would you distinguish model error from market-data error, trade-data error and configuration error?I would reproduce the valuation with controlled inputs, then test one layer at a time: contractual fields, market-data observations, curve construction, instrument configuration and pricing logic. Cash-flow comparison and sensitivity analysis reveal where results diverge, allowing evidence-based classification instead of attributing every difference to the model.
6. Positions, Exposure and P&L15
  1. Explain the difference between contractual position, scheduled position, nominated position and actual position.Contractual position reflects legally agreed quantities. Scheduled position represents planned physical movements. Nominated position records quantities submitted to pipelines, grids or operators. Actual position uses measured delivery or consumption. Each state should remain separately traceable because operational changes can affect exposure, settlement and P&L.
  2. How would you calculate the position of a physical commodity desk?I would aggregate validated purchases, sales, inventory, transport commitments and eligible operational movements by commodity, location, delivery period and unit. The report should distinguish contractual, scheduled, nominated and actual quantities while converting them through governed factors and preventing duplication between trades and movements.
  3. What are the appropriate position measures for oil, gas, LNG and power?Oil requires mass or volume by grade, location and period. Gas requires volume and energy by gas day and hub. LNG needs tonnes, cubic metres and energy by cargo. Power requires MW and MWh by delivery interval, zone and peak classification.
  4. How should position aggregation handle different units of measure?Positions should retain original contractual quantities while converting them into approved reporting units through governed, effective-dated conversion rules. Context-dependent factors such as density, temperature or calorific value must remain explicit. Aggregation should stop or flag exceptions when a reliable conversion is unavailable.
  5. How do pricing exposure and physical delivery exposure differ?Pricing exposure measures sensitivity to unfixed market prices and determines how valuation changes when curves move. Physical delivery exposure represents the quantity that must be supplied, received, transported or stored. A fully fixed transaction may have no price exposure while retaining substantial delivery obligations.
  6. What happens to delta exposure as pricing observations become fixed?Each published fixing replaces a forecast curve observation, reducing the transaction's sensitivity to that market factor. Delta normally declines progressively until pricing is fully fixed. Residual exposure may remain from quantity uncertainty, currency conversion, discounting, basis differences or operational adjustments.
  7. How would you design trader position screens for prompt and forward exposure?I would provide prompt and forward positions by commodity, book, location, delivery period, index and unit, with drill-down to trades and profiles. Screens should separate physical, financial, fixed and floating exposure, display data freshness and exceptions, and support approved aggregation without hiding basis risk.
  8. Explain realised, unrealised, settled and total P&L.Realised P&L arises when pricing or disposal economics become fixed. Unrealised P&L reflects changes in the value of open or unfixed positions. Settled P&L relates to completed cash settlements. Total economic P&L combines relevant realised and unrealised components without double counting settlement.
  9. Explain daily P&L attribution.Daily P&L attribution decomposes the movement from prior close to current valuation into identifiable drivers, including new trades, market movements, fixings, time passage, amendments, cancellations, FX and model changes. Remaining unexplained P&L must be investigated rather than automatically assigned to a balancing category.
  10. How would you separate new-deal, market-movement, time-decay, fixing and amendment P&L?I would preserve prior-day trades and market data, then revalue through controlled sequential states. Introducing current trades isolates new-deal P&L; updating market data captures market movement; advancing time captures carry; applying published observations captures fixing effects; and applying changed trade versions isolates amendment P&L.
  11. What is the difference between accounting P&L and risk or economic P&L?Economic P&L reflects current valuation and trading performance using approved risk curves and models. Accounting P&L follows recognition, classification and measurement rules under the applicable accounting standard. Timing, accruals, reserves, hedge accounting and valuation adjustments can therefore produce legitimate differences between them.
  12. How would you investigate a material unexplained P&L amount?I would confirm trade population, versions, valuation date, market-data snapshots, fixings and calculation status. Then I would compare cash flows and sensitivities across sequential P&L states. Remaining differences would be traced to mappings, lifecycle events, units, curves, model changes or incomplete processing.
  13. Why might trader P&L differ from Product Control P&L?The trader may use intraday prices, indicative curves, local adjustments or different portfolio filters, while Product Control uses independently approved end-of-day data, reserves and accounting adjustments. Differences can also arise from cut-offs, late trades, FX rates, valuation models, hierarchy mappings or failed calculations.
  14. How should prior-day curves and prior-day trade states be preserved?Official close processing should retain immutable, versioned snapshots of trades, reference data, fixings, curves, models and configuration with a common as-of timestamp. Reproducing prior-day P&L requires selecting that complete information set, not merely restoring yesterday's prices against today's amended transactions.
  15. How would you prevent double counting between physical trades and associated hedges?I would retain physical and hedge transactions separately but connect them through strategy or hedge relationships. Reports should aggregate signed exposure by common risk factors while preserving basis differences. Controls must prevent operational movements, internal transfers or derivative equivalents from being counted as additional external positions.
7. Front Office Workflows and Controls15
  1. Design a workflow from draft trade through trader validation, confirmation and operational processing.A trader creates a draft using approved templates and reference data. Automated checks validate economics, mandate, counterparty, credit and price reasonableness. Authorised approval moves the trade to validated status, triggering positions, confirmations and operational events. Exceptions enter controlled queues with ownership and ageing.
  2. Which trade checks should be blocked, and which should generate warnings?Failures affecting legal validity, valuation, settlement, credit, trader authority or mandatory economics should block progression. Lower-risk anomalies may generate warnings when an authorised user can assess them. Classification should reflect materiality, compensating controls and downstream consequences rather than user convenience.
  3. How would you implement approval thresholds based on notional, tenor, product and trader mandate?I would define configurable approval rules using notional, quantity, tenor, product complexity, off-market amount, portfolio and trader mandate. Transactions exceeding thresholds would require independent approval before validation. Rules need named owners, effective dates, version control, exception handling and evidence of approval.
  4. How would you enforce counterparty, credit and market-risk controls before trade validation?ETRM should calculate incremental counterparty exposure, market-risk usage and applicable limit consumption before validation. Approved rules would block or route breaches for authorised approval. Controls must use current agreements, collateral, hierarchy and market data while preserving the decision, values, timestamp and approver.
  5. What should happen when credit capacity is unavailable?The trade should remain unvalidated or enter a controlled pending-credit status. Credit Risk may reject it, reduce its size, obtain collateral or approve a documented temporary excess within authority. The system should not silently book the transaction or treat unavailable exposure data as zero.
  6. How would you support emergency trade capture while retaining governance?I would provide a restricted emergency workflow with named authorised users, mandatory justification, limited products and thresholds, enhanced logging and automatic expiry. Trades would undergo retrospective independent review within a defined period. Emergency access must not become a permanent shortcut around standard controls.
  7. How would you control backdated and future-dated trades?Date tolerances should vary by product, portfolio and user role. Transactions outside approved ranges should be blocked or require independent approval and justification. Controls must evaluate impacts on historical positions, P&L, confirmations, settlements, accounting and regulatory reporting, triggering restatement where necessary.
  8. How would you control manual price overrides?Overrides should require a reason, approved source, user authority and independent review above materiality thresholds. ETRM must retain original and overridden values, timestamps and approvals. Reports should identify active overrides, their valuation impact, age and expiry, preventing them from becoming permanent undocumented prices.
  9. How should off-market transactions be detected and approved?The trade price should be compared with an independent market or model value using product-specific tolerances. Material deviations require documented commercial rationale and approval independent of the trader. The control should consider bid-offer, liquidity, optionality and legitimate structured economics before classifying a breach.
  10. How would you govern changes to portfolios, strategies and trader assignments?Creation and modification should follow controlled requests with business-owner, Risk, Finance and security approval where relevant. Changes need effective dates, impact analysis, testing and audit history. Historical reporting must preserve prior assignments rather than automatically rewriting earlier positions and P&L under current structures.
  11. What information should be retained in the trade audit trail?The audit trail should record original and changed values, transaction version, user or service identity, timestamp, action, reason, workflow status and approval. It should also preserve source identifiers and distinguish manual, interface-generated and system-derived changes while remaining tamper-resistant and searchable.
  12. How should workflow design separate economic validation from operational completeness?Economic validation confirms product, price, quantity, dates, counterparty, portfolio and valuation terms are sufficient for risk recognition. Operational validation confirms settlement instructions, delivery details, confirmation data and documentation. A trade may enter risk promptly while remaining in a controlled operational-exception workflow.
  13. How would you prevent a failed downstream event from blocking trader activity unnecessarily?Trade validation should commit the authoritative transaction and publish durable downstream work asynchronously. Failed confirmations, reports or interfaces should enter retryable exception queues rather than reversing valid trades. Idempotency, monitoring and reconciliation must ensure failures are recovered without loss or duplicate processing.
  14. What is your approach to workflow retry, exception handling and operational ownership?I would classify errors as transient, data-related or permanent. Transient failures receive limited automated retries with back-off; data errors enter owned work queues; permanent failures require technical resolution. Every exception needs correlation identifiers, ageing, escalation, controlled replay and proof of successful completion.
  15. How would you demonstrate that Front Office controls remain effective after an ETRM upgrade?I would execute traceable positive and negative regression tests covering permissions, mandates, limits, approvals, overrides, audit history and exception handling. Results would be compared with the approved baseline, while changed behaviour receives impact assessment, business-control-owner approval and post-production monitoring.
8. Integration Architecture15
  1. How would you integrate an exchange, broker or execution-management system with ETRM?
  2. When would you use real-time messaging, APIs, database staging or batch-file integration?
  3. What are the risks of directly integrating external systems with ETRM database tables?
  4. How would you design idempotent trade ingestion?
  5. How would you manage source-system identifiers and ETRM deal numbers?
  6. How would you handle partial integration failure after a deal has already been created?
  7. What acknowledgment and reconciliation controls should surround inbound trades?
  8. How would you publish Front Office positions and P&L to an enterprise data platform?
  9. How would you ensure that downstream consumers receive amendments in the correct order?
  10. How would you manage schema evolution for trade events?
  11. How would Kafka fit alongside ETRM's native integration mechanisms?
  12. Which data should be distributed as events, and which should be obtained through queries?
  13. How would you prevent a reporting platform from placing excessive load on ETRM?
  14. How would you design integrations for low-latency intraday risk?
  15. How would you reconcile externally executed trades against ETRM?
9. Performance and Batch Architecture10
  1. A trader's position screen takes five minutes to load. How would you diagnose it?
  2. What commonly causes slow ETRM simulations?
  3. How would you separate database, configuration, script and valuation-model performance problems?
  4. How would you optimize a large portfolio simulation?
  5. What are the risks of adding excessive result measures to every simulation?
  6. How would you design intraday simulations differently from official end-of-day runs?
  7. How would you manage concurrent trader and batch workloads?
  8. How do grid computing and distributed valuation affect the solution design?
  9. How would you investigate a simulation that returns different results across environments?
  10. Which non-functional requirements should be agreed before designing a Front Office solution?
10. Architecture and Design Governance15
  1. What artifacts should an ETRM Solution Architect produce before implementation?
  2. How would you document current-state and target-state ETRM architecture?
  3. What belongs in a solution-design document for a new trading product?
  4. How do you decide between configuration, scripting, custom code and external services?
  5. How do you prevent excessive ETRM customisation?
  6. What makes an ETRM solution upgrade-safe?
  7. How would you organise reusable components across multiple commodity desks?
  8. How would you conduct an architectural design review?
  9. How do you trace business requirements to configuration, code and tests?
  10. What design decisions should be recorded in an architecture decision register?
  11. How would you manage ETRM configuration across development, testing and production?
  12. How do you handle environment-specific identifiers and reference data?
  13. How would you assess the impact of an ETRM version upgrade on the Front Office?
  14. What should be included in a Front Office production-readiness review?
  15. How would you balance trader usability, control, performance and maintainability?
11. Scenario-Based Architect Questions15
  1. A trader says the position is correct but P&L is wrong. Describe your investigation.
  2. ETRM and the exchange show different positions. How do you determine the authoritative state?
  3. A newly entered deal values correctly but does not appear in the trader's position report. What do you check?
  4. A curve was corrected after end-of-day. How would you rerun valuation without destroying the original official result?
  5. A physical crude deal is economically correct but produces incorrect invoices. Is this a Front Office or settlement-design issue?
  6. A structured LNG contract takes 20 seconds to value individually but causes the portfolio simulation to exceed its SLA. What would you change?
  7. Traders want a spreadsheet upload that bypasses normal trade validation. How would you respond?
  8. The business wants one global deal template despite regional differences. What risks would you raise?
  9. A desk wants real-time P&L, but official market data updates only periodically. How would you define the result?
  10. A trade amendment changes historical P&L. How would you determine whether this is expected?
  11. ETRM contains thousands of nearly identical trade templates. How would you rationalise them?
  12. A new product can be represented using a generic instrument, but users find the trade-entry screen confusing. How would you decide whether to customize it?
  13. A trader books the same economics across several instruments to obtain the required valuation. What long-term risks does this create?
  14. A production issue can be fixed through either a script change or reference-data correction. How would you choose?
  15. The Front Office requests unrestricted manual curve overrides. Design a controlled alternative.
12. Solution-Architect Leadership Questions15
  1. How do you challenge a requirement that reproduces an inefficient legacy process?
  2. How do you resolve disagreements between traders, risk, operations and technology?
  3. How do you estimate an ETRM product-onboarding initiative?
  4. How do you identify architecture dependencies before committing delivery dates?
  5. How would you divide responsibilities among functional consultants, developers, quants, data engineers and infrastructure teams?
  6. How do you review the quality of ETRM scripts and configurations?
  7. How would you govern design decisions delivered by multiple implementation partners?
  8. Describe a major ETRM production problem you diagnosed and the evidence that identified its root cause.
  9. Describe a design you rejected even though the business initially preferred it.
  10. How do you explain a complex valuation or architecture decision to senior non-technical stakeholders?
  11. How do you ensure operational support teams can manage the implemented solution?
  12. What metrics would show whether a Front Office implementation has succeeded?
  13. How would you plan parallel run and migration for an existing trading desk?
  14. What would make you stop a production release?
  15. What distinguishes an ETRM Solution Architect from a senior ETRM developer or functional consultant?
Essential Whiteboard Exercises10
  1. End-to-end OTC commodity trade flow from execution to P&L and settlement.
  2. Physical crude trade priced at monthly Brent average plus differential.
  3. Gas delivery profile with nominations, actuals, imbalance and settlement.
  4. Intraday and end-of-day curve architecture.
  5. Real-time trade ingestion with idempotency, retry and reconciliation.
  6. Front Office position and P&L reporting architecture.
  7. New-product onboarding process with governance and testing.
  8. High-availability design for business-critical trading operations.
  9. Historical as-of valuation and reproducible P&L architecture.
  10. ETRM-to-enterprise-data-platform integration using events and controlled extracts.
Middle Office12 sections · 170 questions
1. Middle Office Operating Model10
  1. What does a Middle Office function do within an ETRM-based trading organisation?
  2. How do Front Office, Middle Office, Product Control, Credit Risk and Back Office responsibilities differ?
  3. Explain the trade lifecycle from Middle Office validation through risk reporting and control.
  4. Which trade attributes are most important for Middle Office control?
  5. How would you design segregation of duties between traders and control functions?
  6. Which controls should operate pre-trade, at trade validation and post-trade?
  7. How should the Middle Office manage late, backdated and amended trades?
  8. What is the difference between preventive, detective and corrective controls?
  9. How would you establish an exception-based Middle Office operating model?
  10. What evidence should ETRM retain for audit and regulatory review?
2. Trade Validation and Control15
  1. How would you design a Middle Office trade-validation workflow in ETRM?
  2. Which validations should block a trade from progressing?
  3. How would you identify off-market transactions?
  4. How would you control manual price overrides?
  5. How would you detect trades booked in incorrect portfolios?
  6. How should trader mandates and product permissions be enforced?
  7. How would you control transactions exceeding tenor or quantity thresholds?
  8. How would you identify duplicate or missing trades?
  9. How should cancelled, terminated, novated and partially unwound trades be controlled?
  10. How would you validate complex pricing formulas independently?
  11. How would you control internal, inter-book and intercompany trades?
  12. How should exceptions be prioritised, assigned, aged and escalated?
  13. How would you handle trades entered after an official valuation cut-off?
  14. What controls should apply to spreadsheet and bulk-uploaded transactions?
  15. How would you prove that all executed trades were captured in ETRM?
3. Position and Exposure Management15
  1. Explain contractual, pricing, delivery, nominated and actual positions.
  2. How would you design a consolidated commodity position report?
  3. How should ETRM aggregate positions across units, currencies and locations?
  4. What is the difference between physical and financial exposure?
  5. How should fixed and floating legs appear in position reporting?
  6. How does exposure change as index observations become fixed?
  7. How would you represent basis and location risk?
  8. How would you measure shape risk in gas or power portfolios?
  9. How would you identify unintended residual positions?
  10. How should options and nonlinear instruments appear in position reports?
  11. How would you reconcile ETRM positions with exchanges and brokers?
  12. How would you reconcile physical positions with scheduling systems?
  13. What can cause a trade to value correctly but appear incorrectly in positions?
  14. How would you control unit-of-measure conversions?
  15. How should historical as-of positions be reproduced?
4. P&L and Product Control15
  1. Explain realised, unrealised, settled and total P&L.
  2. How would you design daily P&L reporting in ETRM?
  3. What is P&L attribution or explain?
  4. How would you separate new-deal, market-movement, fixing, time and amendment P&L?
  5. What causes unexplained P&L?
  6. How would you investigate a large day-on-day P&L movement?
  7. Why might trader P&L differ from Product Control P&L?
  8. How do intraday and official end-of-day P&L differ?
  9. How should fees, premiums, transportation and storage costs affect P&L?
  10. How would you handle provisional and final pricing in P&L?
  11. How do nominations and actual quantities affect physical-trade P&L?
  12. How should FX effects be separated from commodity-price effects?
  13. How would you design P&L sign-off and adjustment workflows?
  14. How should prior-period corrections and restatements be governed?
  15. How would you reconcile ETRM P&L with the general ledger?
5. Market Data and Independent Price Verification15
  1. What is the Middle Office role in market-data governance?
  2. How would you distinguish trader, risk, accounting and IPV curves?
  3. What controls should validate incoming market prices?
  4. How would you identify stale, missing or anomalous market data?
  5. How should price-source hierarchies and fallback rules be governed?
  6. How would you design independent price verification in ETRM?
  7. How do bid-offer reserves affect fair-value reporting?
  8. How would you value illiquid or unobservable curve tenors?
  9. How should valuation adjustments be calculated and approved?
  10. How would you control manual curve adjustments?
  11. What is prudent valuation, and how does it differ from economic valuation?
  12. How would you investigate a curve change causing a material P&L movement?
  13. How should corrected market data be applied after end-of-day?
  14. How would you prevent future information from entering historical valuations?
  15. What evidence should support an official market-data snapshot?
6. Market Risk and Sensitivities15
  1. Which market-risk measures should ETRM calculate for commodity portfolios?
  2. Explain delta, gamma, vega and theta in commodity trading.
  3. How would you calculate basis, location and spread sensitivities?
  4. What risk factors should be mapped for a physical crude-oil portfolio?
  5. How would you represent gas or power shape risk?
  6. How do cross-currency trades create combined commodity and FX exposure?
  7. How should risk-factor mappings be governed?
  8. What happens when a trade cannot be mapped to an approved risk factor?
  9. How would you validate ETRM sensitivities independently?
  10. What can cause unstable or counterintuitive Greeks?
  11. How would you design risk aggregation by desk, book and legal entity?
  12. How should nonlinear and optional products be included in risk reporting?
  13. How would you distinguish gross, net and hedged exposure?
  14. How should liquidity risk complement conventional market-risk measures?
  15. How would you investigate inconsistent risk across two simulations?
7. Value at Risk17
  1. Explain parametric, historical and Monte Carlo VaR.
  2. Which VaR method is most appropriate for a commodity portfolio?
  3. How would you design an ETRM VaR implementation?
  4. What are risk factors, returns, covariance matrices and confidence levels?
  5. How should missing historical data be handled?
  6. How would you map new or illiquid products to proxy risk factors?
  7. What is the difference between full revaluation and sensitivity-based VaR?
  8. How do holding period and confidence level affect VaR?
  9. How should options and nonlinear products be treated?
  10. How would you validate VaR results?
  11. What is VaR backtesting?
  12. How should backtesting exceptions be investigated?
  13. What is model drift, and how would you detect it?
  14. How would you prevent incorrect aggregation of commodity-level VaR?
  15. Why can portfolio VaR differ from the sum of individual VaRs?
  16. How would you investigate an unexpectedly large VaR result?
  17. What limitations of VaR must be communicated to management?
8. Stress Testing and Scenario Analysis15
  1. How does stress testing differ from VaR?
  2. How would you design historical and hypothetical stress scenarios?
  3. What constitutes a shocked-revaluation stress test?
  4. Why is multiplying delta by a price shock insufficient for some products?
  5. How would you stress commodity, basis, FX and volatility risks together?
  6. How should correlations behave under stressed conditions?
  7. How would you model negative commodity prices?
  8. How would you stress illiquid forward-curve tenors?
  9. How should physical constraints be represented in stress testing?
  10. How would you stress an LNG portfolio for cargo delay or diversion?
  11. How would you model gas-storage or power-shape stress?
  12. How should stress losses be aggregated and reported?
  13. How would you govern scenario creation, approval and retirement?
  14. How should stress-test results influence limits and management actions?
  15. How would you demonstrate that a scenario is severe but plausible?
9. Credit Risk and Limits15
  1. How does commodity counterparty credit risk differ from market risk?
  2. Explain current, future and settlement exposure.
  3. How would you calculate counterparty exposure in ETRM?
  4. What is potential future exposure?
  5. How do netting and collateral agreements reduce exposure?
  6. How would you model parent, subsidiary and credit-group structures?
  7. How should guarantees and letters of credit affect available credit?
  8. How would you implement credit limits by counterparty, product and tenor?
  9. What should happen when a proposed trade breaches a limit?
  10. How should temporary limit increases be governed?
  11. How do wrong-way risk and concentration risk arise?
  12. How would you represent sovereign, country and industry limits?
  13. How would you reconcile ETRM credit exposure with a central credit platform?
  14. How should disputed settlements affect credit exposure?
  15. How would you investigate an unexpected credit-limit breach?
10. Risk Limits and Mandates13
  1. What types of market-risk limits should be configured?
  2. How would you distinguish hard and soft limits?
  3. How should limit utilisation be calculated and aggregated?
  4. How would you define limits for delta, VaR, stress and position?
  5. How should desk, book and trader mandates interact?
  6. What workflow should follow a limit breach?
  7. How would you handle a breach caused by market movements rather than new trading?
  8. How should intraday and end-of-day limit monitoring differ?
  9. How would you prevent users from bypassing limits through portfolio transfers?
  10. How should temporary exceptions and limit extensions expire?
  11. What evidence should support limit approval and changes?
  12. How would you prevent double counting across hierarchical limits?
  13. How should limit consumption be reconciled with reported risk?
11. Simulations, Reporting and Performance15
  1. Explain the purpose of ETRM simulations and result measures.
  2. How would you design separate intraday and end-of-day simulations?
  3. What result measures are required for Middle Office reporting?
  4. How would you preserve reproducible official risk results?
  5. What commonly causes slow ETRM risk simulations?
  6. How would you optimize a large portfolio simulation?
  7. How should simulation dependencies and execution order be managed?
  8. How would you prevent reporting workloads from affecting traders?
  9. What controls should verify that all portfolios were processed?
  10. How would you manage failed or partially completed risk runs?
  11. How should corrected trades or market data trigger recalculation?
  12. How would you publish ETRM risk results to an enterprise platform?
  13. How would you reconcile published results with ETRM?
  14. How should report definitions, filters and calculations be versioned?
  15. What service-level objectives should apply to risk reporting?
12. Architecture and Scenario Questions10
  1. A trader's P&L is correct, but VaR is materially overstated. How would you investigate?
  2. ETRM and the exchange report different positions. Which checks would you perform?
  3. A new trade is visible in P&L but missing from risk. What could cause this?
  4. A corrected curve changes yesterday's official P&L. How should it be handled?
  5. A portfolio has zero net delta but significant basis risk. Explain the situation.
  6. A VaR result rises tenfold overnight without major market movement. How would you isolate the cause?
  7. Traders request permission to override risk-factor mappings. How would you respond?
  8. A physical contract values correctly but its delivery exposure is wrong. Where would you investigate?
  9. Risk results differ between test and production using the same trades. What should be compared?
  10. What distinguishes an ETRM Middle Office Solution Architect from a risk analyst, functional consultant or developer?
Back Office12 sections · 190 questions
1. Back Office Operating Model10
  1. What does the Back Office function do in an ETRM-based trading organisation?
  2. How do Front Office, Middle Office, Operations, Back Office and Finance responsibilities differ?
  3. Explain the transaction lifecycle after Front Office validation.
  4. Which ETRM trade attributes are critical for downstream processing?
  5. How would you design segregation of duties between trade entry, confirmation, settlement and payment?
  6. What are the differences between economic, operational, settlement and accounting events?
  7. How would you design an exception-based Back Office operating model?
  8. Which controls should be preventive, detective or corrective?
  9. How should Back Office manage late and backdated transactions?
  10. What operational evidence must ETRM retain for audit purposes?
2. ETRM Event and Lifecycle Architecture15
  1. Explain ETRM's event-driven processing architecture.
  2. How do instruments generate lifecycle and settlement events?
  3. What is the relationship among transactions, parameters, profiles, cash flows and events?
  4. How do event dates differ from payment and settlement dates?
  5. How would you identify missing or incorrectly generated events?
  6. What happens to events when a transaction is amended?
  7. How should cancelled, terminated and partially unwound transactions affect existing events?
  8. How would you prevent duplicate lifecycle events?
  9. When should an event be regenerated rather than manually corrected?
  10. How would you manage event dependencies and processing order?
  11. What controls should prevent incomplete trades from generating downstream events?
  12. How should historical events be preserved after transaction changes?
  13. How would you manage manually entered Back Office events?
  14. What configuration changes can unintentionally alter event generation?
  15. How would you test event generation for a newly introduced product?
3. Confirmations and Contract Documentation15
  1. Explain the confirmation lifecycle in ETRM.
  2. What determines whether a transaction requires confirmation?
  3. How would you select the correct confirmation template?
  4. Which trade and reference-data fields commonly populate confirmations?
  5. How would you support confirmations across products, languages and legal entities?
  6. What is the difference between paper, email and electronic confirmation?
  7. How would you integrate ETRM with an electronic confirmation platform?
  8. How should matching statuses and discrepancies be managed?
  9. What controls should identify unconfirmed or aged transactions?
  10. How would you handle disputed economic terms?
  11. How should trade amendments affect previously issued confirmations?
  12. How would you manage transaction cancellations and confirmation withdrawals?
  13. What should happen when confirmation generation fails?
  14. How would you prevent duplicate confirmations?
  15. How would you prove that all eligible transactions were confirmed?
4. Settlement Instructions and Static Data15
  1. What are standard settlement instructions?
  2. How should settlement instructions be assigned to a transaction?
  3. How would you model instructions by counterparty, legal entity, currency and product?
  4. How would you control changes to bank-account details?
  5. Why should settlement instructions not be maintained directly on every trade?
  6. How should effective dating work for settlement instructions?
  7. What happens when settlement instructions are missing or ambiguous?
  8. How would you prevent payments to unauthorised bank accounts?
  9. What maker-checker controls should govern sensitive static data?
  10. How would you handle one-off settlement instructions?
  11. How should beneficiary, intermediary and correspondent banks be represented?
  12. How would you manage settlement instructions for internal counterparties?
  13. What reference data is necessary for physical commodity settlement?
  14. How would you migrate settlement instructions from a legacy platform?
  15. How would you test static-data changes without creating real payments?
5. Settlement and Netting20
  1. Explain the ETRM settlement lifecycle.
  2. How are settlement amounts generated from transaction economics?
  3. What is the difference between contractual cash flow and settlement events?
  4. How would you validate settlement amounts independently?
  5. How should fixed and floating transactions progress toward settlement?
  6. How are provisional and final settlements managed?
  7. How do payment terms, business-day rules and calendars affect settlement dates?
  8. How would you configure bilateral settlement netting?
  9. What legal prerequisites must exist before cash flows can be netted?
  10. How should netting by currency, agreement and settlement date work?
  11. How would you prevent inappropriate netting across legal entities?
  12. What is payment netting versus close-out netting?
  13. How would you manage gross-settlement exceptions?
  14. How should disputed cash flows be excluded from payment?
  15. How would you control manual settlement adjustments?
  16. What happens when a settled transaction is amended?
  17. How would you reconcile expected and completed settlements?
  18. How should settlement failures be tracked and escalated?
  19. How would you manage partial settlement?
  20. How would you demonstrate settlement completeness at end-of-day?
6. Invoicing20
  1. Explain the invoice lifecycle for a physical commodity transaction.
  2. What is the difference between payable, receivable and self-billing invoices?
  3. How does ETRM group settlement events into invoices?
  4. Which attributes should determine invoice grouping?
  5. How would you configure invoice templates for different legal entities?
  6. How are taxes, fees and additional charges included?
  7. How would you manage provisional and final invoices?
  8. How should quantity and price adjustments affect invoices?
  9. How would you handle credit notes and debit notes?
  10. What happens when an invoiced transaction is amended?
  11. How would you prevent duplicate invoicing?
  12. How should invoice numbering be controlled?
  13. How would you manage disputed invoices?
  14. What controls should identify uninvoiced eligible events?
  15. How would you reconcile invoices with supporting trades and deliveries?
  16. How should rounding differences be managed?
  17. How would you integrate ETRM with an external invoicing platform?
  18. How would you support electronic invoicing requirements?
  19. How should invoice approval and release be segregated?
  20. What evidence should support invoice cancellation and reissuance?
7. Physical Commodity Operations15
  1. How do scheduled, nominated, confirmed and actual quantities differ?
  2. How should actual quantities update settlement?
  3. How would you model quantity tolerances?
  4. How should under-delivery and over-delivery be processed?
  5. How would you handle natural-gas imbalance charges?
  6. How should oil quantity and quality adjustments affect invoicing?
  7. How would you represent losses, gains and shrinkage?
  8. How should delivery locations and movement identifiers be controlled?
  9. How would you integrate ETRM with a scheduling or logistics platform?
  10. What happens when operational actuals arrive after invoicing?
  11. How would you reconcile contractual quantities with physical movements?
  12. How should inventory transfers affect settlement and accounting?
  13. How would you process freight, demurrage and ancillary charges?
  14. How should LNG boil-off or delivered-energy adjustments be handled?
  15. How would you preserve traceability from a physical movement to its financial settlement?
8. Payments and Treasury Integration15
  1. Explain the process from approved settlement to payment instruction.
  2. How would you integrate ETRM with a treasury-management or payment platform?
  3. What payment statuses should return to ETRM?
  4. How would you generate and control payment files?
  5. What controls should prevent duplicate payments?
  6. How would you support payment cancellation and recall?
  7. How should rejected bank payments be handled?
  8. How would you manage payment cut-off times?
  9. How should value dates and payment dates differ?
  10. How would you manage multicurrency settlement?
  11. How should bank charges be recorded?
  12. What is payment-on-behalf-of, and what controls does it require?
  13. How would you manage urgent manual payments?
  14. How would you reconcile payment acknowledgements and bank statements?
  15. How should unapplied cash be investigated?
9. Accounting Architecture20
  1. Explain how ETRM generates accounting entries from transactions and events.
  2. What is the relationship between business events and accounting events?
  3. How would you design accounting rules for a new commodity product?
  4. How should realised and unrealised P&L be accounted for?
  5. How would you handle accruals and reversals?
  6. How should invoices, settlements and payments affect accounting?
  7. How would you account for provisional and final pricing?
  8. How should fees, premiums and transportation costs be treated?
  9. How would you handle inventory accounting?
  10. How should intercompany transactions be accounted for?
  11. How would you support multiple accounting standards or ledgers?
  12. How should account mappings be governed?
  13. What dimensions should accompany general-ledger postings?
  14. How would you prevent unbalanced accounting entries?
  15. How should accounting periods and cut-offs be controlled?
  16. How would you handle postings after period close?
  17. How should accounting corrections be implemented?
  18. How would you reconcile ETRM's subledger with the general ledger?
  19. What controls identify unposted or rejected accounting events?
  20. How would you test accounting changes for existing products?
10. Collateral and Margin Operations10
  1. How do variation margin and initial margin differ?
  2. How should collateral calls be calculated and processed?
  3. How would you represent collateral agreements and thresholds?
  4. How do minimum transfer amounts and independent amounts affect calls?
  5. How should collateral disputes be managed?
  6. How would you integrate ETRM with clearing brokers or collateral platforms?
  7. How should cash and non-cash collateral be represented?
  8. How would you manage collateral interest?
  9. What controls prevent duplicate or incorrect margin payments?
  10. How would you reconcile ETRM collateral balances with external statements?
11. Reconciliation, Interfaces and Batch Processing15
  1. Which Back Office reconciliations should be performed daily?
  2. How would you reconcile trades, events, invoices, payments and accounting entries?
  3. How would you design idempotent outbound interfaces?
  4. How should failed interface messages be retried?
  5. How would you prevent events from being delivered out of sequence?
  6. How should source and target identifiers be maintained?
  7. What should a Back Office control dashboard contain?
  8. How would you design completeness and control-total checks?
  9. What commonly causes ETRM end-of-day processing failures?
  10. How would you restart a failed batch without duplicating output?
  11. How should business cut-offs and time zones be managed?
  12. How would you preserve reproducible end-of-day results?
  13. How should archived settlement and accounting data remain accessible?
  14. How would you design operational monitoring and alerting?
  15. Which service levels should apply to confirmations, invoices, payments and accounting?
12. Solution Architecture Scenarios20
  1. A trade values correctly but generates no settlement event. How would you investigate?
  2. ETRM produces the wrong payment date despite correct contractual terms. What would you check?
  3. An amendment creates both the original and revised invoice amounts. How would you resolve it?
  4. A counterparty receives two confirmations for one transaction. Where could duplication occur?
  5. ETRM nets payments that the legal agreement requires to settle gross. How would you respond?
  6. A bank rejects a payment file generated by ETRM. How would you isolate the cause?
  7. A physical trade settles using scheduled rather than actual quantity. What should be examined?
  8. ETRM and the general ledger disagree after month-end. How would you reconcile them?
  9. Accounting entries are correct individually but unbalanced by legal entity. What could cause this?
  10. An invoice was issued before a corrected fixing arrived. How should the lifecycle continue?
  11. A settled transaction is cancelled retrospectively. What controls and events are required?
  12. Operations requests direct database correction of a failed event. How would you respond?
  13. ETRM and the treasury platform show different payment statuses. Which system is authoritative?
  14. An interface replay creates duplicate accounting postings. How should the architecture prevent this?
  15. A Back Office batch misses its cut-off. How would you prioritise recovery?
  16. A new product values correctly but fails confirmation and accounting tests. Is it production-ready?
  17. How would you migrate unsettled trades without duplicating invoices or payments?
  18. How would you prove that every eligible settlement event reached the payment platform?
  19. What would make you stop a Back Office production release?
  20. What distinguishes an ETRM Back Office Solution Architect from a functional consultant or developer?
Technical and Platform Architecture17 sections · 320 questions
1. ETRM Platform Architecture15
  1. Describe the logical architecture of an enterprise ETRM implementation.
  2. What are the principal ETRM platform components and their responsibilities?
  3. How do ETRM clients, application services, engines and database components interact?
  4. How does ETRM's architecture support Front, Middle and Back Office processes?
  5. Which processing should remain inside ETRM, and which should be externalised?
  6. How would you identify architectural boundaries between ETRM and surrounding platforms?
  7. What are the major stateful and stateless components?
  8. How does ETRM support interactive, scheduled and event-driven processing?
  9. How would you map ETRM components to business capabilities?
  10. Which architectural dependencies create the greatest operational risk?
  11. What information would you collect before designing an ETRM target architecture?
  12. How would you document the current-state platform?
  13. How would you identify obsolete, duplicate or unsupported components?
  14. How should architecture differ for a single-desk and global multi-commodity implementation?
  15. What distinguishes a platform architecture decision from a functional configuration decision?
2. ETRM Services and Processing Components15
  1. What categories of ETRM services and engines are commonly deployed?
  2. How should services be separated by workload and business criticality?
  3. Which services require continuous availability?
  4. How do interactive and background processing workloads differ?
  5. How would you prevent one resource-intensive process from affecting other users?
  6. How should service instances be distributed across hosts?
  7. When should multiple service instances be deployed?
  8. How would you determine appropriate concurrency levels?
  9. What causes service contention or processing bottlenecks?
  10. How should service dependencies and startup order be managed?
  11. What health checks should be implemented for ETRM services?
  12. How would you detect a service that is running but not processing correctly?
  13. How should failed jobs be recovered safely?
  14. How would you prevent duplicate execution following service restart?
  15. What operational metadata should every service execution produce?
3. Transaction and Reference-Data Architecture15
  1. How are transactions represented within ETRM?
  2. What is the architectural relationship among instruments, transactions, parameters and profiles?
  3. How do transaction statuses affect downstream processing?
  4. How would you design organisational structures, portfolios and books?
  5. How should legal entities, business units and counterparties be represented?
  6. Which reference-data domains are foundational to ETRM?
  7. How would you establish authoritative sources for reference data?
  8. What are the risks of duplicating enterprise reference data inside ETRM?
  9. How should effective-dated reference data be managed?
  10. How would you control changes to indexes, units, currencies and calendars?
  11. How should reference-data dependencies be migrated between environments?
  12. How would you identify transactions affected by a reference-data change?
  13. What controls should govern bulk reference-data updates?
  14. How would you reconcile ETRM reference data with enterprise master-data platforms?
  15. How should historical transactions remain reproducible after reference-data changes?
4. Database and Persistence Architecture15
  1. What role does the relational database play within ETRM?
  2. Why should external applications avoid direct writes to ETRM tables?
  3. When, if ever, are direct database reads acceptable?
  4. What risks arise from tightly coupling reporting to the ETRM schema?
  5. How would you identify expensive database queries?
  6. What causes database blocking and contention in ETRM?
  7. How should indexes and statistics be managed?
  8. How would you diagnose rapid database growth?
  9. Which data-retention and archival requirements should be defined?
  10. How would you design database backup and recovery?
  11. How would you verify that a backup is operationally recoverable?
  12. What consistency risks arise when restoring the database independently of other components?
  13. How should database credentials and privileged access be controlled?
  14. How would you separate transactional and analytical workloads?
  15. How should database changes be governed during an legacy-to-modern ETRM upgrade?
5. Extensibility with Custom Code20
  1. What is the platform scripting language, and where is it commonly used?
  2. When should the platform scripting language be used instead of standard configuration?
  3. When is a Java extension preferable to an the platform scripting language script?
  4. What are the risks of excessive scripting?
  5. How would you structure reusable script libraries?
  6. How should scripts handle transactions, errors and resource cleanup?
  7. How would you prevent memory leaks in long-running processes?
  8. How should logging be implemented within custom components?
  9. How would you manage script dependencies?
  10. How should configuration values be externalised from code?
  11. How would you prevent environment-specific identifiers from being hard-coded?
  12. What standards should apply to code reviews?
  13. How would you unit-test an the platform scripting language or Java component?
  14. How should integration and regression testing be organised?
  15. What makes a customisation upgrade-safe?
  16. How would you identify unused or duplicate custom code?
  17. How should custom components be versioned and deployed?
  18. How would you diagnose intermittent script failures?
  19. What controls should prevent unauthorised script execution?
  20. When should custom logic be moved outside ETRM?
6. APIs and Integration Architecture25
  1. What integration mechanisms are available around ETRM?
  2. How would you select among APIs, messaging, files and database extracts?
  3. What is OpenComponents, and when would you use it?
  4. How would you design synchronous trade-entry integration?
  5. When is asynchronous processing preferable?
  6. How would you implement idempotent trade ingestion?
  7. How should source-system and ETRM identifiers be mapped?
  8. How would you handle amendments arriving out of sequence?
  9. How should integration acknowledgements be designed?
  10. What retry strategy would you use for transient failures?
  11. How would you distinguish retryable and non-retryable errors?
  12. How should failed messages be quarantined and reprocessed?
  13. How would you prevent message replay from creating duplicate transactions?
  14. How should schemas and interface contracts be versioned?
  15. How would you maintain backward compatibility?
  16. What validation should occur before an inbound trade reaches ETRM?
  17. How would you publish transaction and lifecycle changes?
  18. Should ETRM expose business events or database-level changes?
  19. How would Kafka fit into an ETRM integration architecture?
  20. How would you trace a transaction across multiple systems?
  21. What reconciliation controls should accompany every material interface?
  22. How would you secure service-to-service communication?
  23. How should API throttling and workload protection be implemented?
  24. How would you test recovery after partial integration failure?
  25. What makes an interface operationally supportable?
7. Workflow and Process Orchestration15
  1. How are business workflows represented around ETRM?
  2. What is the distinction between workflow orchestration and business-rule execution?
  3. Which processes should be synchronous and which should be queued?
  4. How would you design an approval workflow?
  5. How should workflow state be persisted?
  6. How would you avoid tightly coupling unrelated business processes?
  7. What is the role of Transaction Processing Manager or equivalent orchestration capabilities?
  8. How would you design restartable workflow steps?
  9. How should timeouts and abandoned workflow instances be managed?
  10. How would you prevent the same event from triggering a process twice?
  11. How should manual exceptions rejoin automated processing?
  12. How would you monitor workflow throughput and ageing?
  13. What audit information should be retained for each transition?
  14. How should workflow configuration be tested?
  15. When should orchestration be implemented outside ETRM?
8. Batch, Scheduling and Grid Computing20
  1. How would you design the ETRM end-of-day architecture?
  2. What are the major dependencies within an end-of-day schedule?
  3. How should business dates and processing dates be controlled?
  4. How would you construct a restartable batch process?
  5. What checkpoints should exist within a long-running batch?
  6. How would you prevent duplicate output after a restart?
  7. What is the role of grid or distributed processing in ETRM?
  8. Which workloads are suitable for grid execution?
  9. How should portfolios and simulations be partitioned?
  10. What can cause uneven workload distribution?
  11. How would you determine the appropriate number of workers?
  12. Why might adding more workers fail to improve performance?
  13. How should compute capacity be allocated between intraday and end-of-day workloads?
  14. How would you manage dependencies among market data, valuation and reporting jobs?
  15. What should happen when only part of a risk run fails?
  16. How would you prove that all expected portfolios were processed?
  17. How should batch service-level objectives be monitored?
  18. How would you accommodate different regional cut-offs?
  19. How should daylight-saving changes be tested?
  20. What recovery strategy would you use after an extended infrastructure outage?
9. Reporting and Enterprise Data Architecture20
  1. What reporting workloads should remain within ETRM?
  2. When should data be extracted to an enterprise data platform?
  3. How would you protect ETRM from resource-intensive reporting?
  4. What is the difference between operational and analytical reporting?
  5. How would you design incremental data extraction?
  6. How should transaction amendments and deletions be represented downstream?
  7. How would you preserve historical trade states?
  8. How should valuation results be versioned?
  9. How would you model as-of and knowledge-time reporting?
  10. How would you reconcile a data lake or warehouse with ETRM?
  11. What control totals should accompany extracted datasets?
  12. How would you manage schema evolution?
  13. How should data lineage be captured?
  14. How would you protect sensitive trading and counterparty data?
  15. How would you prevent downstream reports from becoming unofficial books of record?
  16. What should happen when downstream data arrives late?
  17. How would you publish near-real-time positions?
  18. Which data is better distributed as events than snapshots?
  19. How should corrected historical data be communicated to consumers?
  20. How would you define ownership for ETRM-derived data products?
10. Performance and Capacity Engineering20
  1. How would you establish a performance baseline?
  2. Which metrics indicate ETRM platform health?
  3. How would you investigate slow client response?
  4. How would you distinguish client, network, service, database and script latency?
  5. What commonly causes slow simulations?
  6. How would you identify an inefficient custom script?
  7. How can excessive result measures affect performance?
  8. How would you analyse memory growth in a long-running process?
  9. What causes excessive database round trips?
  10. How should large datasets be processed efficiently?
  11. How would you conduct volume and stress testing?
  12. What transaction, market-data and result-volume assumptions are required?
  13. How would you model future capacity requirements?
  14. What are the risks of optimising without representative production data?
  15. How would you validate that an optimisation has not changed results?
  16. How should performance regressions be detected before release?
  17. How would you protect critical workloads during peak processing?
  18. What operational thresholds should generate alerts?
  19. How would you address gradually degrading performance?
  20. When is infrastructure scaling insufficient to solve a performance problem?
11. Security, Entitlements and Audit20
  1. How would you design role-based access in ETRM?
  2. How should permissions align with business responsibilities?
  3. How would you enforce segregation of duties?
  4. How should privileged administrative access be controlled?
  5. How would you manage service accounts?
  6. What is the appropriate approach to credential and secret management?
  7. How should portfolio and transaction visibility be restricted?
  8. How would you control access to custom scripts and reports?
  9. How should sensitive static-data changes be approved?
  10. What audit trail should exist for transaction amendments?
  11. How would you identify excessive or conflicting permissions?
  12. How should joiner, mover and leaver processes affect ETRM access?
  13. How would you conduct periodic access recertification?
  14. How should production support access be governed?
  15. What controls should apply to non-production copies of production data?
  16. How would you integrate ETRM with enterprise identity management?
  17. How should authentication failures and suspicious activity be monitored?
  18. How would you demonstrate compliance to an auditor?
  19. Which security controls belong inside ETRM and which belong in infrastructure?
  20. How should emergency-access activity be reviewed?
12. Infrastructure, High Availability and Disaster Recovery20
  1. How would you design a highly available ETRM environment?
  2. Which ETRM components require active-active or active-passive resilience?
  3. How should single points of failure be identified?
  4. What recovery-time and recovery-point objectives are appropriate?
  5. How should application and database recovery remain consistent?
  6. How would you design service failover?
  7. How should queued or in-flight work be handled during failover?
  8. How would you prevent duplicate processing after recovery?
  9. What infrastructure dependencies must be included in disaster recovery?
  10. How should DNS, certificates, secrets and external endpoints be recovered?
  11. How would you test disaster recovery without affecting production?
  12. What constitutes successful business-level recovery?
  13. How should storage performance and resilience be designed?
  14. How would you monitor infrastructure capacity?
  15. How should operating-system and middleware patching be managed?
  16. How would you minimise downtime during infrastructure maintenance?
  17. What additional considerations apply to virtualised infrastructure?
  18. How would network latency affect architecture choices?
  19. How should time synchronisation be controlled across components?
  20. What evidence should be retained from resilience testing?
13. Cloud and Deployment Architecture20
  1. What factors determine whether ETRM workloads are suitable for cloud hosting?
  2. How would you translate an on-premises ETRM architecture to cloud infrastructure?
  3. Which components can scale horizontally?
  4. Which components remain constrained by state or database dependencies?
  5. How would you design cloud network segmentation?
  6. How should private connectivity to exchanges, banks and market-data vendors be provided?
  7. How would you manage cloud identities and secrets?
  8. How should backups be protected across accounts or regions?
  9. What are the risks of treating ETRM as a cloud-native application?
  10. Where can containers be useful around ETRM?
  11. Why may containerising every ETRM component be inappropriate?
  12. How would you integrate ETRM with cloud-native messaging and analytics services?
  13. How should cloud consumption costs be controlled?
  14. How would you design non-production environments economically?
  15. How should production data be masked before cloud-based testing?
  16. What observability capabilities should be cloud-native?
  17. How would you manage availability-zone or regional failure?
  18. How would you validate vendor support for the proposed architecture?
  19. What architecture decisions would require a proof of concept?
  20. How would you avoid cloud-provider lock-in where it matters?
14. Environment and Configuration Management20
  1. What ETRM environments should an enterprise maintain?
  2. How should configuration move from development to production?
  3. How would you identify dependencies within a deployment package?
  4. How should database, configuration and code changes be coordinated?
  5. How would you prevent environment-specific values from entering shared packages?
  6. What version-control strategy should apply to scripts and configuration?
  7. How would you detect configuration drift?
  8. How should emergency production fixes be brought back into development?
  9. What evidence should accompany a release?
  10. How would you design automated deployment validation?
  11. Which ETRM changes require regression testing?
  12. How should reference data be promoted safely?
  13. How would you roll back a configuration deployment?
  14. What if rollback would invalidate newly created transactions?
  15. How should multiple project teams share an ETRM release train?
  16. How would you resolve conflicting configuration changes?
  17. What should a production-readiness review include?
  18. How should release cut-over and verification be organised?
  19. What post-deployment monitoring is required?
  20. When should a release be stopped?
15. Upgrade and Migration Architecture20
  1. How would you assess an ETRM version upgrade?
  2. Which customisations create the greatest upgrade risk?
  3. How would you establish an inventory of configuration and code?
  4. How should deprecated functions and APIs be identified?
  5. What regression scope is required for an upgrade?
  6. How would you compare valuations before and after an upgrade?
  7. Which differences may be legitimate?
  8. How would you validate event, settlement and accounting behaviour?
  9. How should performance be compared across versions?
  10. What is the role of parallel testing?
  11. How would you migrate active and historical transactions?
  12. How would you preserve transaction lineage and identifiers?
  13. How should open lifecycle events be migrated?
  14. How would you prevent duplicate confirmations, invoices or payments?
  15. What reconciliation controls should govern migration?
  16. How would you manage a phased desk migration?
  17. What determines whether coexistence is practical?
  18. How would you plan cut-over and rollback?
  19. How should business users participate in acceptance?
  20. What conditions should prevent go-live?
16. Monitoring and Production Support20
  1. What should an ETRM observability framework cover?
  2. Which application, service, database and business metrics should be monitored?
  3. How would you correlate logs across distributed components?
  4. How should correlation identifiers be propagated?
  5. What alerts require immediate escalation?
  6. How would you reduce false-positive alerts?
  7. How should incidents be classified by business impact?
  8. How would you diagnose an intermittent production issue?
  9. What evidence should be captured before restarting a failed service?
  10. When is a restart an unacceptable substitute for root-cause analysis?
  11. How would you manage recurring batch failures?
  12. How should known errors and operational workarounds be documented?
  13. What should a production-support runbook contain?
  14. How would you define Level 1, Level 2 and Level 3 support responsibilities?
  15. How should vendors be engaged during critical incidents?
  16. How would you perform root-cause analysis?
  17. How should corrective actions be tracked?
  18. What production metrics indicate architectural debt?
  19. How would you transition a new solution into support?
  20. How would you measure platform reliability?
17. Solution Architecture Scenarios20
  1. ETRM clients are slow, but database utilisation is normal. How would you investigate?
  2. A simulation succeeds for small portfolios but fails for the full desk. What would you examine?
  3. Increasing grid workers makes end-of-day slower. Why might this happen?
  4. An interface retries after timeout and creates duplicate trades. How would you redesign it?
  5. Trade updates arrive in the wrong order. How should ordering be enforced?
  6. A report directly querying ETRM causes production degradation. What should replace it?
  7. A service is running but has stopped consuming work. How should monitoring detect this?
  8. Test and production produce different valuations from identical trades. What should be compared?
  9. A reference-data change alters historical results. How would you restore reproducibility?
  10. A custom script consumes increasing memory throughout the day. How would you diagnose it?
  11. An end-of-day job fails after producing partial downstream output. How should I restart work?
  12. Disaster recovery restores the database but loses queued messages. What inconsistency can result?
  13. A cloud design assumes every ETRM component can autoscale. How would you challenge it?
  14. A team proposes direct database writes because the supported interface is slower. How would you respond?
  15. An upgrade breaks several undocumented scripts. What governance failure allowed this?
  16. Two projects require conflicting changes to the same configuration. How would you resolve them?
  17. A deployment succeeds technically but produces incorrect settlement events. What was missing?
  18. Production support frequently performs manual database corrections. What architectural action is required?
  19. Business users request zero downtime without funding resilience. How would you frame the decision?
  20. What distinguishes an ETRM Technical Solution Architect from an infrastructure engineer, developer or functional architect?
Data Model and Reference Data17 sections · 315 questions
1. ETRM Data-Model Fundamentals15
  1. How would you explain ETRM's logical data model to a non-technical stakeholder?
  2. What are the principal business-data domains within ETRM?
  3. How do transactional, reference, market and calculated data differ?
  4. What is the relationship between an instrument and a transaction?
  5. How do transactions, parameters, legs and profiles relate?
  6. How are financial cash flows and physical deliveries represented conceptually?
  7. How do lifecycle events relate to the originating transaction?
  8. What is the difference between stored, derived and simulation-result data?
  9. Which data should be treated as authoritative inside ETRM?
  10. Which data should remain mastered outside ETRM?
  11. How would you document ETRM entities and relationships?
  12. How would you trace a business field from the user interface to downstream output?
  13. Why is direct knowledge of physical database tables insufficient for solution architecture?
  14. What risks arise when external systems depend on ETRM's internal schema?
  15. How should business definitions be separated from physical implementation details?
2. Transaction Data Structure20
  1. What information is stored at the transaction level?
  2. What information belongs at the parameter or leg level?
  3. How are repeating delivery or pricing periods represented?
  4. How do header-level attributes differ from leg-level attributes?
  5. How would you model a transaction containing multiple commodities or currencies?
  6. How are buy/sell direction and payer/receiver direction represented?
  7. How does transaction status affect downstream processing?
  8. How are trade date, start date, maturity date and payment dates related?
  9. How should external execution identifiers be stored?
  10. How would you establish parent-child relationships among transactions?
  11. How should block trades and allocated transactions be linked?
  12. How would you represent amendments and transaction versions?
  13. How should cancellations and terminations remain historically traceable?
  14. How would you model novations and partial unwinds?
  15. What data is required to reproduce a transaction as of an earlier date?
  16. How would you identify economically equivalent but technically different transactions?
  17. What causes duplicate transactions, and how should they be prevented?
  18. How should transaction-level custom attributes be governed?
  19. When should information be represented as reference data rather than a transaction field?
  20. How would you avoid overloading generic fields with unrelated business meanings?
3. Instruments and Product Definitions15
  1. What does an ETRM instrument definition control?
  2. How do instrument definitions influence data capture and event generation?
  3. How would you determine whether an existing instrument supports a new product?
  4. What data-model risks arise from using the wrong instrument?
  5. How should product taxonomy differ from technical instrument taxonomy?
  6. How would you model physical and financial variants of the same commodity?
  7. How should fixed, floating and optional components be represented?
  8. How would you model a structured transaction containing multiple legs?
  9. What determines whether components belong in one transaction or linked transactions?
  10. How should product definitions be aligned with accounting treatment?
  11. How do product definitions affect risk-factor mapping?
  12. How should products be restricted by portfolio or business unit?
  13. How would you maintain product-definition ownership?
  14. What regression testing is required after changing an instrument configuration?
  15. How would you retire an obsolete product without affecting historical trades?
4. Parties, Legal Entities and Business Units20
  1. How does ETRM distinguish legal entities, counterparties and internal business units?
  2. What is the difference between a counterparty and a settlement entity?
  3. How should parent, subsidiary and credit-group relationships be represented?
  4. How would you model branches and booking entities?
  5. How should internal and external parties be distinguished?
  6. Which attributes are required to onboard a counterparty?
  7. How should counterparty status and eligibility be governed?
  8. How would you represent multiple trading agreements for one counterparty?
  9. How should agreement applicability be determined?
  10. How would you model guarantors and guarantee beneficiaries?
  11. How should credit-rating and classification data be maintained?
  12. How would you represent regulatory classifications?
  13. How should tax identifiers and jurisdictions be managed?
  14. What happens when two records represent the same legal entity?
  15. How would you identify and resolve duplicate counterparties?
  16. What controls should govern counterparty mergers or legal-name changes?
  17. How should historical transactions behave after a party hierarchy changes?
  18. How would you integrate ETRM with an enterprise party master?
  19. Which party attributes should ETRM consume, enrich or own?
  20. How would you reconcile party data across ETRM, CRM, credit and payment systems?
5. Organisational, Portfolio and Strategy Data20
  1. What is the purpose of an ETRM portfolio?
  2. How do portfolios, books, desks and strategies differ?
  3. How should portfolios align with legal ownership?
  4. How would you design a portfolio hierarchy for a global commodity business?
  5. How should trader and portfolio assignments be maintained?
  6. How do portfolio structures affect risk aggregation?
  7. How do they affect accounting and reporting?
  8. How should internal portfolios be distinguished from external-facing books?
  9. How would you represent hedging and commercial portfolios?
  10. How should dormant portfolios be retired?
  11. What risks arise from moving trades between portfolios?
  12. How should historical reporting treat portfolio transfers?
  13. How would you control the creation of new portfolios?
  14. How should organisational restructures be reflected?
  15. What data should drive desk and business-unit reporting?
  16. How would you avoid using free-text strategies as uncontrolled classifications?
  17. How should strategy hierarchies be versioned?
  18. How would you manage shared portfolios across regions?
  19. What controls prevent bookings into unauthorised portfolios?
  20. How would you reconcile ETRM's organisation hierarchy with enterprise finance hierarchies?
6. Commodity, Location and Product Reference Data20
  1. How would you design a commodity hierarchy?
  2. How should commodity, grade, quality and specification differ?
  3. How would you represent crude-oil grades?
  4. How should natural-gas hubs and delivery points be modelled?
  5. How would you represent power zones, nodes and interconnectors?
  6. How should LNG loading and discharge locations be maintained?
  7. How would you model emissions products by scheme and vintage?
  8. How should renewable certificates be classified?
  9. How would you represent metal brands, grades and warehouses?
  10. How should agricultural origin and quality attributes be modelled?
  11. What is the difference between a physical location and a pricing location?
  12. How should location hierarchies support aggregation?
  13. How would you represent transportation routes?
  14. How should storage facilities and inventory locations be maintained?
  15. What happens when a market location is renamed or retired?
  16. How should quality adjustments reference master data?
  17. How would you prevent commodity classifications from diverging across systems?
  18. Which attributes should form a commodity master record?
  19. How should new commodity products be approved?
  20. How would you migrate commodity and location data from a legacy ETRM?
7. Units of Measure and Conversions20
  1. Why are units of measure architecturally important in ETRM?
  2. How should volume, mass, energy and currency units be distinguished?
  3. What is the difference between static and context-dependent conversion?
  4. How would you convert barrels to metric tonnes?
  5. Why can density make oil conversions transaction-specific?
  6. How would you convert gas volume into energy?
  7. How do calorific value and standard conditions affect gas conversion?
  8. How should power quantities and rates be represented?
  9. How would you manage currency-per-unit price conventions?
  10. What is the difference between quantity, price and exposure units?
  11. How should trading, scheduling, risk and settlement units coexist?
  12. How would you avoid repeated or inconsistent conversions?
  13. How should conversion-factor sources be governed?
  14. How should effective dates apply to conversion factors?
  15. What rounding conventions should be controlled?
  16. How would you identify a unit mismatch causing incorrect valuation?
  17. How should converted values remain traceable to original quantities?
  18. How would you test unit conversions across products?
  19. What controls prevent users from selecting incompatible units?
  20. How should unit mappings be reconciled with external systems?
8. Calendars, Dates and Time Zones20
  1. What types of calendars are required in ETRM?
  2. How do trading, publication, delivery and payment calendars differ?
  3. How should business-day conventions be maintained?
  4. What is the difference between following, modified-following and preceding conventions?
  5. How should holidays affect pricing observations?
  6. How should holidays affect settlement dates?
  7. How would you manage regional calendar differences?
  8. What risks arise from changing an existing holiday calendar?
  9. How should calendar versions and effective dates be governed?
  10. How would you model gas days crossing calendar dates?
  11. How should power delivery intervals be represented?
  12. How would you handle 23-hour and 25-hour daylight-saving days?
  13. Why should timestamps include timezone context?
  14. How would you standardise timestamps across integrated platforms?
  15. How should publication time and fixing date differ?
  16. How would you represent valuation cut-off timestamps?
  17. What can cause apparent one-day differences across systems?
  18. How would you test leap years and month-end boundaries?
  19. How should historical results behave after a calendar correction?
  20. What controls should govern emergency calendar changes?
9. Market and Index Reference Data20
  1. What is an index definition in ETRM?
  2. Which attributes should an index contain?
  3. How do price source, index, fixing and curve differ?
  4. How would you represent exchange contracts and contract months?
  5. How should quotation units and currencies be maintained?
  6. How would you model index publication calendars?
  7. How should preliminary and final index values be distinguished?
  8. How would you handle corrected historical fixings?
  9. What is the relationship between an index and a forward curve?
  10. How should multiple vendors supplying the same index be represented?
  11. How would you design source-priority and fallback rules?
  12. How should proprietary and composite indexes be governed?
  13. How would you model an index formula using several components?
  14. How should discontinued indexes be replaced?
  15. What happens to historical transactions after an index is retired?
  16. How would you identify trades affected by an incorrect fixing?
  17. How should market-data identifiers map across vendors?
  18. What controls prevent values from being loaded against the wrong index?
  19. How would you manage timezone and publication-time differences?
  20. How should index-reference changes be regression-tested?
10. Settlement, Payment and Agreement Data20
  1. Which reference data drives settlement processing?
  2. How should standard settlement instructions be represented?
  3. How should instructions vary by legal entity, counterparty, currency and product?
  4. Why must bank-account data have stronger controls?
  5. How should settlement instructions be effective-dated?
  6. How would you manage temporary or one-time instructions?
  7. What should happen when multiple instructions are eligible?
  8. How should payment methods and message formats be maintained?
  9. How would you represent intermediary and correspondent banks?
  10. How should settlement netting agreements be modelled?
  11. What determines whether two cash flows can be netted?
  12. How should tax and invoice classifications be maintained?
  13. How would you model confirmation and invoice-document templates?
  14. How should collateral agreements connect to counterparties?
  15. How would you represent thresholds and minimum transfer amounts?
  16. How should agreement amendments affect existing transactions?
  17. How would you reconcile agreement data with legal-document systems?
  18. What controls prevent expired agreements from being applied?
  19. How would you test settlement-data changes safely?
  20. How should sensitive payment data be masked outside production?
11. Accounting Reference Data15
  1. Which reference-data domains drive accounting?
  2. How should account mappings be designed?
  3. How do product, portfolio, legal entity and event type influence accounting?
  4. How should accounting-event definitions be governed?
  5. How would you represent cost centres, profit centres and business dimensions?
  6. How should multiple ledgers or accounting standards be supported?
  7. How would you maintain effective-dated general-ledger mappings?
  8. What happens when an account mapping changes retrospectively?
  9. How should intercompany mappings be managed?
  10. How would you prevent incomplete accounting dimensions?
  11. How should accounting rules reference transaction attributes?
  12. What are the risks of embedding account numbers in custom scripts?
  13. How would you reconcile ETRM dimensions with the enterprise chart of accounts?
  14. How should new products be assessed for accounting-data requirements?
  15. How would you test that reference-data changes produce balanced postings?
12. User-Defined Fields and Extensibility15
  1. When should a user-defined field be introduced?
  2. What alternatives should be considered before creating one?
  3. How should field names and business definitions be governed?
  4. Which data type and validation rules should be selected?
  5. How should mandatory fields vary by product or lifecycle status?
  6. What risks arise from excessive custom fields?
  7. How would you prevent several fields representing the same concept?
  8. How should custom fields be exposed to integrations?
  9. How should they be included in reporting and lineage?
  10. How would you backfill a new field for existing transactions?
  11. How should field defaults be controlled?
  12. What happens when the meaning of a field changes?
  13. How would you retire an unused custom field?
  14. How should sensitive custom attributes be protected?
  15. What documentation and ownership should every custom field have?
13. Data Quality and Governance20
  1. What constitutes high-quality ETRM reference data?
  2. Which dimensions of data quality are most important?
  3. How would you define critical data elements?
  4. Who should own counterparty, commodity and market reference data?
  5. How do data owner and data steward responsibilities differ?
  6. How should data-quality rules be implemented?
  7. Which rules should block processing?
  8. How should non-blocking exceptions be managed?
  9. How would you establish data-quality thresholds?
  10. What should a reference-data control dashboard display?
  11. How should duplicate records be detected?
  12. How would you manage data-quality issue remediation?
  13. How should root causes be separated from symptoms?
  14. How would you measure the downstream impact of poor reference data?
  15. What is the role of data lineage in ETRM governance?
  16. How should business definitions be maintained?
  17. How would you manage conflicting definitions across functions?
  18. How should emergency data corrections be governed?
  19. What evidence should support periodic control review?
  20. How would you demonstrate regulatory compliance for critical data?
14. Integration and Synchronisation20
  1. How should reference data enter ETRM?
  2. When should synchronisation be real-time or batch-based?
  3. How would you implement idempotent reference-data ingestion?
  4. How should enterprise and ETRM identifiers be mapped?
  5. What happens when dependent records arrive out of sequence?
  6. How would you manage partial synchronisation failure?
  7. How should records rejected by ETRM be handled?
  8. What reconciliation controls should accompany reference-data interfaces?
  9. How would you distribute ETRM-owned data downstream?
  10. How should change events differ from full snapshots?
  11. How would you handle deleted, merged or retired records?
  12. How should effective dates be preserved across systems?
  13. How would you prevent update loops between two authoritative systems?
  14. What should happen when source and target disagree?
  15. How should interface schemas be versioned?
  16. How would you protect personally identifiable and payment information?
  17. How should data lineage span integration boundaries?
  18. How would you monitor synchronisation latency?
  19. How should reference-data cutovers be coordinated?
  20. What makes a reference-data interface operationally supportable?
15. Migration and Reconciliation20
  1. How would you profile legacy data before an ETRM migration?
  2. How should source-to-target mappings be documented?
  3. How would you identify missing reference-data dependencies?
  4. What is the difference between cleansing, standardisation and enrichment?
  5. How should duplicate parties and products be resolved?
  6. How would you preserve legacy identifiers?
  7. How should historical and active transactions be treated differently?
  8. How would you sequence reference and transaction-data migration?
  9. What happens when source values have no valid ETRM equivalent?
  10. How should default values be governed?
  11. How would you validate migrated transaction economics?
  12. What control totals should be reconciled?
  13. How would you compare positions, cash flows, P&L and events?
  14. How should rejected records be tracked and resolved?
  15. How would you perform iterative migration rehearsals?
  16. What determines whether a migration defect blocks go-live?
  17. How should delta migration be managed near cut-over?
  18. How would you prevent duplicate downstream events after migration?
  19. What evidence should support migration sign-off?
  20. How should legacy data remain accessible after decommissioning?
16. Performance, Retention and Archiving15
  1. How can poor data modelling affect ETRM performance?
  2. What risks arise from uncontrolled transaction-level attributes?
  3. How can large profiles affect valuation and reporting?
  4. How would you identify rapidly growing data domains?
  5. Which data should be retained online?
  6. How should archival requirements be defined?
  7. How would you archive data without breaking auditability?
  8. How should archived transactions remain searchable?
  9. What legal or regulatory requirements affect retention?
  10. How should simulation results be retained?
  11. When should results be recalculated rather than stored?
  12. How would you prevent analytical workloads from overloading ETRM?
  13. What role should an enterprise data platform play?
  14. How should deletion and anonymisation requirements be handled?
  15. How would you test data archival and restoration?
17. Architecture Scenarios20
  1. A trade values correctly but appears under the wrong desk. What would you inspect?
  2. Two counterparties represent the same legal entity. How would you remediate them?
  3. A unit conversion causes a thousandfold exposure difference. How would you isolate it?
  4. A calendar change alters historical settlement dates. How should it be handled?
  5. A transaction uses a retired index. What remediation options exist?
  6. A portfolio restructure changes historical P&L reporting. How would you preserve both views?
  7. A settlement instruction is valid but selects the wrong bank account. What could cause this?
  8. An upstream party master merges counterparties that ETRM must keep distinct. How would you respond?
  9. A new custom field duplicates an existing reference-data concept. Would you approve it?
  10. An integration sends reference data after dependent transactions. How should processing recover?
  11. Test and production contain different reference-data identifiers. How would you manage deployment?
  12. A fixing was loaded against the wrong index and used for invoicing. What remediation is required?
  13. Historical valuation changes after a unit-conversion update. What design weakness does this expose?
  14. Direct database reporting breaks after an upgrade. What architectural mistake was made?
  15. Several systems claim ownership of commodity reference data. How would you establish authority?
  16. A transaction migration balances by count but not by exposure. What should be reconciled next?
  17. A user requests direct database correction of a counterparty record. How would you respond?
  18. Data-quality controls generate thousands of unresolved warnings. How would you redesign them?
  19. A physical location and pricing location were treated as the same concept. What problems can result?
  20. What distinguishes an ETRM data architect from a database administrator or data modeller?
Integration Architecture and APIs17 sections · 340 questions
1. Integration Architecture Fundamentals20
  1. What are the major integration patterns used around ETRM?
  2. How would you define ETRM's integration boundaries?
  3. Which capabilities should remain inside ETRM?
  4. Which capabilities should be provided by external platforms?
  5. How do synchronous, asynchronous, batch and streaming integrations differ?
  6. When is request-response integration appropriate?
  7. When should a durable queue be preferred?
  8. When is file-based integration still appropriate?
  9. Why should direct database integration generally be avoided?
  10. How would you assess an existing ETRM integration landscape?
  11. What belongs in an integration architecture document?
  12. How would you create a system-context diagram?
  13. What makes an integration business-critical?
  14. How should integration ownership be divided between teams?
  15. How would you prevent point-to-point integration sprawl?
  16. What factors determine an interface's delivery pattern?
  17. How should business and technical contracts be separated?
  18. What non-functional requirements should be agreed before design?
  19. How would you calculate interface capacity requirements?
  20. What distinguishes connectivity from complete business integration?
2. ETRM Integration Mechanisms20
  1. What supported integration mechanisms are available for ETRM?
  2. What is OpenComponents, and where is it appropriate?
  3. How does an API-based integration differ from an the platform scripting language process?
  4. When should ETRM scripting participate in integration?
  5. When should integration logic remain in middleware?
  6. What are the risks of embedding orchestration in scripts?
  7. When can controlled file exchange be preferable to an API?
  8. How should ETRM-generated reports participate in outbound interfaces?
  9. What is the role of workflow or transaction-processing capabilities?
  10. How would you evaluate a vendor-supplied connector?
  11. How do ETRM-version dependencies affect API consumers?
  12. How would you avoid coupling consumers to ETRM's internal objects?
  13. How should supported and unsupported interfaces be distinguished?
  14. What governance is required before introducing a new connector?
  15. How would you select the correct mechanism for high-volume trade ingestion?
  16. Which mechanism would you choose for low-latency position retrieval?
  17. How would you publish settlement events reliably?
  18. How should bulk reference-data loads be handled?
  19. When is database extraction acceptable for analytics?
  20. How would you prove that an integration is upgrade-safe?
3. API Design25
  1. How would you design an API for trade creation?
  2. Which fields should be mandatory in a trade API?
  3. Should the API expose ETRM's internal transaction structure directly?
  4. How would you design a canonical trade model?
  5. How should product-specific fields be represented?
  6. How would you handle optional and conditionally mandatory fields?
  7. What is the difference between technical and business validation?
  8. Which validation belongs at the API gateway?
  9. Which validation belongs within ETRM?
  10. How should validation errors be returned?
  11. How would you design an API for trade amendment?
  12. Should amendments use complete replacement or patch semantics?
  13. How should cancellations and terminations be represented?
  14. How would you retrieve current transaction status?
  15. How should API pagination be designed?
  16. How would you support large result sets?
  17. How should filtering and sorting be constrained?
  18. How would you prevent APIs from creating expensive database workloads?
  19. What information should a response envelope contain?
  20. How should correlation and request identifiers be represented?
  21. How would you version an API?
  22. When is a breaking version necessary?
  23. How should deprecated versions be retired?
  24. How would you maintain backward compatibility?
  25. What makes an API operationally supportable?
4. Canonical Data Models and Mapping20
  1. What is a canonical data model?
  2. When does a canonical model reduce integration complexity?
  3. When can it become an unnecessary abstraction?
  4. How would you map external products to ETRM instruments?
  5. How should counterparties and legal entities be mapped?
  6. How would you map books, portfolios, traders and strategies?
  7. How should units, currencies, indexes and locations be mapped?
  8. Where should cross-reference mappings be stored?
  9. How should mappings be effective-dated?
  10. What happens when one source value maps to several ETRM values?
  11. How would you manage unmapped values?
  12. Should interfaces silently apply default values?
  13. How would you represent multi-leg transactions?
  14. How should daily or hourly profiles be transmitted?
  15. How would you represent provisional pricing?
  16. How should lifecycle relationships be preserved?
  17. How would you map parent, child and allocation transactions?
  18. How should source-system identifiers survive migration?
  19. What controls should validate mapping completeness?
  20. How would you prevent different interfaces from implementing inconsistent mappings?
5. Synchronous Integration15
  1. When should an ETRM interface be synchronous?
  2. What response time should a synchronous trade API provide?
  3. How should timeouts be selected?
  4. What does a timeout mean when ETRM may have completed processing?
  5. How would you resolve an indeterminate transaction outcome?
  6. Why is blindly retrying a timed-out create request dangerous?
  7. How should idempotency work for synchronous requests?
  8. Where should idempotency keys be stored?
  9. How long should an idempotency record remain valid?
  10. How would you prevent duplicate execution across service instances?
  11. What happens when ETRM is temporarily unavailable?
  12. How should connection pools be configured?
  13. How would you apply throttling and back-pressure?
  14. How should synchronous dependencies be limited?
  15. When should a synchronous request be converted into an asynchronous job?
6. Messaging and Event-Driven Integration25
  1. When should messaging be used around ETRM?
  2. What is the difference between a command, event and notification?
  3. Should a trade-capture message be treated as a command or event?
  4. How would you design a durable trade-ingestion queue?
  5. What delivery semantics can messaging platforms provide?
  6. Why does “exactly once” require business-level design?
  7. How would you achieve effectively-once processing?
  8. How should message keys be selected?
  9. How would you preserve ordering for a transaction?
  10. Is global message ordering necessary?
  11. How would you process unrelated transactions concurrently?
  12. What happens when an amendment arrives before the original trade?
  13. How should delayed or out-of-order events be managed?
  14. What is a dead-letter queue?
  15. What information should a dead-letter record contain?
  16. How should dead-letter messages be reprocessed?
  17. How would you prevent replay from creating duplicate actions?
  18. How should message retention be determined?
  19. What is consumer lag, and why does it matter?
  20. How should message schemas evolve?
  21. How would Kafka fit into an ETRM architecture?
  22. When might a conventional message queue be preferable to Kafka?
  23. How would you handle poison messages?
  24. How should event consumers indicate processing success?
  25. What reconciliation remains necessary despite reliable messaging?
7. Trade Capture Integration20
  1. How would you integrate an execution platform with ETRM?
  2. Which system should assign the authoritative execution identifier?
  3. How should ETRM deal numbers be returned to the source?
  4. How would you handle block trades and allocations?
  5. What happens when allocation arrives after the block?
  6. How should partial allocations be handled?
  7. How would you process corrected or busted exchange trades?
  8. How should execution versions be represented?
  9. How would you detect duplicate executions?
  10. Which fields should be compared for duplicate detection?
  11. How should trade economics be validated before booking?
  12. How would you manage product mappings?
  13. What happens when required reference data is unavailable?
  14. Should invalid trades be rejected or quarantined?
  15. How should quarantined trades be corrected?
  16. How would you preserve the original message?
  17. How should manual intervention be audited?
  18. How would you prove that every execution reached ETRM?
  19. How should execution and ETRM status differences be reconciled?
  20. How would you design cut-off handling for late trades?
8. Market and Reference-Data Integration20
  1. How would you integrate market-data vendors with ETRM?
  2. How should real-time and end-of-day data flows differ?
  3. How would you validate incoming prices and rates?
  4. How should stale or missing data be detected?
  5. How would you manage multiple sources for the same index?
  6. How should source priority and fallback operate?
  7. How would you ingest corrected fixings?
  8. How should the original fixing remain traceable?
  9. What happens when a correction arrives after settlement?
  10. How would you prevent data being loaded against the wrong index?
  11. How should price units and currencies be validated?
  12. How would you integrate an enterprise party master?
  13. How should merged or retired counterparties be handled?
  14. How would you synchronise product and location master data?
  15. What happens when a dependent transaction arrives before reference data?
  16. How would you avoid update loops between master systems?
  17. How should effective dates be transmitted?
  18. How would you reconcile reference data?
  19. What service levels should apply to critical market data?
  20. How should licensing restrictions affect data distribution?
9. Outbound Events and Data Distribution20
  1. Which ETRM changes should generate outbound events?
  2. Should consumers receive transaction snapshots or change events?
  3. What are the advantages of a transactional outbox pattern?
  4. How would you ensure that a committed ETRM change is published?
  5. What happens if database processing succeeds but event publication fails?
  6. How should transaction amendments be represented?
  7. How should cancellations and reversals be published?
  8. What event should represent a status transition?
  9. How would you preserve event ordering?
  10. How should event identifiers be generated?
  11. How would consumers detect duplicates?
  12. How should consumers recover missing events?
  13. When should a complete snapshot be republished?
  14. How would you support event replay?
  15. How should replayed events be distinguished from new business activity?
  16. How would you prevent sensitive fields from leaving ETRM?
  17. How should consumers be authorised by data domain?
  18. How would you publish positions and P&L?
  19. Should calculated results be events, snapshots or query responses?
  20. How would you communicate corrected historical results?
10. Settlement, Payment and Accounting Interfaces20
  1. How would you publish settlement instructions from ETRM?
  2. What controls should surround payment-file generation?
  3. How would you prevent duplicate payment instructions?
  4. Which system should own payment status?
  5. How should bank acknowledgements return to ETRM?
  6. How would you process rejected payments?
  7. How should payment cancellation and recall be represented?
  8. How would you reconcile ETRM with a treasury platform?
  9. How would invoices be transmitted to an external billing system?
  10. How should invoice corrections and credit notes be communicated?
  11. How would you integrate ETRM accounting with a general ledger?
  12. What information should accompany an accounting posting?
  13. How should rejected journal entries be handled?
  14. How would you prevent duplicate general-ledger postings?
  15. How should accounting periods and cut-offs be aligned?
  16. How would you reconcile the ETRM subledger with the general ledger?
  17. What control totals should accompany accounting interfaces?
  18. How should partial interface completion be handled?
  19. How would you restart processing without duplicating outputs?
  20. What evidence is required for financial-control sign-off?
11. File-Based and Batch Integration20
  1. When is file-based integration appropriate?
  2. What controls should accompany every file?
  3. How should file names and business dates be defined?
  4. How would you detect missing files?
  5. How should duplicate files be detected?
  6. What are control totals and hash totals?
  7. How would you validate file completeness?
  8. How should partial files be prevented from processing?
  9. What is an atomic file-delivery pattern?
  10. How should encryption and signing be applied?
  11. How would you manage large files?
  12. What happens when individual records fail?
  13. Should valid records proceed when some records fail?
  14. How should rejected records be returned?
  15. How would you restart a failed batch?
  16. How should file retention be governed?
  17. How would you handle reruns for an earlier business date?
  18. How should time zones and cut-offs be managed?
  19. How would you reconcile file processing end-to-end?
  20. When should a file interface be replaced with an API or event stream?
12. Security and API Management20
  1. How would you authenticate systems calling ETRM APIs?
  2. How does authentication differ from authorisation?
  3. When should mutual TLS be used?
  4. How should service identities be managed?
  5. Where should API credentials and secrets be stored?
  6. How should credentials be rotated?
  7. What data should never appear in logs?
  8. How would you protect bank-account and counterparty data?
  9. How should API scopes be designed?
  10. How would you enforce least privilege?
  11. What is the role of an API gateway?
  12. How should rate limits be established?
  13. How would you protect ETRM from denial-of-service conditions?
  14. How should inbound payloads be validated?
  15. How would you prevent injection and deserialisation attacks?
  16. How should certificates be monitored for expiry?
  17. How would you audit API access?
  18. How should non-production interfaces handle production data?
  19. What controls should apply to privileged support access?
  20. How would you respond to a compromised service credential?
13. Error Handling, Recovery and Reconciliation20
  1. What error categories should an interface define?
  2. How do business, validation, technical and dependency errors differ?
  3. Which failures are safe to retry?
  4. How should exponential back-off be applied?
  5. When should retry attempts stop?
  6. What is a retry storm?
  7. How would circuit breakers protect ETRM?
  8. How should failed requests be quarantined?
  9. What information is necessary for investigation?
  10. How should operational users correct errors?
  11. How would corrected records re-enter processing?
  12. How should manual changes be audited?
  13. What is end-to-end reconciliation?
  14. Why are transport acknowledgements insufficient?
  15. How would you reconcile counts, quantities, amounts and statuses?
  16. How should reconciliation breaks be assigned and aged?
  17. How would you detect silent data loss?
  18. How should a recovered interface process accumulated backlog?
  19. How would you prioritise messages after an outage?
  20. How would you prove that recovery caused no duplication or omission?
14. Performance, Scalability and Availability20
  1. How would you estimate interface throughput?
  2. Which volume characteristics matter beyond average transactions per second?
  3. How would you test peak-volume behaviour?
  4. How should large profiles and structured trades affect sizing?
  5. How would you prevent integration workloads from degrading ETRM?
  6. What is back-pressure?
  7. How should queues absorb traffic spikes?
  8. When should consumers scale horizontally?
  9. What can limit horizontal scaling?
  10. How would transaction ordering affect concurrency?
  11. How should connection pooling be configured?
  12. What causes excessive API latency?
  13. How would you isolate network, middleware, ETRM and database latency?
  14. How should service-level indicators be defined?
  15. What availability level should a critical interface provide?
  16. How would you design interface failover?
  17. What happens to in-flight requests during failover?
  18. How would disaster recovery preserve message consistency?
  19. How should recovery-point objectives apply to integrations?
  20. How would you test interface resilience?
15. Monitoring and Observability15
  1. What should an integration-monitoring dashboard display?
  2. Which technical and business metrics should be monitored?
  3. How should correlation identifiers be propagated?
  4. How would you trace a trade across execution, middleware and ETRM?
  5. What logs should be generated at each stage?
  6. How should logs avoid exposing sensitive data?
  7. What is distributed tracing?
  8. How could tracing help with ETRM integrations?
  9. How would you detect a consumer that is alive but not processing?
  10. What thresholds should trigger alerts?
  11. How would you reduce false-positive alerts?
  12. How should business cut-off breaches be detected?
  13. What data should support service-level reporting?
  14. How would you distinguish backlog from processing failure?
  15. How should support teams access replay and reconciliation tools?
16. Testing and Release Management20
  1. What should an ETRM integration test strategy cover?
  2. How do unit, component, contract and end-to-end tests differ?
  3. What is consumer-driven contract testing?
  4. How would you test API compatibility?
  5. How should external dependencies be mocked?
  6. When is a production-like environment necessary?
  7. How would you create representative test data?
  8. How would you test duplicates and message reordering?
  9. How would you test timeouts and indeterminate outcomes?
  10. How should retry and dead-letter processing be tested?
  11. How would you test partial batch failure?
  12. How should failover and disaster recovery be tested?
  13. How would you conduct volume and soak testing?
  14. How should reconciliations be tested?
  15. What evidence is required before production release?
  16. How should interface configuration move between environments?
  17. How would you detect configuration drift?
  18. How should breaking changes be coordinated with consumers?
  19. What rollback options exist after messages have been processed?
  20. What conditions should prevent an integration release?
17. Integration Architecture Scenarios20
  1. An API times out, but ETRM creates the trade. How should the caller recover?
  2. A retry creates a duplicate transaction. What architectural control was missing?
  3. Amendments arrive before original trades. How would you redesign processing?
  4. Kafka reports successful delivery, but ETRM contains no trade. What should be reconciled?
  5. ETRM commits a transaction but fails to publish its outbound event. How would you recover?
  6. A reference-data message arrives after the dependent trade. What should happen?
  7. An upstream system reuses an execution identifier. How would you handle it?
  8. A queue backlog threatens the trading cut-off. How would you prioritise recovery?
  9. An interface works in testing but overloads production. What assumptions likely failed?
  10. A direct database extract breaks after an legacy-to-modern ETRM upgrade. What design flaw does this expose?
  11. An external system requires ETRM internal field names in its contract. Would you approve this?
  12. Two consumers require incompatible versions of the same event. How would you support them?
  13. A payment interface replay creates duplicate bank instructions. How would you prevent this?
  14. Middleware modifies trade economics without retaining the original message. What risks arise?
  15. A market-data vendor republishes corrected history. How should corrections enter ETRM?
  16. Interface counts reconcile, but commodity quantities do not. What should be investigated?
  17. A service account can create trades in every portfolio. What control weakness exists?
  18. Operations repeatedly edits failed messages directly in the queue. How would you improve control?
  19. The business demands exactly-once processing. How would you translate that requirement?
  20. What distinguishes an ETRM Integration Architect from an API developer or middleware specialist?
Extensibility with Custom Code19 sections · 375 questions
1. Extensibility Strategy20
  1. When should standard ETRM functionality be used without customisation?
  2. When is configuration preferable to code?
  3. When is the platform scripting language appropriate?
  4. When is Java preferable to the platform scripting language?
  5. When should functionality be implemented outside ETRM?
  6. How would you evaluate a custom-development request?
  7. What questions should be answered before approving an extension?
  8. How would you calculate the lifecycle cost of customisation?
  9. What makes an extension upgrade-sensitive?
  10. How would you prevent ETRM becoming a bespoke application?
  11. What is the difference between extension and modification?
  12. Why should supported APIs be preferred?
  13. How would you identify customisations duplicating standard functionality?
  14. What architecture principles should govern extensions?
  15. How would you document an extensibility decision?
  16. What belongs in an architecture decision record?
  17. How should business criticality influence implementation choice?
  18. When is a tactical script acceptable?
  19. How should tactical components be retired?
  20. What would make you reject a customisation request?
2. the platform scripting language Fundamentals20
  1. What is the platform scripting language?
  2. What types of ETRM processes commonly use the platform scripting language?
  3. How does an the platform scripting language script execute within the ETRM environment?
  4. What is the conventional entry point of an the platform scripting language script?
  5. What role does `com.olf.openjvs` play?
  6. How are ETRM objects accessed from the platform scripting language?
  7. How does the platform scripting language differ from general-purpose Java development?
  8. What limitations should an architect understand?
  9. How should the platform scripting language scripts be classified by purpose?
  10. Which scripts should run interactively?
  11. Which scripts should run as background services?
  12. Which scripts are suitable for scheduled processing?
  13. How does execution context affect script behaviour?
  14. How should user and service-account context be handled?
  15. How can a script obtain runtime parameters?
  16. How should a script return execution status?
  17. What should happen when required parameters are missing?
  18. How do API-version differences affect scripts?
  19. How would you assess an unfamiliar the platform scripting language codebase?
  20. What signs indicate poor the platform scripting language design?
3. the platform scripting language Table Handling20
  1. What is the platform scripting language `Table` object?
  2. Why is `Table` central to many the platform scripting language solutions?
  3. How do ETRM tables differ from Java collections?
  4. How should columns and rows be defined?
  5. How would you populate a table efficiently?
  6. What risks arise from repeated row insertion?
  7. How would you access values safely?
  8. How should null, empty and invalid values be distinguished?
  9. How would you join or aggregate tables?
  10. When should table operations be performed in memory?
  11. When should processing be pushed to the database?
  12. How would you copy or clone a table?
  13. What risks arise from unintended table references?
  14. How should temporary tables be managed?
  15. Why must table objects be destroyed?
  16. What happens when tables are not destroyed?
  17. How would you guarantee cleanup after an exception?
  18. How should very large result sets be processed?
  19. How would you avoid excessive table copying?
  20. How would you diagnose table-related memory growth?
4. Transactions and Deal Processing20
  1. How does the platform scripting language access an ETRM transaction?
  2. How would you retrieve a transaction safely?
  3. How should new transactions be created?
  4. What validation should occur before saving a transaction?
  5. How would you distinguish business validation from technical validation?
  6. How should transaction status transitions be controlled?
  7. What risks arise from scripts changing validated transactions?
  8. How would you process trade amendments?
  9. How should cancellations, terminations and novations be handled?
  10. How would you preserve external identifiers?
  11. How should duplicate trade creation be prevented?
  12. How would you design idempotent transaction processing?
  13. How should parent-child trade relationships be maintained?
  14. How would you process multi-leg transactions?
  15. How should transaction profiles be populated?
  16. How would you manage unit, currency and index mappings?
  17. What happens when required reference data is unavailable?
  18. How should partial bulk-processing failure be handled?
  19. When should one invalid trade prevent the entire batch?
  20. How would you reconcile script-created trades with source records?
5. Query and Database Access20
  1. How should the platform scripting language retrieve data from the ETRM database?
  2. What is the role of supported query APIs?
  3. Why are direct database writes prohibited?
  4. What risks arise from direct table updates?
  5. When can controlled database reads be acceptable?
  6. How would you parameterise database queries?
  7. How would you prevent SQL injection?
  8. Why should dynamic SQL be minimised?
  9. How would you avoid retrieving unnecessary columns?
  10. How would you process large database result sets?
  11. What is the impact of repeated database calls inside loops?
  12. How would you replace row-by-row queries?
  13. How should database transactions be handled?
  14. How would you avoid long-running locks?
  15. How should user tables be used?
  16. When is a user table preferable to a configuration file?
  17. How should user-table schemas be governed?
  18. How would you migrate user-table changes?
  19. What risks arise when custom tables imitate core ETRM data?
  20. How would you diagnose a script causing database contention?
6. Error and Exception Handling20
  1. What exception types should an the platform scripting language solution anticipate?
  2. How should `OException` be handled?
  3. Should scripts catch every exception?
  4. When should an exception be rethrown?
  5. How should business exceptions differ from technical failures?
  6. How would you define recoverable and unrecoverable errors?
  7. What should a script do after partial processing?
  8. How would you guarantee resource cleanup?
  9. How should contextual information be added to errors?
  10. What information should never appear in error messages?
  11. How would you prevent exception handling from hiding failures?
  12. Should a script continue after one record fails?
  13. How should rejected records be quarantined?
  14. How would operational users correct and replay failures?
  15. How should retry logic be designed?
  16. When can retrying be dangerous?
  17. How would you prevent retry storms?
  18. How should fatal errors affect batch status?
  19. What evidence should be retained after failure?
  20. How would you test exception paths?
7. Logging and Observability20
  1. What should an the platform scripting language logging standard contain?
  2. Which logging levels should be supported?
  3. What belongs in informational versus debug logging?
  4. How would you avoid excessive production logging?
  5. How should correlation identifiers be used?
  6. How would you trace one trade through several scripts?
  7. What transaction and batch identifiers should be logged?
  8. How should sensitive data be masked?
  9. Why should passwords, tokens and bank details never be logged?
  10. How would you record processing counts and control totals?
  11. What execution-duration metrics should be captured?
  12. How would you identify the slowest processing stage?
  13. How should script health be monitored?
  14. How would you detect a script that is running but making no progress?
  15. What alerts should a business-critical script generate?
  16. How should log retention be governed?
  17. How would production support access diagnostic information?
  18. How should logging differ between development and production?
  19. How would you correlate application and middleware logs?
  20. What observability requirements belong in the original design?
8. Java Extensibility20
  1. When should compiled Java be selected over the platform scripting language?
  2. What benefits does Java provide for larger components?
  3. What additional risks accompany compiled extensions?
  4. How should a Java extension interact with supported ETRM APIs?
  5. How would you structure a Java codebase?
  6. How should domain, application and infrastructure logic be separated?
  7. How would you manage third-party libraries?
  8. What risks arise from dependency conflicts?
  9. How should class-loading constraints influence design?
  10. How would you prevent library-version collisions?
  11. How should configuration be externalised?
  12. How would you manage environment-specific values?
  13. How should thread safety be handled?
  14. Can every ETRM API object be safely shared across threads?
  15. What risks arise from unmanaged multithreading?
  16. How would you manage connection pools?
  17. How should long-running Java services manage memory?
  18. How would you diagnose garbage-collection pressure?
  19. How should Java components expose operational health?
  20. What makes a Java component supportable by an ETRM operations team?
9. Plug-ins, Hooks and Workflow Extensions20
  1. What extension points can invoke custom logic?
  2. When should logic run during trade capture?
  3. What validation is appropriate before trade save?
  4. What logic should not run synchronously in the user session?
  5. How would a slow validation affect trader experience?
  6. How should post-trade processing be triggered?
  7. How would you prevent the same event invoking logic twice?
  8. How should hooks behave when dependent services are unavailable?
  9. What risks arise from placing external calls inside transaction processing?
  10. How would you decouple long-running processing?
  11. How should workflow extensions preserve state?
  12. How would you design restartable steps?
  13. How should manual exceptions rejoin automated workflows?
  14. How would you prevent recursion or repeated event triggering?
  15. How should workflow timeouts be managed?
  16. What auditing should surround approval logic?
  17. How would you test extensions invoked by lifecycle events?
  18. How should extension execution order be governed?
  19. How would you identify conflicting hooks?
  20. When should orchestration be moved to an external workflow platform?
10. Report and Simulation Extensions20
  1. How would the platform scripting language support custom reporting?
  2. When should a report use standard result measures?
  3. When is a custom result calculation justified?
  4. How should custom results remain reconcilable with ETRM?
  5. What risks arise from recalculating valuation logic inside reports?
  6. How would you process simulation results efficiently?
  7. How should large portfolio results be partitioned?
  8. How would you avoid loading unnecessary measures?
  9. How should report filters and parameters be validated?
  10. How would you preserve valuation scenario and as-of context?
  11. How should reports handle missing results?
  12. How would you identify incomplete portfolio processing?
  13. How should results be published downstream?
  14. What control totals should accompany extracts?
  15. How would you prevent reporting from degrading production?
  16. When should reporting move to an enterprise data platform?
  17. How would you test custom result calculations?
  18. How should rounding and aggregation be governed?
  19. How would you manage report-version changes?
  20. How should historical report reproducibility be demonstrated?
11. Integration Components20
  1. How would you implement inbound trade processing using the platform scripting language or Java?
  2. Should transport logic and trade-booking logic reside in the same component?
  3. How would you validate inbound messages?
  4. How should source-system identifiers be stored?
  5. How would you implement idempotency?
  6. What happens when ETRM saves the trade but acknowledgement fails?
  7. How should indeterminate outcomes be resolved?
  8. How would you process out-of-order amendments?
  9. How should reference-data dependencies be handled?
  10. How would you publish outbound events?
  11. What risks arise from publishing before transaction commit?
  12. How could an outbox-style pattern improve reliability?
  13. How should failed messages be quarantined?
  14. How would you support controlled replay?
  15. How should interface schemas be versioned?
  16. How would you protect ETRM from excessive request volume?
  17. How should connection and API timeouts be configured?
  18. How would you prevent duplicated payment or accounting output?
  19. What reconciliation should accompany integration code?
  20. When should integration be delegated to middleware?
12. Performance Engineering20
  1. What commonly makes an the platform scripting language script slow?
  2. How would you establish a performance baseline?
  3. How would you profile script execution?
  4. How would you identify expensive database operations?
  5. Why are database calls inside loops problematic?
  6. How should batch operations replace row-by-row processing?
  7. How can excessive table operations affect performance?
  8. How would you minimise object creation?
  9. When should processing be partitioned?
  10. How would you select partition keys?
  11. What limits safe parallel processing?
  12. How can parallel scripts create database contention?
  13. Why might increasing worker count reduce throughput?
  14. How would you protect interactive users from background workloads?
  15. How should large transaction profiles be handled?
  16. How would you test peak-volume behaviour?
  17. What is soak testing?
  18. How would you identify gradual memory degradation?
  19. How should performance regressions be detected?
  20. How would you verify that optimisation has not changed business results?
13. Secure Coding20
  1. What secure-coding standards should apply?
  2. How should scripts authenticate to external services?
  3. Where should credentials and secrets be stored?
  4. How should secrets be rotated?
  5. Why should credentials never be embedded in code?
  6. How would you validate untrusted input?
  7. How would you prevent SQL injection?
  8. How should file paths and file names be validated?
  9. How would you prevent unauthorised file access?
  10. How should outbound URLs and endpoints be controlled?
  11. How would you protect against malicious payloads?
  12. How should personally identifiable information be handled?
  13. How would you restrict script execution?
  14. What permissions should service accounts possess?
  15. How should privileged actions be audited?
  16. How would you scan dependencies for vulnerabilities?
  17. How should third-party libraries be approved?
  18. How would you respond to a vulnerable dependency?
  19. What security testing should precede release?
  20. How should production data be protected in lower environments?
14. Testing Strategy20
  1. How would you unit-test the platform scripting language code?
  2. Which logic should be isolated from ETRM APIs?
  3. How can wrapper or adapter patterns improve testability?
  4. How would you mock ETRM dependencies?
  5. What should component testing cover?
  6. How does integration testing differ from unit testing?
  7. What belongs in regression testing?
  8. How would you create representative transaction test cases?
  9. How should boundary dates and calendars be tested?
  10. How would you test 23-hour and 25-hour power-delivery days?
  11. How should negative prices and zero quantities be tested?
  12. How would you test large profiles?
  13. How should duplicate and out-of-order messages be tested?
  14. How would you test partial processing failure?
  15. How should restart and replay be tested?
  16. How would you validate memory cleanup?
  17. How should concurrency problems be tested?
  18. What results should be reconciled before release?
  19. How would you automate ETRM regression testing?
  20. What test evidence is required for production approval?
15. Source Control and Build Management20
  1. What should be stored in source control?
  2. How should an the platform scripting language repository be structured?
  3. How would you version scripts?
  4. How should branches and releases be managed?
  5. What coding standards should be enforced automatically?
  6. How would you introduce static analysis?
  7. What should a continuous-integration pipeline perform?
  8. How should compiled Java artifacts be built?
  9. How should dependencies be pinned?
  10. How would you ensure reproducible builds?
  11. How should artifact integrity be verified?
  12. How should environment-specific configuration be injected?
  13. How would you package related scripts and user-table changes?
  14. How should deployment dependencies be declared?
  15. How would you prevent unreviewed code reaching production?
  16. What information should a release manifest contain?
  17. How should database changes accompany code changes?
  18. How would you handle concurrent changes from multiple teams?
  19. What is the correct process for an emergency fix?
  20. How should production fixes return to the main development branch?
16. Deployment and Configuration Management20
  1. How should the platform scripting language scripts be promoted between environments?
  2. How should compiled Java components be deployed?
  3. What pre-deployment checks are required?
  4. How would you detect missing dependencies?
  5. How should deployment order be determined?
  6. What services may require restart?
  7. How would you minimise deployment downtime?
  8. How should backward compatibility support rolling deployment?
  9. What post-deployment smoke tests are required?
  10. How would you verify the deployed version?
  11. What operational monitoring should follow deployment?
  12. How would you roll back a script?
  13. When is rollback unsafe?
  14. What if new transactions were processed by the faulty version?
  15. How should data remediation accompany rollback?
  16. How would you detect environment drift?
  17. How should configuration values be compared across environments?
  18. What evidence should support release sign-off?
  19. What conditions should stop deployment?
  20. How should deployment ownership be divided?
17. Upgrade and Technical-Debt Management20
  1. How would you assess custom code before an legacy-to-modern ETRM upgrade?
  2. How should API usage be inventoried?
  3. How would you identify deprecated functions?
  4. What risks arise from undocumented customisations?
  5. How should binary and source dependencies be assessed?
  6. How would you compile and test Java components against the target version?
  7. Which scripts require full regression testing?
  8. How would you compare pre-upgrade and post-upgrade results?
  9. How should legitimate behavioural differences be documented?
  10. How would you measure customisation-related technical debt?
  11. Which components should be refactored before upgrading?
  12. When should a customisation be replaced by new standard functionality?
  13. How would you retire unused scripts safely?
  14. How should ownership of legacy code be established?
  15. How would you manage custom code with no source repository?
  16. What documentation is required for business-critical extensions?
  17. How should technical-debt remediation be prioritised?
  18. How would you prevent new debt during an upgrade?
  19. What would block upgrade approval?
  20. How should post-upgrade customisation performance be validated?
18. Code Review Questions15
  1. What do you examine first in an unfamiliar the platform scripting language script?
  2. How would you identify resource leaks?
  3. How would you detect unsafe database access?
  4. What indicates poor transaction handling?
  5. How would you identify hidden environment dependencies?
  6. What signs suggest excessive coupling?
  7. How would you identify duplicated business logic?
  8. What makes exception handling inadequate?
  9. How would you assess logging quality?
  10. How would you identify scalability risks?
  11. What indicates that code should be externalised?
  12. How would you review user-table usage?
  13. How would you assess thread-safety assumptions?
  14. What evidence should support a code-review approval?
  15. How should critical findings be tracked to closure?
19. Architecture Scenarios20
  1. A script works interactively but fails under a service account. What would you check?
  2. A long-running the platform scripting language process consumes increasing memory. What is the likely investigation path?
  3. A bulk trade loader creates duplicates after timeout. How would you redesign it?
  4. A script performs one database query per transaction. What should replace this pattern?
  5. A hook calls an external API while saving a trade. What risks does this create?
  6. A validation script adds several seconds to every trade. How would you improve it?
  7. An exception is logged, but the batch reports success. What design failure exists?
  8. A script catches every exception and continues processing. Why is this dangerous?
  9. A Java extension introduces incompatible library versions. How would you resolve it?
  10. A production script contains hard-coded portfolio identifiers. What should change?
  11. A script directly updates core ETRM tables. Would you approve it?
  12. An upgrade changes API behaviour and custom results differ. How would you isolate the cause?
  13. A report recalculates P&L differently from ETRM. What architectural problem exists?
  14. A replay produces duplicate settlement output. Which control is missing?
  15. Two scripts implement different mappings for the same commodity. How would you rationalise them?
  16. Operations edits user-table values without approval. What controls are required?
  17. A component is fast in testing but slow in production. What assumptions should be examined?
  18. A failed deployment processed some trades before rollback. What recovery is required?
  19. A business team wants to solve every exception through scripting. How would you challenge this?
  20. What distinguishes an ETRM extension architect from an the platform scripting language or Java developer?
Reporting, Data Lake and Analytics19 sections · 380 questions
1. Reporting Architecture Fundamentals20
  1. What reporting capabilities should remain inside ETRM?
  2. Which workloads should move to an enterprise data platform?
  3. How do operational, analytical, regulatory and financial reports differ?
  4. How would you define ETRM's reporting architecture boundaries?
  5. Why should ETRM not become an enterprise data warehouse?
  6. What risks arise when every report queries ETRM directly?
  7. How would you inventory existing ETRM reports?
  8. How would you identify duplicate or conflicting reports?
  9. What determines whether a report is business-critical?
  10. How should official and exploratory reports be distinguished?
  11. What constitutes an authoritative report?
  12. How should report ownership be assigned?
  13. What belongs in a reporting solution design?
  14. How would you capture functional and non-functional requirements?
  15. How should data latency requirements influence architecture?
  16. How would you support intraday and end-of-day reporting?
  17. How should global and desk-specific reports coexist?
  18. How would you establish a reporting catalogue?
  19. Which controls should accompany report publication?
  20. What distinguishes a reporting solution from a data extract?
2. ETRM Reporting and Simulation Results20
  1. How do ETRM simulations support reporting?
  2. What is a result measure?
  3. How would you select result measures for a report?
  4. Why should reports avoid requesting unnecessary measures?
  5. How do transaction, market-data and simulation contexts affect results?
  6. How should portfolio and transaction filters be defined?
  7. How would you identify an incomplete simulation result?
  8. What happens when a trade cannot be valued?
  9. How should failed transactions appear in reports?
  10. How would you preserve the market-data scenario used?
  11. How should valuation and business dates be represented?
  12. How would you report positions, P&L and sensitivities consistently?
  13. How should custom result calculations be governed?
  14. What are the risks of recalculating valuation logic in a report?
  15. How would you reconcile custom measures with standard results?
  16. How should report aggregation and rounding be controlled?
  17. How would you handle multiple currencies and units?
  18. How should report definitions be versioned?
  19. How would you reproduce an official ETRM report?
  20. When should simulation results be stored rather than recalculated?
3. Operational Reporting20
  1. What constitutes an operational ETRM report?
  2. Which reports require near-real-time data?
  3. How would you report failed trade-validation events?
  4. How should confirmation exceptions be reported?
  5. How would you identify unsettled or overdue cash flows?
  6. How should missing settlement instructions be reported?
  7. How would you report incomplete invoices?
  8. How should failed accounting postings appear?
  9. What should an end-of-day control dashboard contain?
  10. How would you report missing market data?
  11. How should stale curves and fixings be highlighted?
  12. How would you report unprocessed portfolios?
  13. How should exceptions be prioritised?
  14. How would you represent ownership and ageing?
  15. What drill-down should an operational report provide?
  16. How should corrected exceptions disappear from reports?
  17. How would you prevent duplicate workflow tasks?
  18. What service levels should operational reports support?
  19. How should reports distinguish data delay from process failure?
  20. When is a dashboard insufficient without workflow integration?
4. Position, Exposure and P&L Analytics20
  1. How would you design an enterprise position model?
  2. What is the correct grain of a commodity-position dataset?
  3. How should physical and financial positions coexist?
  4. How would you represent contractual, scheduled, nominated and actual quantities?
  5. How should fixed and floating exposures be distinguished?
  6. How would you model daily and hourly delivery profiles?
  7. How should unit conversions be applied?
  8. Which quantity should remain authoritative?
  9. How would you represent basis and location exposure?
  10. How should spread exposure be modelled?
  11. How would you prevent double counting between trades and hedges?
  12. How should options be represented in exposure analytics?
  13. How would you model delta-equivalent positions?
  14. What is the correct grain of a P&L dataset?
  15. How would you separate realised and unrealised P&L?
  16. How should P&L explain components be stored?
  17. How would you represent new-deal and amendment P&L?
  18. How should currency effects be separated?
  19. How would you reconcile aggregated analytics with ETRM?
  20. What controls prevent dashboards from presenting stale positions as current?
5. Market and Credit Risk Analytics20
  1. How would you model market-risk sensitivities in a data lake?
  2. What dimensions should accompany a risk measure?
  3. How should risk-factor mappings be represented?
  4. How would you store delta, gamma, vega and theta?
  5. How should VaR results be modelled?
  6. What metadata must accompany a VaR value?
  7. How would you represent portfolio diversification?
  8. Why should commodity VaRs not simply be added?
  9. How should historical simulation scenarios be stored?
  10. How would you model stress-test results?
  11. How should shocked inputs and results remain linked?
  12. How would you distinguish full-revaluation and approximation results?
  13. How should limit utilisation be represented?
  14. How would you report limit breaches and approvals?
  15. How would you model counterparty exposure?
  16. How should current, future and settlement exposure differ?
  17. How would you represent netting and collateral?
  18. How should credit hierarchies support aggregation?
  19. How would you preserve risk calculations as of an earlier date?
  20. How should model and methodology versions accompany risk results?
6. Extraction Architecture20
  1. What options exist for extracting data from ETRM?
  2. How would you select between reports, APIs, messaging and database extracts?
  3. When is a scheduled snapshot appropriate?
  4. When is change-based extraction preferable?
  5. How would you design an incremental extract?
  6. Which field should act as the change watermark?
  7. What problems arise from relying only on modification timestamps?
  8. How would you capture late and backdated changes?
  9. How should transaction cancellations be extracted?
  10. How would you represent physical deletion or record retirement?
  11. How should lifecycle-event changes be captured?
  12. How would you extract large transaction profiles efficiently?
  13. How should simulation results be exported?
  14. How would you avoid affecting ETRM's operational performance?
  15. What control totals should accompany each extract?
  16. How would you identify missing extraction windows?
  17. How should extract reruns be handled?
  18. How would you prevent reruns from duplicating downstream data?
  19. How should extraction failures be recovered?
  20. What evidence demonstrates that extraction is complete?
7. Events, CDC and Streaming20
  1. When should ETRM data be distributed as events?
  2. What is the difference between event streaming and database change-data capture?
  3. Why may raw CDC be unsuitable as a business contract?
  4. What is a business event?
  5. How should trade-created, amended and cancelled events differ?
  6. How would you publish events only after successful ETRM processing?
  7. What is the transactional-outbox pattern?
  8. How would you preserve event ordering for a transaction?
  9. How should consumers detect duplicate events?
  10. How would you support controlled event replay?
  11. How should event schemas be versioned?
  12. How would you communicate corrected historical data?
  13. What happens when a consumer misses events?
  14. When should a snapshot supplement an event stream?
  15. How would Kafka support near-real-time analytics?
  16. How should partitions be selected?
  17. How would you monitor consumer lag?
  18. What business reconciliation remains necessary?
  19. How should sensitive fields be excluded from events?
  20. When should streaming be rejected in favour of simpler batch extraction?
8. Data Lake and Lakehouse Architecture20
  1. What is the role of a data lake in an ETRM architecture?
  2. How does a lakehouse differ from a traditional data lake?
  3. What should raw, standardised and curated layers contain?
  4. Should raw ETRM extracts be transformed before retention?
  5. How would you preserve source-system fidelity?
  6. What metadata should accompany every ingestion batch?
  7. How would you partition ETRM datasets?
  8. What are the risks of excessive partitioning?
  9. Which file formats are suitable for analytical data?
  10. How should small-file problems be managed?
  11. How would you implement ACID processing in a lakehouse?
  12. How should schema enforcement and evolution be handled?
  13. How would you manage late-arriving data?
  14. How should corrected records update curated datasets?
  15. How would you prevent partial ingestion from becoming visible?
  16. What quality gates should separate data layers?
  17. How should failed records be quarantined?
  18. How would you manage retention and archival?
  19. How should disaster recovery be designed?
  20. When is a warehouse preferable to a lakehouse?
9. Analytical Data Modelling20
  1. How would you model ETRM trades analytically?
  2. What should be the grain of a trade fact table?
  3. When should transaction legs form separate facts?
  4. How should repeating profiles be represented?
  5. How would you model lifecycle events?
  6. How should cash flows and settlement events differ?
  7. How would you model market-data observations?
  8. How should curves and curve points be represented?
  9. How would you model simulation results?
  10. How should portfolio and organisational hierarchies be represented?
  11. What is a slowly changing dimension?
  12. Which dimensions require Type 2 history?
  13. How should counterparty hierarchy changes be handled?
  14. How would you preserve portfolio history?
  15. How should effective and ingestion dates differ?
  16. What is the difference between business time and system time?
  17. When is a bitemporal model necessary?
  18. How would you model trade versions?
  19. How should external and ETRM identifiers coexist?
  20. How would you prevent model design from losing ETRM business semantics?
10. Historical and As-of Reporting20
  1. What does “as of” mean in an ETRM report?
  2. How do valuation time and knowledge time differ?
  3. What data is required to reproduce an earlier result?
  4. How would you preserve historical transaction versions?
  5. How should market-data snapshots be versioned?
  6. How would you handle corrected historical fixings?
  7. Should corrected data overwrite original official data?
  8. How would you distinguish originally reported and restated results?
  9. How should organisational hierarchy changes affect historical reports?
  10. How would you report using current and historical hierarchies?
  11. How should late trades affect prior-day reporting?
  12. How would you prevent future-data leakage?
  13. What is an as-of fence?
  14. How should model versions be incorporated?
  15. How would you test reproducibility?
  16. What evidence should support a financial restatement?
  17. How should historical recalculation be authorised?
  18. How would downstream users select the correct version?
  19. How should official snapshots be retained?
  20. When is exact reproduction impossible, and how should that limitation be disclosed?
11. Data Quality and Reconciliation20
  1. What data-quality dimensions apply to ETRM analytics?
  2. How would you define critical data elements?
  3. Which checks belong at ingestion?
  4. Which checks belong in curated datasets?
  5. How would you validate schema and mandatory fields?
  6. How should referential integrity be tested?
  7. How would you detect duplicate transactions?
  8. How should unit and currency validity be checked?
  9. How would you detect missing transaction profiles?
  10. How should missing market data be identified?
  11. What is a control total?
  12. Which counts and amounts should be reconciled?
  13. How would you reconcile positions between ETRM and the lakehouse?
  14. How should P&L reconciliation handle rounding?
  15. How would you reconcile lifecycle events?
  16. What should happen when reconciliation fails?
  17. How should breaks be prioritised and assigned?
  18. How would you identify the first point of divergence?
  19. How should corrections be tracked?
  20. How would you demonstrate data completeness to auditors?
12. Data Lineage, Catalogue and Metadata20
  1. What lineage is required for an ETRM-derived metric?
  2. How would you trace a dashboard value back to ETRM?
  3. What technical and business metadata should be captured?
  4. How should report definitions be catalogued?
  5. How would you document transformation logic?
  6. How should source fields map to business terms?
  7. What is a data contract?
  8. How should data-product owners use contracts?
  9. How would you handle one field having different business meanings?
  10. How should calculation formulas be versioned?
  11. What metadata should accompany market-risk results?
  12. How would you record source-system and processing timestamps?
  13. How should data-quality results appear in the catalogue?
  14. What is the role of impact analysis?
  15. How would lineage support an legacy-to-modern ETRM upgrade?
  16. How should sensitive data be classified?
  17. Who owns lineage accuracy?
  18. How would you prevent documentation becoming stale?
  19. What metadata should be generated automatically?
  20. How would you prove lineage for a regulatory report?
13. Security and Data Access20
  1. How should ETRM data be classified?
  2. Which datasets contain commercially sensitive information?
  3. How should counterparty and bank data be protected?
  4. How would you implement role-based access?
  5. When is row-level security required?
  6. When is column-level masking appropriate?
  7. How should desk and portfolio access be enforced?
  8. How would you protect data in transit and at rest?
  9. How should service identities access data?
  10. How would you manage encryption keys?
  11. How should production data be protected in development?
  12. What masking or tokenisation methods could be used?
  13. How would you audit data access?
  14. How should bulk downloads be controlled?
  15. How would you prevent data exfiltration?
  16. What retention restrictions apply to user activity logs?
  17. How should external analysts access curated data?
  18. How would you manage cross-border data restrictions?
  19. What should happen when a user changes desks?
  20. How would you conduct periodic access recertification?
14. BI and Semantic-Layer Design20
  1. What is a semantic layer?
  2. Why should dashboards not independently redefine business measures?
  3. How would you define certified position and P&L measures?
  4. How should reusable dimensions be governed?
  5. How would you support drill-down from desk to trade?
  6. What dimensions should support slicing risk results?
  7. How would you handle unit and currency selection?
  8. Should currency conversion occur in the dashboard?
  9. How should aggregation behaviour be defined?
  10. Which measures are non-additive?
  11. Why should VaR not be summed indiscriminately?
  12. How should latest and official snapshots be distinguished?
  13. How would you communicate data freshness?
  14. How should incomplete data be displayed?
  15. How would you optimise dashboard performance?
  16. When should data be pre-aggregated?
  17. What caching risks arise for intraday data?
  18. How would you validate dashboard numbers?
  19. How should self-service analytics be governed?
  20. What prevents a dashboard from becoming an uncontrolled spreadsheet replacement?
15. Advanced Analytics and AI20
  1. Which ETRM datasets are suitable for advanced analytics?
  2. How could analytics improve trade surveillance?
  3. How could anomaly detection support P&L control?
  4. How could machine learning identify market-data anomalies?
  5. How could settlement failures be predicted?
  6. How could cash-flow forecasts support treasury?
  7. How might analytics improve credit-exposure monitoring?
  8. How would you create features from trade and market data?
  9. How should point-in-time correctness be maintained?
  10. What causes training-serving leakage?
  11. How should model outputs be reconciled with controlled ETRM results?
  12. Should AI-generated values directly update ETRM?
  13. What human approval should surround model-driven actions?
  14. How would you monitor model drift?
  15. How should model versions and datasets be tracked?
  16. How would you explain an analytical result to risk controllers?
  17. What controls apply to generative AI using trade data?
  18. How would you prevent sensitive information entering external models?
  19. When is a deterministic rule preferable to machine learning?
  20. How would you establish that an analytics use case creates measurable value?
16. Performance and Cost Management20
  1. How would you estimate ETRM data volumes?
  2. Which datasets typically grow most rapidly?
  3. How should ingestion frequency affect platform sizing?
  4. How would you manage hourly or sub-hourly position snapshots?
  5. When should data be recomputed instead of stored?
  6. How would you prevent unnecessary full-data reloads?
  7. What is predicate pushdown?
  8. How do partition pruning and clustering improve performance?
  9. How would you handle skewed portfolio data?
  10. When should datasets be compacted?
  11. How should compute and storage be separated?
  12. How would you manage concurrent BI and data-science workloads?
  13. How should workload isolation be implemented?
  14. How would you establish cost attribution by data product?
  15. What metrics indicate inefficient pipelines?
  16. How would you reduce cloud costs without weakening controls?
  17. What retention policies should apply to intermediate data?
  18. How should performance testing use representative volumes?
  19. How would you detect data-volume assumptions becoming invalid?
  20. When should architecture be redesigned instead of scaled?
17. DevOps and DataOps20
  1. How should reporting code be stored and versioned?
  2. What should a data-pipeline CI/CD process perform?
  3. How would you test SQL transformations?
  4. What is data-contract testing?
  5. How should schema changes be detected?
  6. How would you test reconciliation automatically?
  7. How should reference-data mappings be promoted?
  8. How would you separate code from environment configuration?
  9. What release evidence should be retained?
  10. How should failed pipeline deployments be rolled back?
  11. What if a faulty transformation already published data?
  12. How would you perform data correction and backfill?
  13. How should pipeline dependencies be orchestrated?
  14. How would you make pipelines restartable?
  15. What checkpoints should long-running jobs maintain?
  16. How should observability be built into pipelines?
  17. What service-level objectives apply to data products?
  18. How should data incidents be managed?
  19. How would you detect configuration drift?
  20. What conditions should block a reporting release?
18. Migration and Modernisation20
  1. How would you migrate legacy ETRM reports?
  2. Which reports should be retired rather than migrated?
  3. How would you identify report usage?
  4. How should business definitions be rationalised?
  5. How would you compare legacy and target results?
  6. What differences may be legitimate?
  7. How should parallel reporting operate?
  8. How long should parallel validation continue?
  9. How would you migrate historical snapshots?
  10. How should historical lineage be preserved?
  11. How would you handle reports containing undocumented logic?
  12. How should user-owned spreadsheets be assessed?
  13. When should a spreadsheet become a governed data product?
  14. How would you migrate without disrupting daily controls?
  15. What reconciliation thresholds should apply?
  16. Who should approve report decommissioning?
  17. How would you prevent users returning to obsolete reports?
  18. What training and adoption support is required?
  19. How should post-migration defects be prioritised?
  20. What determines successful reporting modernisation?
19. Architecture Scenarios20
  1. ETRM and a dashboard show different P&L. How would you investigate?
  2. Trade counts reconcile, but positions do not. What should be compared?
  3. A cancelled trade remains in the data lake. What extraction weakness might exist?
  4. Yesterday's official dashboard changes after a fixing correction. What design problem exists?
  5. Intraday reports are current, but their market data is stale. How should this be shown?
  6. A data pipeline rerun duplicates simulation results. Which controls are missing?
  7. A report sums desk-level VaR and overstates enterprise risk. What modelling error occurred?
  8. Current portfolio hierarchies rewrite historical reporting. How would you correct this?
  9. A direct database report fails after an legacy-to-modern ETRM upgrade. What architectural decision should change?
  10. Traders request unrestricted access to raw ETRM data. How would you respond?
  11. A lakehouse trade model removes leg-level detail. What analytics could become incorrect?
  12. A dashboard converts all quantities using current conversion factors. What historical problem results?
  13. An hourly position dataset becomes prohibitively expensive. How would you redesign it?
  14. A source extract completes successfully but omits one portfolio. How should completeness be detected?
  15. A late trade must update yesterday's report without overwriting the originally published result. How would you model it?
  16. Two teams define realised P&L differently. How would you establish an authoritative definition?
  17. An AI model predicts settlement failures but cannot explain its drivers. Would you operationalise it?
  18. The data platform contains sensitive counterparty data accessible to every analyst. What controls are required?
  19. The business requests real-time reporting although ETRM updates only periodically. How would you frame the limitation?
  20. What distinguishes an ETRM data and analytics architect from a BI developer or data engineer?
Performance, Grid and Batch Architecture19 sections · 410 questions
1. Performance Architecture Fundamentals20
  1. What does performance mean for an ETRM platform?
  2. How do latency, throughput, concurrency and capacity differ?
  3. Which ETRM workloads are latency-sensitive?
  4. Which workloads are throughput-oriented?
  5. How should interactive and batch requirements differ?
  6. What is a performance baseline?
  7. Which measurements should establish the baseline?
  8. How would you define a performance service-level objective?
  9. How do technical and business service levels differ?
  10. What is a representative workload?
  11. Why is average response time insufficient?
  12. How should percentile response times be used?
  13. What is workload contention?
  14. How would you identify the platform's bottleneck?
  15. Why should infrastructure scaling not be the first response?
  16. What is coordinated omission in performance testing?
  17. How would you distinguish a symptom from a root cause?
  18. What architectural decisions most influence ETRM performance?
  19. How should performance requirements be documented?
  20. What evidence demonstrates acceptable production performance?
2. Workload Classification and Isolation20
  1. How would you classify ETRM workloads?
  2. How do trade capture, valuation, reporting and settlement workloads differ?
  3. Which processes require immediate execution?
  4. Which processes can be queued?
  5. How would you isolate trader-facing workloads?
  6. How should end-of-day workloads be separated from intraday processing?
  7. How would you prevent reporting from affecting trade entry?
  8. Which workloads should run on dedicated services?
  9. When should dedicated hosts be considered?
  10. How should critical and non-critical queues be separated?
  11. What is workload prioritisation?
  12. How should business cut-offs influence prioritisation?
  13. How would you control ad hoc user workloads?
  14. How should large report requests be governed?
  15. What is admission control?
  16. How would you prevent one desk monopolising shared capacity?
  17. When is workload throttling appropriate?
  18. How should back-pressure be implemented?
  19. How would you handle unexpected volume spikes?
  20. What indicates that workload isolation is inadequate?
3. Client and Interactive Performance20
  1. How would you investigate slow ETRM client response?
  2. How would you separate client, network, service and database latency?
  3. What causes slow trade-entry screens?
  4. How can excessive defaulting logic affect users?
  5. How can synchronous validations increase latency?
  6. Which validations must remain synchronous?
  7. Which validations could run asynchronously?
  8. How would you diagnose a slow portfolio query?
  9. How can large result sets affect client performance?
  10. How should search criteria be constrained?
  11. How could user layouts or saved queries create performance problems?
  12. How would you investigate slow login?
  13. How can entitlement evaluation affect response time?
  14. How would network latency affect remote users?
  15. When should regional access architecture be reconsidered?
  16. How would you monitor user-experienced latency?
  17. What telemetry is needed for interactive diagnostics?
  18. How would you reproduce an intermittent client issue?
  19. Why might only one user experience slowness?
  20. When should a client-performance incident be treated as a platform issue?
4. Database Performance25
  1. How does database performance affect ETRM?
  2. What are the common symptoms of database bottlenecks?
  3. How would you identify expensive queries?
  4. What causes blocking and lock contention?
  5. How can long-running transactions affect other workloads?
  6. How should query execution plans be analysed?
  7. What role do indexes play?
  8. How can inappropriate indexing reduce performance?
  9. Why are database statistics important?
  10. How should statistics maintenance be scheduled?
  11. What causes excessive database round trips?
  12. Why are row-by-row queries inefficient?
  13. How would you replace repeated queries with set-based processing?
  14. How can direct analytical queries affect ETRM?
  15. How should operational and analytical workloads be separated?
  16. What causes temporary-space pressure?
  17. How would you investigate increasing database I/O?
  18. How does storage latency affect batch performance?
  19. What causes database connection exhaustion?
  20. How should connection pools be sized?
  21. How would you detect connection leaks?
  22. How should data growth be monitored?
  23. When should historical data be archived?
  24. How would you verify that archiving improved performance?
  25. What controls should govern database tuning changes?
5. the platform scripting language and Java Performance25
  1. What commonly causes poor the platform scripting language performance?
  2. How would you profile an the platform scripting language script?
  3. Why are database calls inside loops problematic?
  4. How should table operations be optimised?
  5. How can repeated table copying affect memory and runtime?
  6. Why must the platform scripting language table objects be destroyed?
  7. How would you detect table-related memory leaks?
  8. What risks arise from processing an entire dataset in memory?
  9. How should large datasets be partitioned?
  10. How would you choose an appropriate batch size?
  11. What are the risks of very small batches?
  12. What are the risks of very large batches?
  13. How would you reduce unnecessary object creation?
  14. How should reusable reference data be cached?
  15. What risks arise from stale caches?
  16. How would you profile a Java extension?
  17. What does sustained garbage collection indicate?
  18. How would you diagnose heap exhaustion?
  19. How can unmanaged threads affect ETRM?
  20. When can parallel processing make a script slower?
  21. How would you ensure thread safety?
  22. How should external-service calls be timed and monitored?
  23. What timeout and retry problems can degrade performance?
  24. How would you detect a performance regression after code deployment?
  25. How should optimisation preserve functional results?
6. Simulation Architecture25
  1. What is an ETRM simulation?
  2. Which inputs determine simulation performance?
  3. How do transaction volume and product complexity affect runtime?
  4. How does the number of result measures affect performance?
  5. Why should simulations request only necessary measures?
  6. How do market-data scenarios influence processing?
  7. How would you design an intraday simulation?
  8. How should official end-of-day simulations differ?
  9. How would you partition a large simulation?
  10. Which partition keys are commonly useful?
  11. What risks arise from partitioning by transaction count alone?
  12. How should complex transactions influence partitioning?
  13. How would you address skewed portfolio workloads?
  14. What is full revaluation?
  15. When can sensitivity-based calculation reduce runtime?
  16. What control is required when using approximations?
  17. How should dependencies between result measures be managed?
  18. What can cause one transaction to slow an entire simulation?
  19. How would you identify problematic transactions?
  20. How should unvalued transactions be handled?
  21. What constitutes a complete simulation result?
  22. How would you verify that all expected portfolios were processed?
  23. How should partial simulation failures be recovered?
  24. How would you compare simulation results across environments?
  25. What would justify redesigning a simulation rather than adding capacity?
7. Grid Architecture25
  1. What is the role of grid computing in ETRM?
  2. Which workloads benefit from grid execution?
  3. Which workloads are unsuitable for distribution?
  4. What are grid coordinators, workers and work units conceptually?
  5. How should work be divided across workers?
  6. How would you select the number of workers?
  7. Why does adding workers not guarantee linear scaling?
  8. What shared resources can limit grid scalability?
  9. How can the database become a grid bottleneck?
  10. How can network latency affect distributed processing?
  11. What is workload skew?
  12. How would you detect uneven worker utilisation?
  13. How should large or complex portfolios be distributed?
  14. What happens when a worker fails?
  15. How should failed work units be retried?
  16. How would you prevent duplicate results after retry?
  17. How should intermediate results be managed?
  18. What constitutes successful grid completion?
  19. How would you detect a worker that is alive but stalled?
  20. Which worker metrics should be monitored?
  21. How should worker capacity be reserved for critical workloads?
  22. How would you support multiple simulations concurrently?
  23. What causes grid queue congestion?
  24. How should queue priority be governed?
  25. How would you test grid failover?
8. Batch Architecture25
  1. What constitutes an ETRM batch process?
  2. What makes a batch restartable?
  3. How should a batch be divided into logical stages?
  4. What checkpoints should be retained?
  5. How should dependencies be represented?
  6. How would you prevent downstream stages running prematurely?
  7. What is the difference between job completion and business completion?
  8. How should batch control totals be calculated?
  9. How would you detect missing portfolios or records?
  10. What happens when only one stage fails?
  11. Should the entire batch be rerun?
  12. How would you design selective restart?
  13. How should previously completed work be recognised?
  14. How would you prevent duplicate outputs?
  15. How should batch parameters be controlled?
  16. How would you manage business-date parameters?
  17. What risks arise from defaulting to the current system date?
  18. How should reruns for historical dates be handled?
  19. How should batch status be reported?
  20. What audit evidence should every run retain?
  21. How should manual intervention be controlled?
  22. When should operators be prevented from bypassing failed stages?
  23. How would you manage downstream notification?
  24. How should batch retention and log archival be governed?
  25. What makes a batch architecture operationally supportable?
9. End-of-Day Architecture25
  1. What are the principal stages of an ETRM end-of-day cycle?
  2. How should trading cut-off be established?
  3. How would you control late and backdated trades?
  4. How should official market-data readiness be confirmed?
  5. What checks should precede valuation?
  6. How should valuation, risk and P&L jobs be sequenced?
  7. When can jobs execute in parallel?
  8. Which dependencies require strict ordering?
  9. How should settlement and accounting processing fit into end-of-day?
  10. What is an official result snapshot?
  11. How should official and rerun results be distinguished?
  12. How would you preserve the original published result?
  13. How should corrected trades or market data trigger recalculation?
  14. Who should authorise a rerun?
  15. How should downstream systems be notified of restated results?
  16. How would you coordinate regional close schedules?
  17. How should overlapping business dates be managed?
  18. How would you handle daylight-saving transitions?
  19. What happens when end-of-day misses its SLA?
  20. How should critical and deferrable stages be classified?
  21. What is the minimum viable close?
  22. How should incomplete results be communicated?
  23. How would you recover after an extended outage?
  24. What reconciliation proves end-of-day completeness?
  25. What criteria determine successful business-day closure?
10. Scheduling and Orchestration20
  1. How should ETRM jobs be scheduled?
  2. When should enterprise scheduling be used?
  3. How should ETRM-native and external scheduling coexist?
  4. How would you model cross-system dependencies?
  5. What is a job dependency graph?
  6. How should calendars and regional holidays affect schedules?
  7. How would you prevent duplicate scheduler execution?
  8. What happens during scheduler failover?
  9. How should missed schedules be detected?
  10. How would you manage ad hoc executions?
  11. How should job parameters be approved?
  12. How would you control manual restarts?
  13. What is a maximum execution window?
  14. How should long-running jobs be escalated?
  15. When should a job be terminated?
  16. What risks arise from automatically killing a slow job?
  17. How should scheduler time zones be configured?
  18. How would you coordinate month-end and year-end processing?
  19. What operational dashboard should orchestration provide?
  20. How would you test schedule changes?
11. Concurrency and Transaction Management20
  1. What concurrency risks exist in ETRM processing?
  2. How can two processes attempt to update the same trade?
  3. How should conflicting updates be handled?
  4. What is optimistic versus pessimistic locking?
  5. How can lock contention affect batch throughput?
  6. How would you identify a deadlock?
  7. How should transaction boundaries be selected?
  8. Why are long database transactions risky?
  9. How would you process independent records concurrently?
  10. Which records must remain sequential?
  11. How should ordering be maintained for trade amendments?
  12. How would you prevent simultaneous duplicate processing?
  13. What is idempotent processing?
  14. How does idempotency support batch restart?
  15. How should shared reference-data caches be protected?
  16. What risks arise from parallel writes to output tables?
  17. How should control totals be calculated across parallel workers?
  18. How would you test race conditions?
  19. Why can concurrency defects be difficult to reproduce?
  20. When should concurrency be reduced deliberately?
12. Memory and Resource Management20
  1. Which ETRM workloads are memory-intensive?
  2. How would you establish normal memory usage?
  3. What is the difference between a memory spike and a leak?
  4. How would you identify gradual memory growth?
  5. What causes heap exhaustion?
  6. How can large transaction profiles increase memory usage?
  7. How should large result tables be processed?
  8. Why is resource cleanup essential?
  9. How would you detect unreleased database connections?
  10. What causes excessive temporary-file usage?
  11. How should disk space be monitored?
  12. What is CPU saturation?
  13. How would you distinguish useful CPU work from contention?
  14. What indicates thread-pool exhaustion?
  15. How should worker thread pools be sized?
  16. How would you diagnose excessive context switching?
  17. How can logging degrade performance?
  18. How should log levels be controlled dynamically?
  19. What resource limits should trigger alerts?
  20. When should a process be restarted, and when is restart insufficient?
13. High Availability and Recovery20
  1. Which performance services require high availability?
  2. How should active-active and active-passive designs differ?
  3. What happens to running jobs during failover?
  4. How should in-flight work be identified?
  5. How would you prevent duplicate processing after recovery?
  6. How should checkpoints survive host failure?
  7. What recovery-point objective applies to batch state?
  8. What recovery-time objective applies to end-of-day?
  9. How should database and application recovery remain consistent?
  10. What happens when grid workers lose coordinator connectivity?
  11. How should queued work survive service restart?
  12. How would you recover from database unavailability?
  13. How should accumulated backlog be prioritised?
  14. What capacity is required during degraded operation?
  15. How would you test failover under full workload?
  16. What constitutes business-level recovery?
  17. How should disaster-recovery capacity be sized?
  18. How would you verify historical results after recovery?
  19. What evidence should resilience testing produce?
  20. Which recovery assumptions require regular revalidation?
14. Monitoring and Observability20
  1. What should an ETRM performance dashboard show?
  2. Which client-performance metrics should be monitored?
  3. Which service metrics should be monitored?
  4. Which database metrics should be monitored?
  5. Which grid metrics should be monitored?
  6. Which batch metrics should be monitored?
  7. How would you correlate activity across components?
  8. What role should correlation identifiers play?
  9. How would you trace a slow simulation?
  10. How should queue depth and consumer lag be interpreted?
  11. How would you identify a stalled worker?
  12. What is the difference between liveness and progress?
  13. How should expected completion time be forecast?
  14. What thresholds should generate warnings?
  15. What thresholds should generate incidents?
  16. How would you avoid alert fatigue?
  17. How should performance trends be retained?
  18. What data supports capacity planning?
  19. How would you detect degradation before SLA breach?
  20. How should business completeness appear alongside technical status?
15. Capacity Planning20
  1. What inputs are needed for ETRM capacity planning?
  2. How should trade-volume growth be projected?
  3. How should product complexity influence estimates?
  4. How do hourly profiles affect data and compute requirements?
  5. How should additional result measures influence sizing?
  6. How would you estimate concurrent-user growth?
  7. How should intraday valuation frequency affect capacity?
  8. What headroom should production maintain?
  9. How would you size for month-end peaks?
  10. How should failover capacity be considered?
  11. How would you model compound growth across datasets?
  12. What does a capacity constraint look like?
  13. How should capacity forecasts be validated?
  14. When should capacity be added?
  15. How would you distinguish vertical and horizontal scaling opportunities?
  16. Which ETRM workloads scale poorly horizontally?
  17. How should storage growth be forecast?
  18. How would archival affect future capacity?
  19. What cost-performance trade-offs should be presented?
  20. When does capacity planning require architectural redesign?
16. Performance Testing20
  1. What should an ETRM performance-test strategy contain?
  2. How do load, stress, volume, spike and soak tests differ?
  3. How would you create representative trade populations?
  4. Why must structured products be included?
  5. How should market-data volume be represented?
  6. How would you simulate concurrent users?
  7. How should end-of-day dependencies be reproduced?
  8. What baseline environment is required?
  9. How would you account for smaller non-production infrastructure?
  10. Which metrics should be captured during testing?
  11. How would you test grid scalability?
  12. What does a scalability curve reveal?
  13. How would you identify the saturation point?
  14. How should failure and recovery be included?
  15. How would you test partial worker failure?
  16. How should test results be compared with SLAs?
  17. How would you validate result correctness under load?
  18. What is an acceptable performance variance?
  19. How should performance regressions block release?
  20. What evidence should support production-capacity approval?
17. Cloud and Infrastructure Considerations20
  1. How does cloud infrastructure affect ETRM performance?
  2. Which workloads benefit from elastic capacity?
  3. Why may autoscaling be unsuitable for some ETRM components?
  4. How should compute placement minimise latency?
  5. How does cross-zone communication affect performance?
  6. How should database storage be selected?
  7. What impact can network-attached storage have?
  8. How would you benchmark cloud instances?
  9. How should burstable instances be assessed?
  10. How would you avoid noisy-neighbour effects?
  11. How should grid workers be scaled in cloud environments?
  12. What startup time limits elasticity?
  13. How would you manage capacity for predictable end-of-day peaks?
  14. How should infrastructure-as-code support repeatability?
  15. What monitoring should integrate with cloud observability?
  16. How would you control performance-related cloud costs?
  17. When is reserved capacity preferable?
  18. How should disaster-recovery environments be scaled?
  19. How would you validate vendor support for the infrastructure?
  20. What cloud assumptions require proof-of-concept testing?
18. Performance Governance20
  1. Who owns ETRM performance?
  2. How should application, database and infrastructure responsibilities be divided?
  3. What performance standards should developers follow?
  4. How should solution designs include capacity impact?
  5. When is performance testing mandatory?
  6. How should performance defects be prioritised?
  7. What is a performance budget?
  8. How would you prevent gradual SLA erosion?
  9. How should architectural exceptions be approved?
  10. How would you maintain a performance-risk register?
  11. What evidence should accompany tuning changes?
  12. How should production changes be benchmarked?
  13. How would you prevent untested indexes or parameters reaching production?
  14. When should vendor support be engaged?
  15. How should recurring incidents inform architectural remediation?
  16. What metrics indicate accumulated performance debt?
  17. How should improvement benefits be measured?
  18. How would you communicate capacity risk to executives?
  19. What release criteria should include performance?
  20. What conditions justify stopping production deployment?
19. Architecture Scenarios20
  1. End-of-day runtime doubles without increased trade volume. How would you investigate?
  2. Adding grid workers makes simulations slower. What bottlenecks might explain this?
  3. One portfolio consumes half the risk-run duration. How would you redesign partitioning?
  4. Trade entry slows only during reporting hours. What does this suggest?
  5. Database CPU is low, but query latency is high. What else should be examined?
  6. A batch reports success while one portfolio is missing. What control failed?
  7. Restarting a failed batch duplicates accounting output. What design is missing?
  8. A script processes transactions one at a time with repeated queries. How should it change?
  9. Grid workers are busy but overall throughput is flat. What shared constraint may exist?
  10. A simulation is fast in testing but slow in production. Which assumptions should be compared?
  11. A service is running but its queue continues growing. How should monitoring classify it?
  12. Month-end processing misses its cut-off every quarter. Why is this not merely an operational issue?
  13. A complex LNG transaction takes minutes to value. How would you isolate the expensive component?
  14. A report requests every result measure for every trade. What architectural correction is required?
  15. Memory returns to normal after restart but grows again daily. How should this be treated?
  16. A database index improves one report but slows trade capture. How would you assess the change?
  17. A regional close overlaps with another region's intraday run. How would you manage capacity?
  18. Disaster recovery meets infrastructure RTO but misses the business close. What was defined incorrectly?
  19. The business asks for a five-minute SLA without providing expected volumes. How would you respond?
  20. What distinguishes an ETRM performance architect from a database administrator or infrastructure engineer?
Security, Entitlements and Audit20 sections · 400 questions
1. Security Architecture Fundamentals20
  1. What are the principal security domains in an ETRM implementation?
  2. How would you define ETRM's security boundary?
  3. Which controls belong inside ETRM?
  4. Which controls belong in identity, network, database and infrastructure platforms?
  5. How do authentication, authorisation and accountability differ?
  6. What is the principle of least privilege?
  7. What is defence in depth?
  8. How would you perform an ETRM security assessment?
  9. What should an ETRM security architecture document contain?
  10. How would you identify critical business actions?
  11. How should business risk determine control strength?
  12. What is a threat model?
  13. Which ETRM assets require the strongest protection?
  14. How would you classify ETRM data?
  15. How should preventive, detective and corrective controls work together?
  16. What is a security control objective?
  17. How would you map controls to risks?
  18. How should security exceptions be approved?
  19. How would you prevent security architecture becoming environment-specific?
  20. What constitutes effective security rather than documented security?
2. Identity and Authentication20
  1. How should ETRM users be uniquely identified?
  2. How would you integrate ETRM with enterprise identity management?
  3. What authentication methods should be considered?
  4. When should single sign-on be used?
  5. What risks accompany local ETRM accounts?
  6. When might a local emergency account be necessary?
  7. How should emergency credentials be protected?
  8. What is multifactor authentication?
  9. Where should MFA be enforced?
  10. How should service accounts authenticate?
  11. Why should shared user accounts be prohibited?
  12. How should authentication failures be monitored?
  13. What account-lockout policy is appropriate?
  14. How should inactive accounts be handled?
  15. How would you manage password requirements where passwords remain necessary?
  16. How should authentication sessions expire?
  17. How would you manage users across multiple ETRM environments?
  18. How should non-production identities differ from production identities?
  19. What risks arise from copying identity data between environments?
  20. How would you prove that every action maps to an accountable identity?
3. Role-Based Access Control20
  1. What is role-based access control?
  2. How would you design an ETRM role model?
  3. Should roles mirror job titles?
  4. What is the difference between business and technical roles?
  5. How should trader, risk, operations and administrator roles differ?
  6. How would you avoid one role containing excessive permissions?
  7. What is role explosion?
  8. How would you manage regional variations?
  9. How should temporary responsibilities be granted?
  10. How would you define role ownership?
  11. What information should a role catalogue contain?
  12. How should role changes be approved?
  13. How would you identify unused roles?
  14. How should inherited permissions be analysed?
  15. How would you detect conflicting roles?
  16. What is attribute-based access control?
  17. When could attributes complement ETRM roles?
  18. How would you test a role before production deployment?
  19. How should roles move between environments?
  20. How would you demonstrate that a role remains appropriate over time?
4. Organisational, Portfolio and Transaction Entitlements20
  1. How should access be restricted by business unit?
  2. How should portfolio-level visibility be implemented?
  3. How would you restrict a trader to authorised books?
  4. How should read, create, amend and validate permissions differ?
  5. How would you prevent unauthorised portfolio transfers?
  6. How should product eligibility be enforced?
  7. How would you restrict transaction entry by instrument?
  8. How should tenor, quantity or notional mandates be controlled?
  9. How would you restrict access by legal entity?
  10. How should regional data restrictions be represented?
  11. Can users with view access see economically sensitive fields?
  12. How would you limit bulk transaction operations?
  13. How should historical transaction access be governed?
  14. How would you prevent users from bypassing controls through templates?
  15. How should inter-book transactions be authorised?
  16. How would you control cancellation and termination rights?
  17. How should amendment permissions vary by transaction status?
  18. What controls apply after confirmation or settlement?
  19. How would you test negative-entitlement scenarios?
  20. How would you detect booking activity outside a user's mandate?
5. Segregation of Duties20
  1. What is segregation of duties?
  2. Which ETRM duties should normally be separated?
  3. Can a trader create and validate the same transaction?
  4. Should a user maintain and approve settlement instructions?
  5. Should developers deploy their own production changes?
  6. Should operations staff amend core trade economics?
  7. How would you construct a segregation-of-duties matrix?
  8. What constitutes a toxic access combination?
  9. How would you detect toxic role combinations?
  10. How should unavoidable conflicts be managed?
  11. What is a compensating control?
  12. When is supervisory review an adequate compensating control?
  13. How should small teams handle limited staff separation?
  14. How should emergency-access conflicts be reviewed?
  15. How would you prevent users from obtaining conflicts through multiple roles?
  16. How should temporary access affect segregation checks?
  17. How would you test segregation during user acceptance?
  18. How should conflicts be reported and escalated?
  19. Who should accept residual segregation risk?
  20. How would you prove that segregation controls operated effectively?
6. Privileged Access Management20
  1. What constitutes privileged access in ETRM?
  2. Which accounts should be treated as privileged?
  3. How should administrator access be granted?
  4. What is just-in-time privileged access?
  5. How should privileged sessions be approved?
  6. How would you integrate privileged access management?
  7. Should administrators use privileged accounts for ordinary work?
  8. How should database-administrator access be controlled?
  9. How should operating-system access be governed?
  10. How would you manage vendor-support access?
  11. What controls should apply to production support?
  12. How should privileged credentials be rotated?
  13. How would you eliminate embedded administrative passwords?
  14. Should privileged sessions be recorded?
  15. What privileged activities require real-time alerting?
  16. How should emergency access be activated?
  17. How should emergency activity be reviewed?
  18. What happens when privileged access expires?
  19. How would you recertify privileged accounts?
  20. What evidence should a privileged-access review produce?
7. Service Accounts and Machine Identities20
  1. How do service accounts differ from user accounts?
  2. Why should every service have a distinct identity?
  3. How should service-account ownership be assigned?
  4. What permissions should a trade-ingestion service possess?
  5. How should batch-service permissions differ?
  6. How should reporting-service permissions differ?
  7. Why should service accounts be non-interactive?
  8. How should secrets be stored?
  9. How should secrets be rotated without service interruption?
  10. What is certificate-based authentication?
  11. When should mutual TLS be used?
  12. How should certificate expiry be monitored?
  13. How would you prevent credentials appearing in scripts?
  14. How should environment-specific secrets be separated?
  15. How would you identify unused service accounts?
  16. How should service-account activity be monitored?
  17. What indicates that a service identity is compromised?
  18. How should compromised credentials be revoked?
  19. How would you recover dependent services after rotation?
  20. How should service identities be included in access recertification?
8. Sensitive Data Protection20
  1. Which ETRM data should be classified as confidential?
  2. How should transaction economics be protected?
  3. How should counterparty information be classified?
  4. What controls apply to bank-account details?
  5. How should trader and personnel data be protected?
  6. How would you enforce field-level restrictions?
  7. When should data masking be used?
  8. What is tokenisation?
  9. How should production data be sanitised for testing?
  10. Why is simply changing names insufficient anonymisation?
  11. How should data be encrypted in transit?
  12. How should data be encrypted at rest?
  13. Who should control encryption keys?
  14. How should backups be encrypted?
  15. What controls should apply to data exports?
  16. How would you restrict spreadsheet downloads?
  17. How should reports avoid exposing unnecessary information?
  18. What controls apply to email-distributed reports?
  19. How would you manage data residency requirements?
  20. How should sensitive-data access be audited?
9. Database and Infrastructure Security20
  1. How should ETRM database access be restricted?
  2. Why should users not connect directly to production tables?
  3. How should application database credentials be managed?
  4. What risks arise from shared database credentials?
  5. How would you monitor privileged database activity?
  6. How should database changes be approved?
  7. What controls prevent direct updates to core tables?
  8. How should backups and replicas be protected?
  9. How should operating-system accounts be managed?
  10. What file-system permissions should ETRM components receive?
  11. How should network segmentation protect ETRM?
  12. Which inbound and outbound connections should be allowed?
  13. How should firewalls implement least connectivity?
  14. What is the role of a bastion or controlled administration host?
  15. How should remote administrative access be secured?
  16. How should vulnerability scanning be performed?
  17. How should operating-system and database patches be governed?
  18. How would you manage unsupported platform components?
  19. What evidence demonstrates secure infrastructure configuration?
  20. How should disaster-recovery security match production?
10. APIs and Integration Security20
  1. How should systems authenticate to ETRM-facing APIs?
  2. How should API authorisation be implemented?
  3. What is the role of an API gateway?
  4. How should API scopes be defined?
  5. How would you restrict an interface to authorised portfolios?
  6. How should inbound payloads be validated?
  7. How would you prevent injection attacks?
  8. How should oversized or malformed requests be handled?
  9. How would rate limiting protect ETRM?
  10. What is transport-layer security?
  11. How should certificates be governed?
  12. How would you prevent replay attacks?
  13. How should idempotency keys be protected?
  14. How should message queues be secured?
  15. How would you authorise message producers and consumers?
  16. How should sensitive message fields be encrypted?
  17. What data should never appear in integration logs?
  18. How should external vendor connectivity be controlled?
  19. How would you revoke a compromised integration identity?
  20. What security testing should every interface undergo?
11. the platform scripting language and Custom-Code Security20
  1. Who should be permitted to create or modify the platform scripting language scripts?
  2. Who should be allowed to execute scripts?
  3. How should scripts be reviewed before deployment?
  4. Why should credentials never be hard-coded?
  5. How should external endpoints be restricted?
  6. How should input validation be implemented?
  7. How would you prevent SQL injection?
  8. Why should direct database updates be prohibited?
  9. How should file-system access be constrained?
  10. How would you prevent unauthorised command execution?
  11. How should third-party libraries be approved?
  12. How should dependency vulnerabilities be monitored?
  13. What static-analysis controls should be applied?
  14. How should sensitive information be excluded from logs?
  15. How would you detect malicious or unauthorised script changes?
  16. How should code signing or artifact integrity be used?
  17. How would you separate developer and deployment responsibilities?
  18. How should emergency code changes be reviewed?
  19. What evidence should accompany a production script?
  20. How would you retire insecure legacy customisations?
12. Trade and Market-Control Audit20
  1. What trade activities must be audited?
  2. How should original trade capture be recorded?
  3. What evidence should accompany an amendment?
  4. How should cancellations and terminations be audited?
  5. How should manual price overrides be recorded?
  6. What evidence should support an off-market trade?
  7. How should portfolio transfers be audited?
  8. How should user-entered market data be controlled?
  9. What evidence should accompany curve overrides?
  10. How should corrected fixings remain traceable?
  11. How should trader and approver identities be preserved?
  12. What timestamps are required?
  13. How should system-generated and manual changes be distinguished?
  14. How would you report transactions changed after cut-off?
  15. How should bulk changes remain traceable?
  16. What controls prevent audit records from being altered?
  17. How long should trade audit information be retained?
  18. How would you retrieve evidence for a particular transaction?
  19. How should historical audit data remain accessible after upgrades?
  20. How would you prove that audit coverage is complete?
13. Settlement, Payment and Accounting Controls20
  1. How should settlement-instruction changes be authorised?
  2. What controls should apply to bank-account changes?
  3. How would callback or independent verification complement system controls?
  4. How should one-time settlement instructions be managed?
  5. Who should be allowed to release payments?
  6. How would you prevent duplicate payments?
  7. How should urgent manual payments be controlled?
  8. What evidence should support payment cancellation or recall?
  9. How should invoice amendments be audited?
  10. Who should approve credit and debit notes?
  11. How should disputed settlements be controlled?
  12. What controls should govern accounting-rule changes?
  13. How should manual journals be authorised?
  14. How would you detect unbalanced postings?
  15. How should period-close access be restricted?
  16. What controls apply to backdated accounting changes?
  17. How should rejected postings be monitored?
  18. How would you reconcile ETRM with payment and ledger systems?
  19. What access should auditors receive?
  20. How would you demonstrate completeness of financial controls?
14. Audit Logging and Evidence20
  1. What is the difference between application logging and an audit trail?
  2. Which user activities should generate audit records?
  3. Which administrative activities should be audited?
  4. What fields should an audit record contain?
  5. How should before-and-after values be preserved?
  6. How should timestamps be standardised?
  7. Why is reliable time synchronisation important?
  8. How should correlation identifiers support investigations?
  9. How would you protect audit logs from alteration?
  10. Should administrators be able to delete their own audit records?
  11. How should audit logs be centralised?
  12. What retention period should apply?
  13. How would you make archived logs searchable?
  14. How should log access be restricted?
  15. What events should trigger real-time alerts?
  16. How would you detect unusual transaction activity?
  17. How should failed login attempts be analysed?
  18. How would you distinguish user and service-account actions?
  19. What evidence is required to demonstrate control execution?
  20. How would you test audit logging after an upgrade?
15. Monitoring and Security Analytics20
  1. Which ETRM security events should be monitored?
  2. How should ETRM logs integrate with a SIEM?
  3. What constitutes suspicious access behaviour?
  4. How would you detect excessive failed logins?
  5. How would you identify access from unusual locations or hosts?
  6. How should privilege escalation be detected?
  7. How would you detect unauthorised portfolio access?
  8. How should mass trade amendments be monitored?
  9. How would you identify unusual data exports?
  10. What alerts should bank-account changes generate?
  11. How should emergency-access activity be monitored?
  12. How would you detect service-account misuse?
  13. What is a security use case?
  14. How should alert severity be assigned?
  15. How would you reduce false positives?
  16. Who should investigate security alerts?
  17. How should security and operational incidents be correlated?
  18. What evidence should be retained during investigation?
  19. How would you measure security-monitoring effectiveness?
  20. How should lessons from incidents improve controls?
16. Joiner, Mover and Leaver Controls20
  1. How should new ETRM access be requested?
  2. Who should approve a new user's roles?
  3. How should employment status be verified?
  4. How should access start and expiry dates be controlled?
  5. How would you manage contractor access?
  6. What happens when a user changes desks?
  7. How should obsolete roles be removed?
  8. How quickly should leaver access be revoked?
  9. How would you handle immediate termination?
  10. How should dormant accounts be detected?
  11. What happens to reports or processes owned by a departing user?
  12. How should service ownership be reassigned?
  13. How would you reconcile ETRM users with the identity directory?
  14. What exceptions should a reconciliation detect?
  15. How should unresolved identity exceptions be escalated?
  16. How would you test the leaver process?
  17. What evidence should demonstrate timely removal?
  18. How should rehires be handled?
  19. How would you prevent old entitlements being automatically restored?
  20. Who owns the complete joiner-mover-leaver control?
17. Access Reviews and Recertification20
  1. Why is periodic access recertification required?
  2. Which ETRM access should be reviewed most frequently?
  3. Who should certify business access?
  4. Who should certify privileged access?
  5. What information should reviewers receive?
  6. How would you make reviews risk-based?
  7. How should toxic combinations be highlighted?
  8. How should unused access be identified?
  9. What constitutes meaningful certification?
  10. How would you prevent automatic approval?
  11. What happens when reviewers do not respond?
  12. How quickly should rejected access be removed?
  13. How should remediation be evidenced?
  14. How would you review service accounts?
  15. How should emergency accounts be certified?
  16. How would you measure recertification completeness?
  17. What sampling should independent control teams perform?
  18. How should access-review findings influence role redesign?
  19. How would you demonstrate the control to an auditor?
  20. What indicates that the certification process is ineffective?
18. Change, Release and Environment Security20
  1. How should ETRM security configuration move between environments?
  2. Who should approve entitlement changes?
  3. How should configuration changes be versioned?
  4. How would you detect security-configuration drift?
  5. Who should be able to deploy production changes?
  6. How should developer access differ across environments?
  7. Should developers have permanent production access?
  8. How should emergency deployments be controlled?
  9. What security testing should precede release?
  10. How would you test negative permissions?
  11. How should test accounts be governed?
  12. How should production data be protected in lower environments?
  13. What evidence should accompany a release?
  14. How should deployment artifacts be protected?
  15. How would you verify artifact integrity?
  16. What should post-deployment security validation cover?
  17. How should rollback preserve security?
  18. What if a release creates excessive permissions?
  19. Which security findings should block release?
  20. How should upgrade testing validate existing entitlements and audit trails?
19. Incident Response and Resilience20
  1. What constitutes an ETRM security incident?
  2. How should suspected credential compromise be handled?
  3. What actions should follow unauthorised transaction activity?
  4. How would you preserve forensic evidence?
  5. When should an account be disabled immediately?
  6. How should business continuity be considered during containment?
  7. How would you rotate compromised service credentials?
  8. How should dependent integrations be recovered?
  9. What if audit logging was unavailable during an incident?
  10. How would you determine the affected period?
  11. How should sensitive data exposure be assessed?
  12. Who should participate in incident response?
  13. How should regulators or clients be informed?
  14. What should a post-incident review contain?
  15. How should corrective actions be prioritised?
  16. How would you test an ETRM security-response plan?
  17. How should backup credentials be secured?
  18. How should disaster-recovery access be governed?
  19. What security controls must remain operational during recovery?
  20. How would you prove that normal access was restored safely?
20. Architecture Scenarios20
  1. A trader can book into another desk's portfolio. How would you investigate?
  2. A user can create and validate the same trade. What control is missing?
  3. Operations can change bank details and release payment. How should access change?
  4. A service account has full administrative access. How would you remediate it?
  5. A terminated employee's account remains active. What controls failed?
  6. A developer deploys an unreviewed the platform scripting language script directly to production. What weaknesses exist?
  7. Audit logs show a change but not the previous value. Is the evidence sufficient?
  8. A shared account was used for a manual curve override. How would you establish accountability?
  9. A user receives access through several roles that collectively create a conflict. How should it be detected?
  10. A privileged account is used daily because standard access is inconvenient. How would you respond?
  11. An API credential appears in application logs. What immediate actions are required?
  12. A payment file contains unauthorised bank details despite correct ETRM permissions. What else should be examined?
  13. A production database copy is placed in testing without masking. What risks and actions arise?
  14. A user exports all counterparty data before leaving the company. Which controls should detect this?
  15. An emergency fix bypasses normal approval. What retrospective controls are required?
  16. An upgrade silently resets several entitlements. How should testing and monitoring detect it?
  17. A vendor requests permanent administrator access for support. Would you approve it?
  18. Business management repeatedly approves segregation conflicts without remediation. Is the control effective?
  19. The company has extensive audit logs but never reviews them. What capability is missing?
  20. What distinguishes an ETRM security architect from an identity administrator or IT auditor?
Infrastructure, Cloud, HA and Disaster Recovery26 sections · 530 questions
1. Infrastructure Architecture Fundamentals20
  1. Describe the infrastructure layers supporting an enterprise ETRM implementation.
  2. How would you translate logical architecture into physical deployment architecture?
  3. Which ETRM components are stateful?
  4. Which components can be treated as stateless?
  5. What information is required before designing the infrastructure?
  6. How should business criticality influence infrastructure design?
  7. What are the principal ETRM workload categories?
  8. How do interactive, integration, grid and batch workloads differ?
  9. How would you identify infrastructure dependencies?
  10. What constitutes a single point of failure?
  11. How would you document component-to-host allocation?
  12. What should an infrastructure architecture document contain?
  13. How should production and non-production designs differ?
  14. How would you determine environmental sizing ratios?
  15. What is infrastructure headroom?
  16. How much capacity should remain available during normal operation?
  17. How should failure-mode analysis influence design?
  18. What is fault isolation?
  19. How would you avoid one workload affecting the entire platform?
  20. How would you validate vendor certification and supportability?
2. Compute and Host Architecture20
  1. How would you size compute for ETRM services?
  2. Which workload characteristics drive CPU requirements?
  3. Which workloads are memory-intensive?
  4. How should interactive services be separated from batch services?
  5. When should dedicated hosts be used?
  6. When is shared infrastructure acceptable?
  7. How would you select virtual-machine sizes?
  8. What risks arise from heavily oversized virtual machines?
  9. What risks arise from undersized infrastructure?
  10. How would you monitor CPU saturation?
  11. What does sustained high CPU indicate?
  12. How would you investigate low CPU with poor performance?
  13. How should memory utilisation be monitored?
  14. What is the difference between memory pressure and a memory leak?
  15. How would you detect swapping or paging?
  16. How can NUMA architecture affect large workloads?
  17. How should host-level concurrency be controlled?
  18. How would noisy neighbours affect ETRM?
  19. How should compute capacity support month-end peaks?
  20. When should vertical scaling give way to workload redesign?
3. Operating-System Architecture20
  1. Which operating-system requirements should be validated for ETRM?
  2. How should supported versions be governed?
  3. How would you manage operating-system hardening?
  4. What ETRM-specific exceptions might require approval?
  5. How should service accounts be configured?
  6. What file-system permissions should services receive?
  7. How should process limits be configured?
  8. How would you manage environment variables and configuration paths?
  9. How should temporary directories be sized and monitored?
  10. What risks arise from insufficient temporary space?
  11. How should system time be synchronised?
  12. Why is clock drift dangerous for trading systems?
  13. How should locale and timezone settings be governed?
  14. How would you manage operating-system patching?
  15. What testing should precede kernel or system-library changes?
  16. How should endpoint-protection software be configured?
  17. Can antivirus scanning affect ETRM performance?
  18. How should exclusions be controlled and reviewed?
  19. What operating-system telemetry should be retained?
  20. How would you detect configuration drift across hosts?
4. Network Architecture25
  1. What network flows does an ETRM implementation require?
  2. How would you document connectivity?
  3. How should network segmentation be designed?
  4. Which components should reside in separate security zones?
  5. How would you restrict inbound and outbound connectivity?
  6. What is the principle of least connectivity?
  7. How should firewalls be configured?
  8. How would you manage port and protocol inventories?
  9. How can network latency affect ETRM clients?
  10. How does latency affect grid processing?
  11. How would you measure network latency and packet loss?
  12. What is connection-state exhaustion?
  13. How should load balancers be used?
  14. Which health checks should a load balancer perform?
  15. What are the risks of relying only on TCP health checks?
  16. How should DNS support high availability?
  17. How would DNS caching affect failover?
  18. How should certificates and TLS be managed?
  19. How would you connect market-data providers securely?
  20. How should exchanges, banks and clearing platforms connect?
  21. What is private connectivity?
  22. When is public internet connectivity unacceptable?
  23. How would proxy infrastructure affect integrations?
  24. How should bandwidth requirements be estimated?
  25. How would you diagnose intermittent network-related failures?
5. Database Infrastructure25
  1. How would you design the database platform supporting ETRM?
  2. Which database capabilities are critical for ETRM?
  3. How should database compute and memory be sized?
  4. What storage characteristics influence database performance?
  5. How should transaction logs be provisioned?
  6. How would you manage temporary database space?
  7. What causes database I/O bottlenecks?
  8. How should indexes and statistics be maintained?
  9. How would you control database connection counts?
  10. What happens when connection pools are exhausted?
  11. How should database credentials be protected?
  12. Why should direct writes to core ETRM tables be prohibited?
  13. How should privileged database access be monitored?
  14. How would you design database high availability?
  15. What is synchronous versus asynchronous replication?
  16. What data-loss trade-off accompanies asynchronous replication?
  17. How can synchronous replication affect transaction latency?
  18. How should database backups be designed?
  19. How would you validate point-in-time recovery?
  20. How should database recovery align with message and file recovery?
  21. What happens if the database is restored without dependent integration state?
  22. How should database maintenance be scheduled?
  23. How would you perform database patching with minimal disruption?
  24. How should database growth be forecast?
  25. What evidence demonstrates database recoverability?
6. Storage and File-System Architecture20
  1. Which ETRM components depend on shared or local storage?
  2. How would you classify persistent and temporary files?
  3. When is shared storage necessary?
  4. What availability risks accompany shared file systems?
  5. How should storage throughput and latency be measured?
  6. What is IOPS?
  7. Which ETRM workloads are sensitive to storage latency?
  8. How should temporary processing space be sized?
  9. How would you prevent disk exhaustion?
  10. What alerts should storage monitoring generate?
  11. How should file retention be governed?
  12. How would you protect interface landing zones?
  13. How should file permissions be configured?
  14. What controls should prevent partial files from being processed?
  15. How would you implement atomic file delivery?
  16. How should backups of file-based state align with database backups?
  17. How would you replicate shared files to disaster recovery?
  18. What consistency risk arises from asynchronous file replication?
  19. How should archived data remain accessible?
  20. When should object storage be used?
7. Middleware and Integration Infrastructure20
  1. Which middleware components commonly surround ETRM?
  2. When should an API gateway be introduced?
  3. How should message brokers support resilient integration?
  4. What availability level should a trade-ingestion queue provide?
  5. How should messages survive broker failure?
  6. How would you prevent duplicate processing after recovery?
  7. How should consumer concurrency be configured?
  8. What is back-pressure?
  9. How should accumulated messages be managed after an outage?
  10. How would you prioritise critical message types?
  11. How should dead-letter queues be protected?
  12. What monitoring should middleware expose?
  13. How should schema registries be made highly available?
  14. How would you manage integration certificates?
  15. How should secret-management services be made resilient?
  16. What happens when ETRM is available but middleware is unavailable?
  17. What happens when middleware is available but ETRM is unavailable?
  18. How should cross-site message replication be designed?
  19. How would you test integration failover?
  20. What reconciliation proves messaging recovery was complete?
8. ETRM Service Deployment20
  1. How should ETRM services be distributed across hosts?
  2. Which services should be isolated by workload?
  3. How would you determine the number of service instances?
  4. Which services require automatic restart?
  5. When can automatic restart hide a recurring defect?
  6. How should service dependencies be represented?
  7. How should service startup and shutdown be ordered?
  8. What makes a service health check meaningful?
  9. How would you detect a service that is running but stalled?
  10. What is the difference between liveness and readiness?
  11. How should service configuration be versioned?
  12. How would you prevent inconsistent configuration across instances?
  13. How should environment-specific settings be externalised?
  14. How should service credentials be injected securely?
  15. How would you manage service log files?
  16. How should log rotation be configured?
  17. How would you prevent log volumes exhausting storage?
  18. What diagnostic information should be captured before restarting?
  19. How should service restarts be audited?
  20. What post-restart validation is required?
9. Grid Infrastructure20
  1. What infrastructure supports ETRM grid computing?
  2. How should coordinators and workers be deployed?
  3. Which grid components require high availability?
  4. How should worker hosts be sized?
  5. Should all workers use identical configurations?
  6. How would heterogeneous workers affect workload distribution?
  7. How should worker concurrency be determined?
  8. What shared resources can constrain grid scalability?
  9. How can the database become a grid bottleneck?
  10. How does network latency affect distributed valuation?
  11. What happens when a worker host fails?
  12. How should unfinished work be reassigned?
  13. How would you prevent duplicate result production?
  14. What happens when the coordinator fails?
  15. How should grid queues survive failover?
  16. How would you detect an unhealthy worker?
  17. How should worker images or builds be controlled?
  18. How would you scale grid capacity for end-of-day?
  19. When is temporary capacity useful?
  20. How should grid failover be tested under realistic workload?
10. Virtualisation Architecture20
  1. What benefits does virtualisation provide to ETRM?
  2. What risks does virtualisation introduce?
  3. How should CPU overcommitment be assessed?
  4. Why can CPU ready time matter?
  5. How can memory ballooning affect performance?
  6. How should storage contention be monitored?
  7. What is a noisy-neighbour problem?
  8. How should affinity and anti-affinity rules be used?
  9. Which components should not share a failure domain?
  10. How would live migration affect latency-sensitive services?
  11. How should hypervisor maintenance be planned?
  12. What monitoring should include hypervisor-level metrics?
  13. How would you establish reservation and limit policies?
  14. Should disaster-recovery capacity share production clusters?
  15. How would you prevent simultaneous loss of redundant instances?
  16. How should virtual-machine templates be governed?
  17. How would you patch base images?
  18. What tests should follow virtualisation-platform upgrades?
  19. How should licensing implications be evaluated?
  20. When is physical infrastructure still justified?
11. Cloud Architecture Fundamentals20
  1. What factors determine ETRM's suitability for cloud hosting?
  2. How would you assess vendor-supported cloud configurations?
  3. What is the shared-responsibility model?
  4. How would you map ETRM components to cloud services?
  5. Which managed services could reduce operational burden?
  6. Which managed services could create supportability risk?
  7. How should cloud accounts or subscriptions be structured?
  8. How would you separate production and non-production environments?
  9. How should cloud network segmentation be designed?
  10. What is a landing zone?
  11. How should policies and guardrails be applied?
  12. How would you prevent uncontrolled public exposure?
  13. How should private endpoints be used?
  14. How would you manage cross-region connectivity?
  15. What latency constraints influence region selection?
  16. How should data-residency requirements influence placement?
  17. How would you evaluate cloud concentration risk?
  18. How should architecture account for provider service limits?
  19. What assumptions require proof-of-concept testing?
  20. Why should ETRM not automatically be treated as cloud-native?
12. Cloud Compute, Containers and Orchestration20
  1. When are cloud virtual machines appropriate?
  2. Which ETRM workloads can scale horizontally?
  3. Which workloads remain constrained by state?
  4. When could autoscaling be useful?
  5. Why may reactive autoscaling be too slow for end-of-day?
  6. How should predictable batch peaks be handled?
  7. Where could containers be useful around ETRM?
  8. Why may containerising every ETRM component be inappropriate?
  9. What vendor-support questions apply to containers?
  10. How should persistent state be separated from containers?
  11. How would container orchestration manage health and restart?
  12. What risks arise from aggressive automatic restart?
  13. How should container images be secured?
  14. How would you control image provenance?
  15. How should secrets be supplied to containers?
  16. How should resource requests and limits be configured?
  17. What happens when memory limits terminate a process?
  18. How should logs and metrics be exported?
  19. How would you manage rolling upgrades?
  20. When is conventional virtual-machine deployment safer?
13. Cloud Storage, Database and Networking20
  1. How would you select cloud storage for an ETRM database?
  2. Which latency and throughput guarantees are required?
  3. How should managed databases be evaluated?
  4. What ETRM support limitations might affect selection?
  5. How should database availability zones be configured?
  6. What latency can synchronous multi-zone replication introduce?
  7. How should backups be stored across accounts or regions?
  8. How would immutable backups improve resilience?
  9. How should object storage support archives and extracts?
  10. How would you secure cloud storage buckets?
  11. How should private connectivity to ETRM be implemented?
  12. What is a transit network?
  13. How would you connect corporate data centres?
  14. How should routing failover be designed?
  15. How would you resolve cloud DNS during regional failure?
  16. What happens when identity or key-management services are unavailable?
  17. How should cloud service quotas be monitored?
  18. How would you protect against accidental resource deletion?
  19. How should infrastructure events be correlated with ETRM monitoring?
  20. What cloud dependencies must be included in disaster-recovery testing?
14. Infrastructure as Code and Configuration Management20
  1. What is infrastructure as code?
  2. Which ETRM infrastructure should be codified?
  3. How would infrastructure code improve disaster recovery?
  4. How should modules and reusable patterns be structured?
  5. How would you separate code from environment configuration?
  6. How should secrets be excluded from source control?
  7. How would you review infrastructure changes?
  8. What should a CI/CD pipeline validate?
  9. How would you detect configuration drift?
  10. How should emergency manual changes be reconciled?
  11. What is immutable infrastructure?
  12. Where is immutability practical around ETRM?
  13. How should host configuration be automated?
  14. How would you version firewall and load-balancer rules?
  15. How should deployment dependencies be represented?
  16. What evidence should accompany infrastructure release?
  17. How would you roll back an infrastructure change?
  18. When could rollback be more dangerous than remediation?
  19. How should production and disaster-recovery configurations be compared?
  20. How would you prove that an environment can be rebuilt?
15. High-Availability Fundamentals20
  1. What is high availability?
  2. How does high availability differ from disaster recovery?
  3. What availability target should ETRM provide?
  4. How would business impact determine availability requirements?
  5. What is an availability zone or failure domain?
  6. How should redundant components be separated?
  7. What is active-active architecture?
  8. What is active-passive architecture?
  9. When is active-active unsuitable?
  10. How would you calculate theoretical availability?
  11. Why does component redundancy not guarantee service availability?
  12. How should dependent services affect availability calculations?
  13. What is graceful degradation?
  14. Which capabilities could be temporarily degraded?
  15. How should automated failover be governed?
  16. When is manual failover safer?
  17. What split-brain risk exists?
  18. How should quorum be established?
  19. What evidence proves that high availability works?
  20. How frequently should failover be tested?
16. Application and Service High Availability20
  1. How should redundant ETRM services be deployed?
  2. How would you handle services that maintain local state?
  3. How should sessions behave during failover?
  4. What happens to active user operations?
  5. How should in-flight batch work be recovered?
  6. How would you prevent two active instances processing the same job?
  7. What is leader election?
  8. How should scheduled jobs avoid duplicate execution?
  9. How would you manage shared service configuration?
  10. How should load balancers remove unhealthy instances?
  11. What constitutes a readiness check?
  12. How would you test application failover?
  13. How should business users be notified?
  14. What information should be captured during failover?
  15. How would you validate business functionality after recovery?
  16. What happens if services recover before the database?
  17. How should dependent integrations reconnect?
  18. How would queued requests be drained safely?
  19. What post-failover reconciliation is required?
  20. When should service failback occur?
17. Database High Availability20
  1. What database high-availability patterns are available?
  2. How should primary and standby databases be configured?
  3. What is automatic database failover?
  4. What risks accompany automatic failover?
  5. How should replication lag be monitored?
  6. When is zero data loss technically achievable?
  7. What performance cost can synchronous replication introduce?
  8. How would ETRM connections locate the new primary?
  9. How should connection pools respond to failover?
  10. What happens to uncommitted transactions?
  11. How should partially completed business processes recover?
  12. How would you prevent writes to both database copies?
  13. What is a fencing mechanism?
  14. How should read replicas be used?
  15. Can reporting safely use a delayed replica?
  16. How would you validate database failover?
  17. How should data consistency be checked?
  18. What application reconciliation is required?
  19. When should the original primary be reintroduced?
  20. How should failback be planned?
18. Backup and Restore20
  1. How do backup and high availability differ?
  2. What ETRM data and configuration must be backed up?
  3. How should backup frequency be determined?
  4. What is a full, differential or incremental backup?
  5. What is point-in-time recovery?
  6. How should transaction-log backups support recovery objectives?
  7. Where should backups be stored?
  8. Why should backups be isolated from production credentials?
  9. What is an immutable backup?
  10. How would immutable backups mitigate ransomware?
  11. How should backup encryption keys be protected?
  12. How long should backups be retained?
  13. How would regulatory retention affect policy?
  14. How should backup success be monitored?
  15. Why is backup completion not proof of recoverability?
  16. How frequently should restore tests occur?
  17. What should a restore test validate?
  18. How should database and file backups remain consistent?
  19. How would you recover accidentally deleted reference data?
  20. What evidence should backup controls produce?
19. Disaster-Recovery Strategy20
  1. What constitutes a disaster for an ETRM service?
  2. How should disaster scenarios be identified?
  3. What is a business-impact analysis?
  4. What is recovery time objective?
  5. What is recovery point objective?
  6. What is maximum tolerable downtime?
  7. How should RTO and RPO be agreed?
  8. Why should every component not receive identical targets?
  9. How would you select an alternate recovery location?
  10. How should regional correlation risk be considered?
  11. What infrastructure must exist at the recovery site?
  12. What can be provisioned only after disaster declaration?
  13. How should capacity at disaster recovery be sized?
  14. Can reduced-capacity recovery be acceptable?
  15. Which ETRM functions must recover first?
  16. How should recovery waves be defined?
  17. How would external dependencies be recovered?
  18. What happens if a market-data provider cannot serve the recovery site?
  19. How should users connect after recovery?
  20. What constitutes business service restoration?
20. Disaster-Recovery Data Consistency20
  1. How should database replication support disaster recovery?
  2. How does replication differ from backup?
  3. What happens when replication transfers corrupted data?
  4. How should message queues be recovered?
  5. How would you reconcile database and broker recovery points?
  6. What happens to files transferred shortly before failure?
  7. How should in-flight API requests be handled?
  8. How would you identify transactions with indeterminate outcomes?
  9. How should external systems resubmit safely?
  10. What role does idempotency play in disaster recovery?
  11. How should ETRM-generated outbound events be reconciled?
  12. How would you prevent duplicate confirmations or payments?
  13. How should official market-data snapshots be recovered?
  14. How would you preserve batch checkpoints?
  15. What happens if reference data and transactions recover to different times?
  16. How would you establish a common recovery point?
  17. What reconciliation should precede business reopening?
  18. How should unrecoverable differences be managed?
  19. Who should approve resumption of trading?
  20. What evidence should support recovery sign-off?
21. Disaster-Recovery Execution and Testing20
  1. Who should declare a disaster?
  2. What should a disaster-recovery runbook contain?
  3. How should technical and business responsibilities be divided?
  4. What is the required component recovery order?
  5. How should credentials and certificates be activated?
  6. How would DNS and routing be switched?
  7. How should integrations be redirected?
  8. How would users be informed?
  9. What technical validation should follow recovery?
  10. What business validation should follow recovery?
  11. How should positions and P&L be reconciled?
  12. How should settlements and payments be checked?
  13. What is a tabletop exercise?
  14. How does a technical failover test differ from a full business test?
  15. How often should recovery tests occur?
  16. Why should tests include realistic transaction volume?
  17. How would you test an unplanned failover?
  18. How should findings be recorded?
  19. Who owns remediation?
  20. What makes a disaster-recovery test genuinely successful?
22. Cyber Resilience20
  1. How does cyber recovery differ from conventional disaster recovery?
  2. Why may immediate failover be unsafe during a cyberattack?
  3. How would you identify a clean recovery point?
  4. What is an isolated recovery environment?
  5. How should privileged credentials be recovered?
  6. How would you verify that restored systems are uncompromised?
  7. How should immutable backups support cyber recovery?
  8. What if both production and replicated data are corrupted?
  9. How would you rebuild infrastructure from trusted artifacts?
  10. How should ETRM custom code be integrity-checked?
  11. How would you validate database content before reopening?
  12. What security monitoring must operate in recovery?
  13. How should compromised integrations be isolated?
  14. How would new credentials be distributed?
  15. What manual business processes are needed during cyber recovery?
  16. How should accumulated trades be captured after restoration?
  17. What reconciliations are required?
  18. How would you prevent reinfection?
  19. Who should approve return to normal operation?
  20. How should cyber-recovery exercises be conducted?
23. Monitoring and Observability20
  1. What should an ETRM infrastructure dashboard display?
  2. Which host metrics should be monitored?
  3. Which database metrics are essential?
  4. Which network metrics should be retained?
  5. How should storage latency be monitored?
  6. How would you monitor ETRM-service health?
  7. What is synthetic monitoring?
  8. How could synthetic transactions validate business service?
  9. How would you detect a service that is alive but unable to process?
  10. How should correlation identifiers support diagnostics?
  11. How should infrastructure and application logs be centralised?
  12. What alert thresholds should reflect business impact?
  13. How would you prevent alert fatigue?
  14. What is anomaly-based monitoring?
  15. How should certificate expiry be monitored?
  16. How should backup and replication failures be alerted?
  17. How would you monitor disaster-recovery readiness?
  18. What data supports capacity planning?
  19. How long should operational telemetry be retained?
  20. How would observability shorten recovery time?
24. Maintenance, Patching and Upgrades20
  1. How should infrastructure maintenance windows be planned?
  2. How would you patch redundant components without full outage?
  3. What testing should precede operating-system patching?
  4. How should database patching be validated?
  5. How would middleware patches affect ETRM integrations?
  6. How should certificate changes be tested?
  7. What is configuration drift after patching?
  8. How should firmware and hypervisor updates be governed?
  9. What rollback plan should accompany maintenance?
  10. When may rollback be impossible?
  11. How should maintenance interact with end-of-day schedules?
  12. How would you coordinate global business calendars?
  13. What pre-maintenance health checks are required?
  14. What post-maintenance business checks are required?
  15. How should failed maintenance be escalated?
  16. What evidence should accompany completion?
  17. How should vendor support be engaged?
  18. When should a patch be expedited?
  19. What conditions should delay maintenance?
  20. How would you measure patching effectiveness?
25. Capacity and Cost Management20
  1. How would you forecast infrastructure capacity?
  2. Which ETRM growth drivers matter?
  3. How should trade complexity influence sizing?
  4. How do hourly profiles affect storage and compute?
  5. How should additional grid workloads be forecast?
  6. What headroom is required for failure conditions?
  7. How would you size disaster-recovery capacity?
  8. How should month-end and year-end peaks be considered?
  9. When should capacity be added?
  10. How would you detect capacity-risk trends?
  11. What is cloud cost allocation?
  12. How should ETRM costs be attributed?
  13. How would you optimise cost without compromising resilience?
  14. When is reserved capacity appropriate?
  15. When can temporary compute reduce cost?
  16. How should storage lifecycle policies be used?
  17. What hidden network costs should be considered?
  18. How would you compare on-premises and cloud total cost?
  19. What business assumptions should accompany the comparison?
  20. When should cost concerns trigger architecture redesign?
26. Architecture Scenarios20
  1. ETRM is available, but users cannot connect after a load-balancer failover. What would you investigate?
  2. Database failover succeeds, but services retain stale connections. How should recovery work?
  3. Both redundant services run the same scheduled batch. What control is missing?
  4. Grid workers remain healthy, but throughput collapses. Which shared dependencies should be checked?
  5. A shared file system fails and stops all interfaces. How would you remove the single point of failure?
  6. Disaster recovery restores the database but loses recent messages. What reconciliation is required?
  7. The recovery site starts successfully but cannot receive market data. Was the service recovered?
  8. A backup completes daily but has never been restored. Is the control effective?
  9. Synchronous cross-region replication causes unacceptable trade-entry latency. How would you frame the trade-off?
  10. Cloud autoscaling adds workers after end-of-day has already breached its SLA. What should change?
  11. A security agent consumes significant CPU during valuation runs. How should this be resolved?
  12. Infrastructure monitoring is green, but ETRM cannot value trades. What monitoring layer is missing?
  13. The disaster-recovery environment has half production capacity. When could this be acceptable?
  14. Production and recovery sites share the same identity provider. What dependency risk exists?
  15. A regional cloud outage also affects the configured backup store. What design principle failed?
  16. An automated restart repeatedly clears symptoms without preserving diagnostics. How would you correct operations?
  17. DNS caching delays failover for several hours. What should have been designed and tested?
  18. Ransomware corruption replicates immediately to disaster recovery. What recovery capability is required?
  19. The business requests zero downtime and zero data loss across regions. What costs and technical constraints must be challenged?
  20. What distinguishes an ETRM infrastructure architect from a cloud engineer, database administrator or disaster-recovery manager?
Configuration Management, Testing and CI/CD25 sections · 500 questions
1. Configuration-Management Fundamentals20
  1. What constitutes configuration in an ETRM implementation?
  2. How does configuration differ from reference data, code and infrastructure?
  3. Why should ETRM configuration be treated as a controlled software asset?
  4. Which configuration domains are business-critical?
  5. How would you inventory existing ETRM configuration?
  6. What metadata should accompany each configuration item?
  7. How should configuration ownership be assigned?
  8. How would you establish a configuration baseline?
  9. What is configuration drift?
  10. How would you detect drift between environments?
  11. How should configuration dependencies be documented?
  12. How would you identify orphaned configuration?
  13. How should duplicate configuration be rationalised?
  14. What is the difference between global and desk-specific configuration?
  15. How would you prevent unnecessary configuration variants?
  16. How should configuration standards be governed?
  17. What is a configuration-management plan?
  18. How should emergency configuration changes be handled?
  19. How would you preserve historical configuration states?
  20. What evidence demonstrates effective configuration control?
2. Configuration Classification and Ownership20
  1. How would you classify ETRM configuration by domain?
  2. Which configuration should business teams own?
  3. Which configuration should technology own?
  4. Who should own instruments and deal templates?
  5. Who should own curves, indexes and market-data mappings?
  6. Who should own portfolios and organisational structures?
  7. Who should own settlement and accounting configuration?
  8. Who should own simulations and reports?
  9. How should shared configuration be governed?
  10. What happens when multiple teams claim ownership?
  11. How should criticality influence approval requirements?
  12. Which changes require independent review?
  13. How would you document the authorised use of each item?
  14. How should configuration naming conventions be designed?
  15. How would you prevent free-text configuration from becoming uncontrolled?
  16. How should effective dates be managed?
  17. How should obsolete items be retired?
  18. How would you identify configuration still referenced by active trades?
  19. What is the role of a configuration owner during an upgrade?
  20. How should ownership transfer when teams reorganise?
3. Source Control20
  1. Which ETRM artifacts should be stored in source control?
  2. How should the platform scripting language and Java code be organised?
  3. How should SQL, report and interface artifacts be stored?
  4. Can all ETRM configuration be represented as text?
  5. How would you manage configuration that is difficult to diff?
  6. How should exported configuration packages be versioned?
  7. What repository structure would you use?
  8. How should shared libraries be separated from project code?
  9. What branching strategy is appropriate?
  10. How should release branches be managed?
  11. What is trunk-based development?
  12. When could short-lived feature branches be preferable?
  13. How should commit messages support traceability?
  14. How would you associate changes with requirements and defects?
  15. How should peer review be enforced?
  16. Who may approve production-bound changes?
  17. How would you protect the main branch?
  18. How should binary artifacts be handled?
  19. What risks arise from storing credentials in source control?
  20. How would you recover when production code is absent from the repository?
4. Versioning and Dependency Management20
  1. How should ETRM custom components be versioned?
  2. What is semantic versioning?
  3. When is semantic versioning useful for internal components?
  4. How should configuration-package versions be assigned?
  5. How would you identify the exact version running in production?
  6. What should a release manifest contain?
  7. How should dependencies among scripts be declared?
  8. How should dependencies on user tables be managed?
  9. How should dependencies on ETRM APIs be recorded?
  10. How would you manage third-party Java libraries?
  11. What risks arise from unpinned dependency versions?
  12. How would you prevent conflicting library versions?
  13. How should external API versions be tracked?
  14. How would you identify deprecated functions before an upgrade?
  15. What is a software bill of materials?
  16. Should custom ETRM components maintain one?
  17. How should dependency vulnerabilities be monitored?
  18. How would you verify artifact integrity?
  19. What is artifact provenance?
  20. How should dependency changes be regression-tested?
5. Environment Strategy20
  1. Which ETRM environments should an enterprise maintain?
  2. What is the purpose of development, test, UAT and production environments?
  3. When is a dedicated integration-test environment required?
  4. When is a performance environment necessary?
  5. Should disaster recovery be treated as a test environment?
  6. How should environments differ in scale?
  7. Which characteristics must remain production-like?
  8. How would you manage environment-specific identifiers?
  9. How should endpoints and credentials differ?
  10. How would you prevent production connections from lower environments?
  11. How should business dates be controlled?
  12. How should market data be provided to testing?
  13. What are the risks of copying production data?
  14. How should copied data be masked?
  15. How would you manage test-user entitlements?
  16. How should shared testing environments be scheduled?
  17. What causes environment contention?
  18. How would you refresh an environment?
  19. What controls should surround refresh?
  20. How would you prove that environments have not drifted?
6. Change-Management Process20
  1. What should initiate an ETRM change?
  2. How should requirements be assessed?
  3. What belongs in an impact assessment?
  4. How would you identify affected products and processes?
  5. How should architecture review participate?
  6. Which changes require formal design approval?
  7. How should risk and criticality be assessed?
  8. What is a standard change?
  9. What is a normal change?
  10. What is an emergency change?
  11. How should change categories affect approval?
  12. What evidence should accompany a change request?
  13. How should segregation of duties apply?
  14. Who should approve business-rule changes?
  15. Who should approve infrastructure changes?
  16. How should implementation and rollback plans be reviewed?
  17. What is a change collision?
  18. How would you identify conflicting releases?
  19. What should a change advisory board evaluate?
  20. When should a change be rejected?
7. Requirements Traceability20
  1. What is requirements traceability?
  2. How would you link requirements to designs?
  3. How should designs link to configuration and code?
  4. How should test cases link back to requirements?
  5. What is a requirements traceability matrix?
  6. Which requirements require negative test cases?
  7. How would you trace regulatory requirements?
  8. How should non-functional requirements be represented?
  9. How would you ensure every requirement is tested?
  10. How should scope changes affect test coverage?
  11. What happens when code has no corresponding requirement?
  12. How would you handle undocumented legacy behaviour?
  13. How should defects link to failed tests?
  14. How should acceptance criteria be written?
  15. What makes an acceptance criterion objectively testable?
  16. How would you trace production verification?
  17. Who owns traceability completeness?
  18. How should evidence be retained?
  19. How would auditors use traceability?
  20. What indicates that traceability is only administrative rather than effective?
8. Test Strategy and Governance20
  1. What should an ETRM test strategy contain?
  2. How should testing reflect business risk?
  3. What are the principal ETRM testing levels?
  4. How do unit, component, integration, system and acceptance tests differ?
  5. What is functional testing?
  6. What is non-functional testing?
  7. What is regression testing?
  8. What is smoke testing?
  9. What is exploratory testing?
  10. How should positive and negative testing differ?
  11. How would you define test entry criteria?
  12. How would you define exit criteria?
  13. What is a test oracle?
  14. How should expected results be established independently?
  15. Who should approve the test strategy?
  16. How should test independence be achieved?
  17. What should determine test depth?
  18. How should defects be classified?
  19. When can unresolved defects be accepted?
  20. What evidence demonstrates release readiness?
9. Unit and Component Testing20
  1. What ETRM logic can be unit-tested?
  2. How would you isolate business logic from ETRM APIs?
  3. How do adapters and wrappers improve testability?
  4. How would you test the platform scripting language components?
  5. How would you test Java extensions?
  6. What dependencies should be mocked?
  7. What are the limitations of mocking?
  8. How would you test table-processing logic?
  9. How should database queries be tested?
  10. How would you test validation rules?
  11. How should exception handling be tested?
  12. How would you test resource cleanup?
  13. How should logging behaviour be verified?
  14. What code-coverage target is meaningful?
  15. Why is high code coverage not proof of quality?
  16. How should boundary conditions be tested?
  17. How would you test null and missing values?
  18. How should repeated execution be tested?
  19. What makes a unit test deterministic?
  20. When should a component test require a real ETRM environment?
10. Functional Product Testing20
  1. How would you test a new ETRM instrument?
  2. What should a golden transaction contain?
  3. How should fixed and floating legs be tested?
  4. How would you test multi-leg structures?
  5. How should trade amendments be tested?
  6. How would you test cancellation and termination?
  7. How should novation and partial unwind be tested?
  8. How would you test physical delivery profiles?
  9. How should provisional pricing be tested?
  10. How would you test corrected fixings?
  11. How should unit conversions be validated?
  12. How would you test business-day conventions?
  13. How should daylight-saving transitions be tested?
  14. How would you test negative commodity prices?
  15. How should zero and negative quantities be handled?
  16. How would you test transaction templates?
  17. How should product restrictions be tested?
  18. How would you verify audit history?
  19. Which lifecycle stages must a new product traverse?
  20. What proves that a product is operationally complete?
11. Valuation and Risk Testing20
  1. How would you validate ETRM valuation independently?
  2. What constitutes a valuation benchmark?
  3. How should cash flows be compared?
  4. How would you validate discounting?
  5. How should forward-curve use be tested?
  6. How would you test partially fixed transactions?
  7. How should multicurrency valuation be tested?
  8. How would you validate option models?
  9. How should Greeks be tested?
  10. What is sensitivity bump testing?
  11. How would you test position aggregation?
  12. How should basis and location risk be validated?
  13. How would you test P&L attribution?
  14. How should VaR results be regression-tested?
  15. How would you test stress scenarios?
  16. What tolerances are acceptable?
  17. How should numerical tolerances be justified?
  18. What happens when a model upgrade legitimately changes values?
  19. How should model-version differences be documented?
  20. What evidence should model validators approve?
12. Middle- and Back-Office Testing20
  1. How would you test trade-validation workflows?
  2. How should maker-checker controls be tested?
  3. How would you test confirmation generation?
  4. How should electronic matching be tested?
  5. How would you validate settlement events?
  6. How should netting rules be tested?
  7. How would you test provisional and final invoices?
  8. How should credit and debit notes be tested?
  9. How would you validate payment instructions?
  10. How should duplicate-payment prevention be tested?
  11. How would you test accounting-event generation?
  12. How should balanced postings be verified?
  13. How would you test rejected accounting entries?
  14. How should physical actuals affect invoicing?
  15. How would you test collateral or margin processing?
  16. How should business cut-offs be tested?
  17. How would you validate end-of-day completeness?
  18. How should failed events be recovered?
  19. What reconciliations must pass?
  20. Who should provide business acceptance?
13. Integration and Contract Testing20
  1. How would you test an inbound trade interface?
  2. What is API contract testing?
  3. What is consumer-driven contract testing?
  4. How should message schemas be validated?
  5. How would you test backward compatibility?
  6. How should mandatory and optional fields be tested?
  7. How would you test duplicate messages?
  8. How should out-of-order amendments be tested?
  9. How would you test timeouts with indeterminate outcomes?
  10. How should retry behaviour be verified?
  11. How would you test dead-letter processing?
  12. How should controlled replay be tested?
  13. How would you verify idempotency?
  14. How should partial batch failures be tested?
  15. How would you test missing reference data?
  16. How should external systems be simulated?
  17. When is a real external dependency necessary?
  18. How would you test reconciliation?
  19. How should interface-volume testing be conducted?
  20. What proves end-to-end delivery?
14. Data and Migration Testing20
  1. How would you test ETRM data migration?
  2. How should source-to-target mappings be validated?
  3. What is data profiling?
  4. How would you identify source-data anomalies?
  5. How should defaulted values be tested?
  6. How would you validate reference-data dependencies?
  7. How should duplicate records be detected?
  8. What control totals should be compared?
  9. How would you reconcile transaction counts?
  10. Why are record counts alone insufficient?
  11. How should quantities, cash flows and positions be reconciled?
  12. How would you compare valuation and P&L?
  13. How should open lifecycle events be tested?
  14. How would you prevent duplicate downstream processing?
  15. How should rejected records be tracked?
  16. What is a migration reconciliation dashboard?
  17. How would you perform repeatable migration rehearsals?
  18. How should migration defects be prioritised?
  19. What criteria should block cut-over?
  20. What evidence supports migration sign-off?
15. Regression Testing20
  1. What should an ETRM regression suite cover?
  2. How would you select representative products?
  3. What are golden trades?
  4. How should golden portfolios be maintained?
  5. How would you include unusual lifecycle states?
  6. How should historical production defects enter regression?
  7. How would you test unchanged functionality?
  8. How should reference-data changes affect scope?
  9. How should an legacy-to-modern ETRM upgrade affect regression depth?
  10. How would you compare large result datasets?
  11. What is tolerance-based comparison?
  12. How should expected legitimate differences be handled?
  13. How would you detect unintended differences?
  14. How should regression failures be triaged?
  15. Which tests should execute on every build?
  16. Which tests may run nightly?
  17. Which tests should run before release?
  18. How would you keep regression runtime manageable?
  19. Who owns regression-suite maintenance?
  20. What indicates that a regression suite has become ineffective?
16. Test Data Management20
  1. What makes ETRM test data representative?
  2. How would you create a controlled trade library?
  3. Which commodity products must be represented?
  4. How should lifecycle states be covered?
  5. How would you include complex and high-volume profiles?
  6. How should market-data scenarios be prepared?
  7. How would you create deterministic fixings and curves?
  8. Why should tests avoid uncontrolled live market data?
  9. How should counterparty and settlement data be anonymised?
  10. What production information must never enter testing?
  11. How would you generate synthetic transactions?
  12. How should test-data versions align with test cases?
  13. How would you reset test data between runs?
  14. What is test-data pollution?
  15. How should parallel testers avoid collisions?
  16. How would you manage business dates?
  17. How should expired or effective-dated data be tested?
  18. Who owns the test-data catalogue?
  19. How should test data be retained?
  20. What controls prove compliance with privacy requirements?
17. Performance, Resilience and Security Testing20
  1. How do load, stress, volume, spike and soak tests differ?
  2. How would you test end-of-day performance?
  3. How should grid scalability be tested?
  4. How would you establish representative transaction volume?
  5. How should concurrent users be simulated?
  6. How would you validate performance after configuration changes?
  7. What is failure-injection testing?
  8. How would you test service failover?
  9. How should database failover be tested?
  10. How would you test batch restart?
  11. How should disaster-recovery testing integrate with release assurance?
  12. What security testing should custom code undergo?
  13. How would you test negative entitlements?
  14. How should segregation of duties be verified?
  15. How would you test API authentication and authorisation?
  16. What vulnerability testing applies to third-party libraries?
  17. How should sensitive information in logs be tested?
  18. What performance or security findings must block release?
  19. How should non-functional evidence be retained?
  20. Who accepts residual non-functional risk?
18. Test Automation20
  1. Which ETRM tests are suitable for automation?
  2. Which tests should remain manual?
  3. How would you prioritise automation?
  4. What is the automation pyramid?
  5. Why should end-to-end UI tests not dominate?
  6. How would you automate API tests?
  7. How should database-result comparisons be automated?
  8. How would you automate valuation reconciliation?
  9. How should large tables be compared efficiently?
  10. How would you automate lifecycle processing?
  11. How should business dates be controlled?
  12. How would you automate negative test cases?
  13. What makes automated tests repeatable?
  14. How should test failures retain evidence?
  15. How would you prevent flaky tests?
  16. What causes ETRM test automation to become brittle?
  17. How should reusable test libraries be designed?
  18. How should automated-test code be reviewed?
  19. How would you measure automation effectiveness?
  20. When should an automated test be retired?
19. CI Pipeline Design20
  1. What should continuous integration mean for ETRM development?
  2. What should trigger a CI pipeline?
  3. Which validations should run on every commit?
  4. How should compilation and syntax checking work?
  5. How would you introduce code formatting and linting?
  6. What static analysis should be applied?
  7. How should unit tests execute?
  8. How should dependency vulnerabilities be scanned?
  9. How would you scan for embedded secrets?
  10. What is a quality gate?
  11. Which failures should block merging?
  12. How should build artifacts be produced?
  13. Why should artifacts be built once and promoted?
  14. How would you create reproducible builds?
  15. How should artifacts be signed or checksummed?
  16. Where should artifacts be stored?
  17. What retention should apply?
  18. How should pipeline permissions be controlled?
  19. How would you protect CI credentials?
  20. What evidence should a successful build produce?
20. Continuous Delivery and Deployment20
  1. How does continuous delivery differ from continuous deployment?
  2. Is fully automatic production deployment appropriate for ETRM?
  3. Which deployment stages can be automated safely?
  4. How should approvals be inserted into pipelines?
  5. How would you package scripts, configuration and database changes?
  6. How should deployment order be determined?
  7. How would you validate dependencies before deployment?
  8. How should environment-specific values be injected?
  9. What is a deployment manifest?
  10. How should pre-deployment checks work?
  11. How would you detect conflicting changes?
  12. How should services be stopped or drained?
  13. Which components require restart?
  14. How should database changes be deployed?
  15. How would you automate post-deployment smoke tests?
  16. How should deployment status be communicated?
  17. What telemetry should be monitored after release?
  18. When should automatic rollback occur?
  19. When is automatic rollback unsafe?
  20. What makes an ETRM deployment production-safe?
21. Release and Deployment Strategies20
  1. What is a big-bang deployment?
  2. When could phased deployment be used?
  3. What is blue-green deployment?
  4. Where might blue-green be difficult for ETRM?
  5. What is canary deployment?
  6. Which ETRM components could support canary techniques?
  7. How would database compatibility constrain deployment?
  8. What is backward-compatible configuration?
  9. How should interface schema changes be staged?
  10. How would consumers migrate between API versions?
  11. How should parallel processing be reconciled?
  12. What is a dark launch?
  13. How could feature flags be used?
  14. What risks arise from long-lived feature flags?
  15. How should cut-over activities be sequenced?
  16. What is a deployment freeze?
  17. How should global business calendars affect releases?
  18. How would you avoid end-of-day disruption?
  19. What post-release observation period is appropriate?
  20. When should a release be backed out?
22. Rollback, Recovery and Remediation20
  1. What should an ETRM rollback plan contain?
  2. Which changes are easily reversible?
  3. Which changes are difficult to reverse?
  4. Why may database rollback be dangerous?
  5. What happens when new trades use changed configuration?
  6. How should processed lifecycle events affect rollback?
  7. How would you handle faulty accounting output?
  8. How should erroneous payment messages be contained?
  9. What is forward remediation?
  10. When is forward remediation safer than rollback?
  11. How would you identify transactions affected by a defective release?
  12. How should impacted data be corrected?
  13. Who should approve remediation?
  14. How should correction scripts be controlled?
  15. What testing should correction scripts undergo?
  16. How would you prevent correction from creating new errors?
  17. What reconciliations should follow recovery?
  18. How should stakeholders be informed?
  19. What audit evidence should be retained?
  20. How should lessons influence future deployment design?
23. Release Governance20
  1. What should a production-readiness review cover?
  2. Who should participate?
  3. What functional evidence is required?
  4. What non-functional evidence is required?
  5. How should open defects be presented?
  6. Who may accept residual risk?
  7. What is a release go/no-go decision?
  8. Which conditions should automatically produce no-go?
  9. How should vendor dependencies be assessed?
  10. What operational documentation must exist?
  11. How should support teams demonstrate readiness?
  12. What monitoring and alerts must be operational?
  13. How should rollback feasibility be confirmed?
  14. What business approvals are required?
  15. How should release communications be managed?
  16. What is an early-life-support period?
  17. How should incidents during early life be handled?
  18. When should a release be declared stable?
  19. What metrics should assess release quality?
  20. How should failed releases improve governance?
24. Audit, Compliance and Evidence20
  1. What CI/CD activities should be auditable?
  2. How should code-review evidence be retained?
  3. How should approvals be linked to artifacts?
  4. How would you prove that the tested artifact reached production?
  5. What is artifact provenance?
  6. How should deployment identities be controlled?
  7. How would you prevent manual unrecorded deployment?
  8. How should emergency changes be evidenced?
  9. What records should demonstrate segregation of duties?
  10. How should automated test results be retained?
  11. How should failed quality gates be recorded?
  12. What evidence supports configuration reconciliation?
  13. How would you demonstrate environment integrity?
  14. How should privileged deployment activity be monitored?
  15. What retention period should apply to release evidence?
  16. How should auditors retrieve evidence?
  17. How would you test the effectiveness of deployment controls?
  18. What indicates that controls are ceremonial?
  19. How should recurring audit findings be remediated?
  20. Who owns the end-to-end change-control framework?
25. Architecture Scenarios20
  1. Test and production contain different portfolio identifiers. How would you design deployment?
  2. A developer changes production configuration manually and forgets lower environments. What failed?
  3. An automated deployment succeeds technically but generates incorrect settlement events. What was missing?
  4. A test suite passes, but it uses only simple financial trades. Is release evidence sufficient?
  5. A faulty instrument change affects existing trades. How would you identify and remediate them?
  6. Rollback restores code but cannot reverse generated payments. What recovery approach is required?
  7. Every release requires several undocumented manual steps. What architectural risk exists?
  8. Regression testing takes five days and blocks frequent releases. How would you optimise it?
  9. Automated tests fail intermittently without product defects. How should flaky tests be handled?
  10. A migration reconciles record counts but not valuation. Should go-live proceed?
  11. An emergency production fix has no peer review. What controls are required?
  12. A pipeline rebuilds an artifact separately for each environment. What integrity risk does this create?
  13. A database script has no rollback because it transforms existing records. What should the release plan contain?
  14. An upgrade changes valuation legitimately, but the regression suite flags every trade. How should differences be classified?
  15. Configuration exports cannot be meaningfully compared. How would you establish control?
  16. Developers have no representative test environment. What delivery risks arise?
  17. A deployment works in UAT but fails under production volume. Which testing layer was inadequate?
  18. Business users approve screens but do not test accounting or settlement. Is the product production-ready?
  19. Management demands fully automatic ETRM production deployment. What limitations and safeguards would you raise?
  20. What distinguishes an ETRM DevOps architect from a release manager, tester or automation engineer?
Upgrade, Migration and Production Support27 sections · 540 questions
1. Upgrade Strategy and Objectives20
  1. Why do organisations upgrade ETRM?
  2. How would you distinguish mandatory and discretionary upgrade drivers?
  3. What business outcomes should an upgrade deliver?
  4. How would you assess the risks of remaining on an older version?
  5. What should an legacy-to-modern ETRM upgrade strategy contain?
  6. How would you define upgrade scope?
  7. Should an upgrade include business transformation?
  8. What risks arise from combining upgrade and major redesign?
  9. When is a technical upgrade preferable?
  10. When should remediation be completed before upgrading?
  11. How would you assess vendor support timelines?
  12. What external platform dependencies influence version selection?
  13. How should regulatory deadlines influence the plan?
  14. What is an upgrade-readiness assessment?
  15. Who should participate in upgrade governance?
  16. What architecture decisions must be made early?
  17. How would you establish success criteria?
  18. What would justify delaying an upgrade?
  19. What conditions should prevent starting implementation?
  20. How would you communicate upgrade value to executives?
2. Current-State Discovery20
  1. How would you inventory the existing ETRM estate?
  2. Which platform components should be documented?
  3. How would you identify every custom script?
  4. How should Java extensions and third-party libraries be inventoried?
  5. How would you catalogue interfaces?
  6. How should reports and simulations be assessed?
  7. How would you inventory user tables and custom schemas?
  8. How should instrument and workflow customisations be identified?
  9. How would you discover undocumented scheduled jobs?
  10. How should environment-specific configuration be captured?
  11. How would you identify obsolete components?
  12. How would you identify duplicate functionality?
  13. What production statistics should support discovery?
  14. How should user and service-account usage be assessed?
  15. How would you identify unsupported technical components?
  16. What is the role of dependency mapping?
  17. How would you validate the inventory's completeness?
  18. What if source code cannot be located?
  19. How should unknown ownership be resolved?
  20. What output should a current-state assessment produce?
3. Compatibility and Impact Assessment20
  1. How would you assess target-version compatibility?
  2. Which release documentation should be reviewed?
  3. How would you identify deprecated or removed APIs?
  4. How should changed standard behaviour be analysed?
  5. Which customisations create the greatest upgrade risk?
  6. How would you assess database compatibility?
  7. How should operating-system compatibility be validated?
  8. How should Java-runtime compatibility be checked?
  9. How would you assess browser or desktop-client compatibility?
  10. How should integration middleware be assessed?
  11. What risks arise from third-party library changes?
  12. How would you evaluate authentication compatibility?
  13. How should reporting tools be assessed?
  14. How would you identify changed valuation behaviour?
  15. How should lifecycle-event changes be analysed?
  16. How would you assess configuration-conversion requirements?
  17. What is a compatibility matrix?
  18. How should severity and remediation priority be assigned?
  19. Which findings require proof-of-concept testing?
  20. What should the final impact assessment contain?
4. Customisation Rationalisation20
  1. Why should customisations be reviewed before an upgrade?
  2. How would you classify custom components?
  3. Which customisations should be retained?
  4. Which should be replaced by standard functionality?
  5. Which should be redesigned externally?
  6. Which should be retired?
  7. How would you establish whether a script is still used?
  8. What risks arise from unused custom code?
  9. How would you identify duplicated business logic?
  10. How should tactical solutions be handled?
  11. What makes a customisation upgrade-safe?
  12. How would you reduce dependency on internal schemas?
  13. How should direct database integrations be remediated?
  14. When should the platform scripting language be replaced by compiled Java?
  15. When should custom logic move to middleware?
  16. How would you quantify technical debt?
  17. How should business owners approve retirement?
  18. How would you test that removed functionality is genuinely unused?
  19. How should rationalisation benefits be measured?
  20. What would prevent rationalisation during an upgrade?
5. Upgrade Environment Strategy20
  1. Which environments are required for an legacy-to-modern ETRM upgrade?
  2. What is the purpose of an upgrade sandbox?
  3. When is a dedicated remediation environment required?
  4. How should development and system-test environments differ?
  5. Why is a production-like performance environment necessary?
  6. How should UAT be structured?
  7. What environment should support migration rehearsals?
  8. How should disaster recovery be upgraded and tested?
  9. How would you sequence environment upgrades?
  10. How should environment refreshes be controlled?
  11. What production data may be copied?
  12. How should copied data be masked?
  13. How would you preserve repeatable test conditions?
  14. How should market-data snapshots be prepared?
  15. How should business dates be controlled?
  16. How would you detect environment drift?
  17. What infrastructure differences must be documented?
  18. How should environment access be restricted?
  19. How would you manage concurrent business projects?
  20. What makes an upgrade environment fit for purpose?
6. Technical Upgrade Execution20
  1. What are the major stages of a technical legacy-to-modern ETRM upgrade?
  2. How should installation prerequisites be validated?
  3. How would you manage database-conversion steps?
  4. What backups are required before conversion?
  5. How should conversion logs be reviewed?
  6. How would you identify partially converted components?
  7. What should happen when a conversion step fails?
  8. How should repeated upgrade rehearsals be automated?
  9. How would you measure conversion duration?
  10. How should configuration transformations be managed?
  11. How would you deploy recompiled custom components?
  12. How should third-party libraries be upgraded?
  13. How would you validate service startup?
  14. What technical smoke tests are required?
  15. How should application and database versions be confirmed?
  16. How would you verify installed patches?
  17. What should an upgrade execution runbook contain?
  18. How should manual steps be reduced?
  19. What evidence should each execution stage retain?
  20. How would you determine technical upgrade completion?
7. Functional Regression Testing20
  1. What should an legacy-to-modern ETRM upgrade regression suite cover?
  2. How would you select representative golden trades?
  3. Which Front Office functions must be tested?
  4. Which Middle Office controls must be tested?
  5. Which Back Office processes must be tested?
  6. How should trade amendments be tested?
  7. How would you test cancellations and terminations?
  8. How should confirmations be validated?
  9. How would you test settlements and invoices?
  10. How should payment instructions be tested?
  11. How would you test accounting entries?
  12. How should collateral and margin processes be tested?
  13. How would you validate market-data loading?
  14. How should curves and fixings be tested?
  15. How would you test reports and simulations?
  16. How should user entitlements be verified?
  17. What negative testing is required?
  18. How should historical production defects be included?
  19. How would regression failures be triaged?
  20. What evidence supports functional acceptance?
8. Valuation and Risk Regression20
  1. How would you compare pre-upgrade and post-upgrade valuation?
  2. Which market-data snapshot should be used?
  3. How should trade populations be selected?
  4. Why should cash flows be compared before present value?
  5. How would you compare positions?
  6. How should P&L be reconciled?
  7. How would you validate Greeks?
  8. How should VaR and stress results be compared?
  9. What numerical tolerance is acceptable?
  10. How should tolerances be justified?
  11. What can create legitimate valuation differences?
  12. How would you distinguish intended model change from defect?
  13. How should rounding differences be handled?
  14. How would you isolate instrument-specific differences?
  15. How should unvalued trades be investigated?
  16. What is a valuation-difference waterfall?
  17. Who should approve expected differences?
  18. How should differences be documented?
  19. Which differences must block production?
  20. How would you demonstrate overall valuation equivalence?
9. Non-Functional Upgrade Testing20
  1. What non-functional testing does an upgrade require?
  2. How would you establish the current performance baseline?
  3. Which interactive processes should be measured?
  4. How should end-of-day runtime be compared?
  5. How would you test grid scalability?
  6. How should interface throughput be tested?
  7. What is soak testing?
  8. How would you identify memory degradation?
  9. How should database-performance changes be analysed?
  10. How would you test concurrent workloads?
  11. What availability and failover testing is required?
  12. How should disaster recovery be tested?
  13. How would you validate security hardening?
  14. How should vulnerability findings be handled?
  15. How would you verify authentication and entitlements?
  16. What accessibility or usability changes require testing?
  17. How should infrastructure sizing be reassessed?
  18. What degradation should block go-live?
  19. Who accepts residual non-functional risk?
  20. What evidence supports non-functional readiness?
10. Data-Migration Strategy20
  1. When does an ETRM initiative require data migration?
  2. How does upgrade conversion differ from business-data migration?
  3. What should a migration strategy contain?
  4. How would you define migration scope?
  5. Which data should be migrated?
  6. Which historical data may remain archived?
  7. How should active and matured trades be treated differently?
  8. What is the source of truth during migration?
  9. How would you establish source-to-target mappings?
  10. How should transformation rules be documented?
  11. How would you manage data cleansing?
  12. What is data enrichment?
  13. How should default values be governed?
  14. How would you preserve legacy identifiers?
  15. How should transaction lineage be retained?
  16. What is a migration wave?
  17. When is phased migration appropriate?
  18. When is big-bang migration preferable?
  19. What dependencies determine migration sequence?
  20. What would make a migration strategy unacceptable?
11. Reference-Data Migration20
  1. Why must reference data precede transactions?
  2. Which reference-data domains must be migrated?
  3. How would you map legal entities and counterparties?
  4. How should duplicate counterparties be resolved?
  5. How would you migrate portfolios and organisational structures?
  6. How should products and instruments be mapped?
  7. How would you migrate commodities and locations?
  8. How should units and conversion factors be handled?
  9. How would you migrate indexes and calendars?
  10. How should settlement instructions be migrated securely?
  11. How would you migrate accounting mappings?
  12. How should effective dates be preserved?
  13. What happens when source values have no target equivalent?
  14. How should retired records be represented?
  15. How would you validate reference-data completeness?
  16. What should block transaction loading?
  17. How should reference-data ownership support sign-off?
  18. How would you reconcile reference data?
  19. What security controls apply to sensitive migrations?
  20. What evidence supports reference-data approval?
12. Transaction and Lifecycle Migration20
  1. How would you migrate active transactions?
  2. Should trades be recreated or transformed directly?
  3. Why should supported loading mechanisms be used?
  4. How would you preserve transaction economics?
  5. How should multi-leg structures be migrated?
  6. How would you migrate daily and hourly profiles?
  7. How should partially fixed transactions be handled?
  8. How would you migrate amended transactions?
  9. How should cancellations and terminations be represented?
  10. How would you preserve parent-child relationships?
  11. How should novations and partial unwinds be migrated?
  12. How would you migrate accrued and settled cash flows?
  13. How should open confirmations be handled?
  14. How would you migrate uninvoiced settlement events?
  15. How should unpaid invoices be migrated?
  16. How would you prevent duplicate payments?
  17. How should open accounting events be treated?
  18. How would you prevent duplicate downstream output?
  19. What transactions require manual review?
  20. What proves transaction migration completeness?
13. Historical-Data Migration20
  1. How much historical data should move into ETRM?
  2. What business requirements determine history?
  3. How should regulatory retention influence scope?
  4. When should history move to a separate archive?
  5. How would users access archived history?
  6. How should historical transactions remain traceable?
  7. How would you preserve historical market data?
  8. Should all simulation results be migrated?
  9. How should official historical P&L be retained?
  10. How would you preserve audit trails?
  11. What happens when legacy history lacks required target fields?
  12. How should data-quality limitations be disclosed?
  13. How would you handle obsolete products?
  14. How should historical identifiers remain searchable?
  15. How would you prevent future-data leakage into historical reporting?
  16. How should archived data be secured?
  17. How would you test archive retrieval?
  18. What service levels should apply to archived data?
  19. Who approves historical-data disposition?
  20. What evidence demonstrates compliant retention?
14. Migration Tooling and Automation20
  1. What capabilities should migration tooling provide?
  2. How should extraction be automated?
  3. How would you create repeatable transformation pipelines?
  4. How should mapping rules be versioned?
  5. How would you validate data before loading?
  6. How should rejected records be quarantined?
  7. How would you support controlled replay?
  8. How should migration batches be identified?
  9. How would you make loads idempotent?
  10. How should checkpoints support restart?
  11. What control totals should every stage produce?
  12. How would you prevent parallel-load conflicts?
  13. How should database and application load be monitored?
  14. How would you estimate migration duration?
  15. How should sensitive data be protected?
  16. What logging should migration tools provide?
  17. How should technical and business errors differ?
  18. How would you prove the deployed migration version?
  19. How should migration code pass CI/CD controls?
  20. When would manual migration be unacceptable?
15. Migration Reconciliation20
  1. What is migration reconciliation?
  2. Why are transaction counts insufficient?
  3. Which quantitative control totals should be compared?
  4. How would you reconcile quantities?
  5. How should notional and cash flows be compared?
  6. How would you reconcile present value and P&L?
  7. How should positions be compared?
  8. How would you reconcile open lifecycle events?
  9. How should settlement and invoice status be validated?
  10. How would you reconcile accounting balances?
  11. How should reference-data mappings be checked?
  12. What is record-level reconciliation?
  13. What is aggregate reconciliation?
  14. How should tolerances be established?
  15. How would exceptions be classified?
  16. How should breaks be assigned and aged?
  17. Who should approve unresolved differences?
  18. Which differences must block cutover?
  19. How should reconciliation evidence be retained?
  20. What constitutes migration sign-off?
16. Migration Rehearsals20
  1. Why are migration rehearsals necessary?
  2. How many rehearsals should be planned?
  3. What should each rehearsal validate?
  4. How would you establish consistent source snapshots?
  5. How should environments be reset between rehearsals?
  6. How would you measure extraction, transformation and load duration?
  7. How should reconciliation duration be measured?
  8. How would you identify manual bottlenecks?
  9. What is a dress rehearsal?
  10. How closely should it reproduce cutover?
  11. How should production-like volume be represented?
  12. How would you test restart after partial failure?
  13. How should late source changes be simulated?
  14. How would you test rollback?
  15. How should downstream integrations participate?
  16. How would business users validate migrated transactions?
  17. What findings should enter the cutover plan?
  18. How should rehearsal defects be tracked?
  19. What exit criteria should the final rehearsal satisfy?
  20. When should a failed rehearsal delay go-live?
17. Cutover Planning20
  1. What should an ETRM cutover plan contain?
  2. How should cutover ownership be assigned?
  3. What is the required activity sequence?
  4. How should trading freeze be managed?
  5. How would you control late transactions?
  6. How should final source extraction be authorised?
  7. What pre-cutover backups are required?
  8. How should migration checkpoints be defined?
  9. What are go/no-go decision points?
  10. How should elapsed time be monitored?
  11. What happens when an activity exceeds its window?
  12. How should cross-system dependencies be coordinated?
  13. How would you validate market data?
  14. How should users and entitlements be activated?
  15. What technical smoke tests are required?
  16. What business validation is required?
  17. How should interfaces be released?
  18. How should downstream outputs be controlled?
  19. Who authorises reopening for trading?
  20. What evidence should cutover retain?
18. Rollback and Contingency20
  1. What should a rollback plan contain?
  2. At what point does rollback become impractical?
  3. What is the rollback decision deadline?
  4. Who may invoke rollback?
  5. How would you return users to the legacy platform?
  6. How should trades entered after go-live be handled?
  7. What happens to messages already processed?
  8. How would you prevent duplicate transactions after rollback?
  9. How should generated confirmations be handled?
  10. What happens to invoices and payments?
  11. How should accounting outputs be contained?
  12. How would you restore database and file-system consistency?
  13. How should source systems be redirected?
  14. What reconciliation follows rollback?
  15. How would you communicate business limitations?
  16. What alternative exists when rollback is unsafe?
  17. What is forward remediation?
  18. How should contingency capacity be planned?
  19. How would you test rollback in rehearsal?
  20. What makes a rollback plan credible?
19. Go-Live and Hypercare20
  1. What is hypercare?
  2. How long should hypercare continue?
  3. What support coverage is required?
  4. How should business and technical teams be organised?
  5. What command-centre structure is appropriate?
  6. Which metrics should be monitored?
  7. How should defects be prioritised?
  8. What constitutes a critical defect?
  9. How should workarounds be approved?
  10. What changes should be permitted during hypercare?
  11. How should emergency fixes be tested?
  12. How would you prevent uncontrolled production correction?
  13. How should user issues be distinguished from defects?
  14. What daily reconciliations are required?
  15. How should unresolved migration breaks be tracked?
  16. When should vendor support be engaged?
  17. What is the exit criterion for hypercare?
  18. How should operational ownership be transferred?
  19. What lessons-learned review is required?
  20. How would you measure go-live stability?
20. Production-Support Operating Model20
  1. How would you design ETRM production support?
  2. What responsibilities belong to Level 1 support?
  3. What responsibilities belong to Level 2?
  4. What responsibilities belong to Level 3?
  5. When should a vendor receive an escalation?
  6. How should functional and technical support collaborate?
  7. What coverage hours are required?
  8. How should global handovers operate?
  9. What support skills are critical?
  10. How should ownership by service and component be documented?
  11. What is a RACI matrix?
  12. How should support queues be structured?
  13. How would you prevent ticket reassignment loops?
  14. What should an operational knowledge base contain?
  15. How should known errors be documented?
  16. What training should support teams receive?
  17. How should new releases transition into support?
  18. What production access should support personnel receive?
  19. How would you measure support effectiveness?
  20. What indicates that the support model is under-resourced?
21. Incident Management20
  1. What constitutes an ETRM production incident?
  2. How should incident severity be determined?
  3. How should business impact influence priority?
  4. What information should the first incident record contain?
  5. Who should lead a major incident?
  6. How should technical workstreams be coordinated?
  7. What communication cadence is appropriate?
  8. How would you prevent premature assumptions?
  9. What diagnostic evidence should be collected?
  10. When is service restart appropriate?
  11. When can restart destroy valuable evidence?
  12. How should workarounds be assessed?
  13. How should failed trades or jobs be contained?
  14. How would you manage downstream impacts?
  15. When should disaster recovery be considered?
  16. How should vendor support be engaged?
  17. What constitutes service restoration?
  18. What validation should follow restoration?
  19. How should outstanding data corrections be tracked?
  20. When can an incident be closed?
22. Problem and Root-Cause Management20
  1. How does problem management differ from incident management?
  2. What is root-cause analysis?
  3. Which methods can support root-cause analysis?
  4. Why is “human error” rarely a sufficient root cause?
  5. How would you construct an incident timeline?
  6. What evidence should support causal conclusions?
  7. How should contributing factors be identified?
  8. What is a known error?
  9. How should temporary and permanent fixes differ?
  10. How would you prevent recurring incidents?
  11. How should corrective actions be prioritised?
  12. Who should own each action?
  13. How would you track actions to completion?
  14. What validation proves remediation effective?
  15. How should root causes influence architecture standards?
  16. When should technical debt be formally recorded?
  17. How should recurring incidents influence investment?
  18. What should a post-incident report contain?
  19. Who should review major-problem reports?
  20. What indicates ineffective problem management?
23. Monitoring and Observability20
  1. What should ETRM production monitoring cover?
  2. How do infrastructure, application and business monitoring differ?
  3. Which service-health metrics are essential?
  4. How would you detect a process that is alive but stalled?
  5. What queue metrics should be monitored?
  6. How should database health be observed?
  7. How would you monitor grid workers?
  8. What batch metrics should be captured?
  9. How should interface completeness be monitored?
  10. What business controls should appear on dashboards?
  11. How would you monitor unvalued transactions?
  12. How should missing market data be alerted?
  13. How would you detect settlement or accounting failures?
  14. What is synthetic monitoring?
  15. How should correlation identifiers support diagnosis?
  16. How would you reduce alert fatigue?
  17. What service-level indicators should be retained?
  18. How should trends support capacity planning?
  19. How would you detect degradation before failure?
  20. What makes monitoring actionable?
24. Batch and End-of-Day Support20
  1. How should support monitor ETRM end-of-day?
  2. What constitutes technical batch completion?
  3. What constitutes business completion?
  4. How would you detect a missing portfolio?
  5. How should failed work units be recovered?
  6. When should a complete job be rerun?
  7. How would you prevent duplicate output?
  8. How should late market data be managed?
  9. What happens when end-of-day misses its cut-off?
  10. Which stages may be deferred?
  11. How should corrected input trigger recalculation?
  12. Who should approve an official rerun?
  13. How should restated results be labelled?
  14. How would you preserve the original result?
  15. How should regional processing dependencies be managed?
  16. What should a batch runbook contain?
  17. How should manual intervention be recorded?
  18. What reconciliation closes the business day?
  19. How would recurring batch failures be remediated?
  20. What metrics demonstrate end-of-day stability?
25. Production Data Correction20
  1. When is production data correction justified?
  2. Why should direct database correction be avoided?
  3. What supported alternatives should be considered?
  4. How should affected records be identified?
  5. What impact analysis is required?
  6. How should correction logic be independently reviewed?
  7. How would you test a correction script?
  8. What backup or recovery point is required?
  9. Who should approve execution?
  10. How should segregation of duties apply?
  11. How would you prevent correcting unintended records?
  12. What control totals should be captured before correction?
  13. What verification should follow execution?
  14. How should downstream effects be remediated?
  15. What happens if confirmations or payments were already generated?
  16. How should correction evidence be retained?
  17. How would you reverse an incorrect correction?
  18. When should vendor guidance be required?
  19. How should recurring corrections trigger architectural remediation?
  20. What makes a production correction auditable?
26. Service-Level and Capacity Management20
  1. Which ETRM services require formal service levels?
  2. How should availability be measured?
  3. How should transaction-processing latency be measured?
  4. What service level should apply to end-of-day?
  5. How should interface timeliness be measured?
  6. What is an operational-level agreement?
  7. How should third-party commitments support ETRM SLAs?
  8. How would you measure SLA breaches?
  9. How should planned maintenance be treated?
  10. What error budgets may be appropriate?
  11. How should capacity trends be monitored?
  12. What growth factors should be forecast?
  13. How should peak loads influence planning?
  14. What headroom is required?
  15. How should disaster-recovery capacity be considered?
  16. When should infrastructure be scaled?
  17. When should workload design be changed?
  18. How would recurring SLA breaches be escalated?
  19. What service-review metrics should management receive?
  20. How would you demonstrate continual improvement?
27. Upgrade, Migration and Support Scenarios20
  1. Post-upgrade valuations differ for only one instrument family. How would you investigate?
  2. An upgrade succeeds technically, but settlement events differ. Should go-live proceed?
  3. Several scripts compile but fail at runtime. What assessment was incomplete?
  4. End-of-day is 40% slower on the target version. How would you isolate the cause?
  5. A direct database interface breaks after upgrade. What architectural weakness does this expose?
  6. Migration counts reconcile, but commodity positions do not. What should be compared next?
  7. An amended legacy trade loses its historical relationship after migration. What was missing?
  8. A migrated trade generates a duplicate invoice. Which cutover control failed?
  9. A fixing correction arrives during migration freeze. How should it be managed?
  10. The final migration rehearsal exceeds the cutover window. Should go-live continue?
  11. Users enter trades after the rollback deadline. What contingency is required?
  12. Hypercare teams repeatedly correct data manually. What systemic action is needed?
  13. A production service restarts successfully, but its queue does not move. Is service restored?
  14. Support closes incidents after restart without root-cause analysis. What risk accumulates?
  15. Monitoring is green, but one portfolio is missing from risk reports. Which monitoring layer failed?
  16. A critical vendor defect has no immediate patch. How would you design containment?
  17. Disaster recovery restores the platform but not the latest outbound events. What must be reconciled?
  18. Management asks to combine an upgrade, cloud migration and product rollout in one cutover. How would you challenge it?
  19. The target version provides standard capability replacing custom code, but the business wants to retain both. What risks arise?
  20. What distinguishes an legacy-to-modern ETRM upgrade and support architect from a project manager or production-support lead?
Commodity-Specific Case Studies10 sections · 380 questions
A. Crude Oil and Refined Products50
  1. How would you model the transaction in ETRM?
  2. How would you represent the pricing window relative to the bill-of-lading date?
  3. How should provisional and final prices be calculated?
  4. What events should be generated?
  5. How would quantity tolerance be handled?
  6. How should missing or corrected assessments be controlled?
  7. Which positions and sensitivities should the trader see?
  8. How would you test final invoice adjustment?
  9. Which accounting entries are required?
  10. What integrations are needed?
  11. Which attributes belong on the trade?
  12. Which values belong in reference data?
  13. How would laboratory results enter ETRM?
  14. How should quality adjustments affect settlement?
  15. Should they change valuation before delivery?
  16. How would provisional quality assumptions be managed?
  17. How should actual quantity replace scheduled quantity?
  18. What audit trail is required?
  19. How would incorrect laboratory data be corrected?
  20. How would you reconcile the final invoice?
  21. How would you model the physical and financial transactions?
  22. How should they be linked analytically?
  23. Which risk factors are required?
  24. What basis risks remain after hedging?
  25. How would you avoid double counting?
  26. How should futures settlements affect P&L?
  27. How would you attribute hedge and physical P&L?
  28. How should exchange positions be reconciled?
  29. What happens when the cargo pricing period changes?
  30. How would you measure hedge effectiveness?
  31. How would trades and inventory movements be separated?
  32. What is the authoritative inventory quantity?
  33. How should tank locations be represented?
  34. How would temperature conversion be governed?
  35. How should operational losses be processed?
  36. How would inventory valuation be calculated?
  37. How should transfers between tanks be represented?
  38. How would negative inventory be detected?
  39. How should trades reconcile with inventory movements?
  40. Which accounting events should be produced?
  41. How would port, vessel and delivery data be represented?
  42. How should port-specific indexes be mapped?
  43. How would multiple deliveries under one contract be handled?
  44. How should delivery-document quantities update settlement?
  45. How would quality claims be processed?
  46. What credit exposure exists before delivery?
  47. How should invoices group deliveries?
  48. What taxes and fees might require configuration?
  49. How would an external marine-fuel platform integrate?
  50. What controls prevent duplicate delivery invoicing?
B. Natural Gas50
  1. How would the daily delivery profile be modelled?
  2. How should gas-day boundaries and time zones be handled?
  3. How would daily fixings enter the price?
  4. How should unfixed exposure be reported?
  5. How would monthly invoicing be generated?
  6. What happens when one fixing is missing?
  7. How should weekends and holidays be handled?
  8. Which market-data curves are required?
  9. How would the deal appear in daily positions?
  10. How would you validate the monthly invoice?
  11. How would you represent minimum and maximum quantities?
  12. Does the flexibility create embedded optionality?
  13. How should optionality be valued?
  14. How would nominations update expected delivery?
  15. How should cumulative constraints be monitored?
  16. How would make-up rights be represented?
  17. How should penalties be generated?
  18. What is the correct position view?
  19. How would you test operational constraint breaches?
  20. When would external optimisation be required?
  21. How would commodity and transportation contracts be modelled?
  22. How should entry and exit locations be represented?
  23. Which basis exposure remains?
  24. How should pipeline capacity be monitored?
  25. How would fuel-gas losses affect quantity?
  26. How should nominations and allocations enter ETRM?
  27. How would imbalance charges be calculated?
  28. Should transport costs be embedded or separate?
  29. How would landed margin be reported?
  30. What reconciliations are required?
  31. How should storage capacity be represented?
  32. How would injection and withdrawal rights be modelled?
  33. How should ratchets affect available capacity?
  34. What embedded optionality exists?
  35. How should storage valuation be calculated?
  36. How would optimisation results become operational nominations?
  37. How should inventory be reconciled?
  38. What stress scenarios are required?
  39. How would model assumptions be governed?
  40. Which capabilities should remain outside ETRM?
  41. How would the pricing formula be decomposed?
  42. How should lagged oil observations be represented?
  43. How would take-or-pay exposure be measured?
  44. How should annual contract quantities be tracked?
  45. How would a price-review clause affect valuation?
  46. How should forecast and fixed prices coexist?
  47. What curve and FX dependencies exist?
  48. How would the contract be stress-tested?
  49. How should accounting estimates be produced?
  50. What requires custom modelling?
C. LNG40
  1. How would the pricing slope and constant be represented?
  2. How should crude-price averaging be configured?
  3. How would tonnes, cubic metres and MMBtu be reconciled?
  4. Which quantity should drive settlement?
  5. How should boil-off losses be treated?
  6. What events occur at loading and discharge?
  7. How would provisional settlement operate?
  8. Which FX and discount curves are required?
  9. How should cargo P&L be reported?
  10. What data must come from external systems?
  11. Should the original transaction be amended or supplemented?
  12. How should the destination change be audited?
  13. Which market exposures change?
  14. How should additional freight be represented?
  15. How would changed boil-off affect delivered quantity?
  16. What happens to the original hedge?
  17. How should incremental diversion value be measured?
  18. What new settlement events are needed?
  19. How should confirmations be updated?
  20. How would you preserve original and revised economics?
  21. Which data is required for destination netback?
  22. Which calculations belong inside ETRM?
  23. Which belong in an external optimisation platform?
  24. How should freight curves be represented?
  25. How would boil-off be calculated?
  26. How should port and canal charges be maintained?
  27. How would FX affect comparison?
  28. How should counterparty credit influence decisions?
  29. How would scenario assumptions be governed?
  30. How would selected economics become a booked transaction?
  31. How would commercial trades and physical movements be separated?
  32. How should inventory ownership be represented?
  33. How would title-transfer points be captured?
  34. How should transshipment losses be treated?
  35. How would multiple vessel movements be integrated?
  36. What quantity should settle each contract?
  37. How should inventory reconcile after reload?
  38. What operational events require audit?
  39. How would demurrage be handled?
  40. What end-to-end controls are required?
D. Power and Renewables50
  1. How should hourly delivery profiles be modelled?
  2. How should peak and off-peak definitions be governed?
  3. How would holidays affect peak delivery?
  4. How should daylight-saving days be represented?
  5. How would zonal basis risk be measured?
  6. How should shaped exposure be aggregated?
  7. What curves are required?
  8. How would position reports prevent hourly detail from being lost?
  9. How should exchange hedges be reconciled?
  10. What performance considerations arise from hourly profiles?
  11. How would expected generation be represented?
  12. How should forecast and actual generation differ?
  13. How would inflation escalation be modelled?
  14. What optionality is created by the floor?
  15. How should negative-price provisions be represented?
  16. Which market-data curves are required?
  17. How would weather-driven volume risk be handled?
  18. How should imbalance costs affect value?
  19. What is the appropriate valuation methodology?
  20. Which assumptions require model governance?
  21. Should power and certificates be separate transactions?
  22. How should the transactions be linked?
  23. How would certificate vintage be represented?
  24. How should metered generation determine certificate quantity?
  25. What happens when production is below forecast?
  26. How should certificate delivery be tracked?
  27. How would registry identifiers be maintained?
  28. What exposures should be reported?
  29. How should retirement or cancellation be represented?
  30. How would power and certificate revenue be reconciled?
  31. How should physical battery constraints be represented?
  32. What optionality does the battery provide?
  33. How should charging and discharging be modelled?
  34. How would efficiency losses affect quantity?
  35. How should state of charge be tracked?
  36. What optimisation capability is required?
  37. How should dispatch instructions integrate with ETRM?
  38. How would revenues from multiple markets be attributed?
  39. What stress scenarios should be applied?
  40. Which functions should sit outside ETRM?
  41. How would forecast customer load be represented?
  42. How should actual metered consumption update positions?
  43. How would load-shape risk be measured?
  44. How should fixed-tariff revenue be modelled?
  45. What wholesale hedges are required?
  46. How would weather scenarios affect risk?
  47. How should imbalance exposure be represented?
  48. What volume should be settled?
  49. How would customer systems integrate?
  50. What controls prevent forecast data being treated as actual?
E. Emissions and Environmental Products30
  1. How should allowance instruments be represented?
  2. How should compliance year and vintage differ?
  3. How would forecast emissions be modelled?
  4. How should purchased, delivered and surrendered allowances differ?
  5. How would registry movements enter ETRM?
  6. What position indicates compliance shortfall?
  7. How should allowance valuation be performed?
  8. What accounting treatment requires consideration?
  9. How would surrender be controlled?
  10. How would ETRM reconcile with the external registry?
  11. How would the carbon-credit taxonomy be designed?
  12. Which attributes are economically material?
  13. How would unique registry serial numbers be handled?
  14. How should issuance, transfer and retirement differ?
  15. How would quality differences affect valuation?
  16. What market-data limitations exist?
  17. How should invalidated credits be handled?
  18. How would concentration risk be reported?
  19. Which provenance evidence must be retained?
  20. What prevents double counting or double retirement?
  21. How would the two instruments be represented?
  22. Which currency exposure arises?
  23. How should spread risk be reported?
  24. What correlation assumptions affect VaR?
  25. How would liquidity differences be handled?
  26. How should exchange positions reconcile?
  27. What stress scenarios are appropriate?
  28. How should margin cash flows be represented?
  29. How would P&L attribution separate outright and spread moves?
  30. What regulatory classifications must be maintained?
F. Metals30
  1. How would LME pricing be represented?
  2. How should quotation periods and averaging work?
  3. How would the regional premium be modelled?
  4. How should warehouse and metal-grade data be maintained?
  5. What physical and financial exposures exist?
  6. How would warrants or warehouse receipts be represented?
  7. How should exchange hedges be linked analytically?
  8. What basis risk remains?
  9. How would inventory and title be reconciled?
  10. How should the final invoice be validated?
  11. How would assay results be incorporated?
  12. How should provisional and final assays differ?
  13. How would payable metal be calculated?
  14. How should treatment and refining charges be represented?
  15. How would impurity penalties affect settlement?
  16. Which quantity should drive market exposure?
  17. How should provisional invoices be adjusted?
  18. What audit evidence is required?
  19. How would the valuation be independently reconstructed?
  20. When is custom settlement logic justified?
  21. How would principal metal quantity be represented?
  22. How should lease interest be calculated?
  23. What commodity and credit exposures arise?
  24. How should physical return differ from cash settlement?
  25. How would collateral be represented?
  26. Which market and discount curves are required?
  27. How should inventory ownership be tracked?
  28. What events occur at maturity?
  29. How would default be modelled operationally?
  30. What accounting considerations apply?
G. Agriculture and Soft Commodities30
  1. How would futures reference and differential be represented?
  2. How should origin, grade and crop year be modelled?
  3. How would actual quality change settlement?
  4. How should bag, kilogram and tonne conversions be controlled?
  5. How would shipment periods be represented?
  6. What basis risks remain after futures hedging?
  7. How should actual quantity update exposure?
  8. How would warehouse receipts be handled?
  9. How should provisional and final invoices work?
  10. What controls prevent incorrect crop-year mapping?
  11. What optionality does the seller hold?
  12. How should approved origins be represented?
  13. How would expected origin be valued before declaration?
  14. What happens when origin is nominated?
  15. How should freight exposure be represented?
  16. How would quality specifications affect settlement?
  17. What position should be shown before nomination?
  18. How should stress testing cover origin selection?
  19. How would confirmations represent optional terms?
  20. What requires custom modelling?
  21. How should input and output commodities be related?
  22. How would conversion yields be represented?
  23. How should processing losses be handled?
  24. Which curves are required?
  25. How would futures hedges be mapped?
  26. How should crush-margin P&L be calculated?
  27. What operational actuals should update the model?
  28. How would yield variance be reported?
  29. How should inventory be reconciled?
  30. What belongs in ETRM versus the manufacturing system?
H. Freight and Shipping30
  1. Should freight be a separate transaction?
  2. How would vessel, route and voyage be represented?
  3. How should estimated and actual costs differ?
  4. How would laytime be captured?
  5. How should demurrage be calculated?
  6. How would freight affect cargo netback?
  7. What currency exposures arise?
  8. How should invoices be reconciled?
  9. Which operational systems must integrate?
  10. How would voyage profitability be reported?
  11. How would the charter commitment be represented?
  12. How should daily hire charges accrue?
  13. How would costs be allocated across voyages?
  14. How should idle days be treated?
  15. How would bunker exposure be represented?
  16. How should off-hire periods affect settlement?
  17. How would vessel utilisation be reported?
  18. What accounting treatment requires consideration?
  19. Which data belongs in a voyage-management system?
  20. How would ETRM receive actual operating costs?
  21. How would physical and financial freight be modelled?
  22. How should route and vessel class be represented?
  23. Which fixing and forward curves are required?
  24. How would basis risk be measured?
  25. How should settlement against the index operate?
  26. What happens when the physical shipment date changes?
  27. How would hedge P&L be attributed?
  28. How should broker trades be reconciled?
  29. What liquidity risks remain?
  30. How would the combined freight position be reported?
I. Cross-Commodity and Structured Cases40
  1. How should crude inputs and product outputs be represented?
  2. How would yield assumptions be maintained?
  3. Which price curves are required?
  4. How should location and quality basis be captured?
  5. How would crack-spread sensitivities be reported?
  6. How should futures and swap hedges be mapped?
  7. What operational actuals should replace forecasts?
  8. How would production variance affect P&L?
  9. Which calculations belong outside ETRM?
  10. How would the complete margin be reconciled?
  11. How would power, gas and emissions positions be connected?
  12. What is the clean spark spread?
  13. How should heat-rate assumptions be represented?
  14. How would plant availability affect expected generation?
  15. What optionality does dispatch provide?
  16. How should start-up costs be treated?
  17. What optimisation capability is required?
  18. How would cross-commodity stress testing work?
  19. How should actual fuel burn update settlement?
  20. What should remain in the plant-management system?
  21. How should physical fuel and environmental attributes be separated?
  22. How would the composite price formula be represented?
  23. How should sustainability certification be maintained?
  24. How would volume commitments be monitored?
  25. What happens when certified supply is unavailable?
  26. How should conventional-jet and renewable-premium risks be reported?
  27. How would certificates or credits be retired?
  28. What accounting and disclosure requirements arise?
  29. How should supplier evidence be integrated?
  30. What controls prevent environmental double counting?
  31. Should the agreement be one trade or linked transactions?
  32. How should common contractual identifiers be maintained?
  33. How would cross-commodity pricing be represented?
  34. What embedded optionality exists?
  35. How should credit exposure be aggregated?
  36. How would confirmations be generated?
  37. How should invoices be consolidated?
  38. What happens when only one commodity component is amended?
  39. How would risk be reported by commodity and contract?
  40. Which parts require custom architecture?
J. End-to-End Architecture Challenges30
  1. How would you assess product scope?
  2. What gap analysis would you perform?
  3. How would you decide between configuration and customisation?
  4. Which reference data must be established?
  5. What integrations are required?
  6. How would you create the product-control framework?
  7. What test strategy is necessary?
  8. How would you migrate open trades?
  9. What determines production readiness?
  10. How would you phase delivery?
  11. How would you assess the source portfolio?
  12. Which trades should be migrated?
  13. How would reference-data mappings be governed?
  14. How should historical identifiers be preserved?
  15. How would open events be migrated?
  16. How would you prevent duplicate confirmations and payments?
  17. Which positions and values must reconcile?
  18. How would cutover be rehearsed?
  19. What rollback limitations exist?
  20. What should block go-live?
  21. How should market-data exceptions be governed?
  22. How would stale or unavailable prices be handled?
  23. Which stress scenarios should run?
  24. How should nonlinear transactions be revalued?
  25. How would liquidity risk be reported?
  26. How should margin cash-flow forecasts be produced?
  27. How would credit-limit utilisation change?
  28. What operational processes require prioritisation?
  29. How should official and indicative results differ?
  30. Which architecture bottlenecks might appear?
Architect Leadership and Stakeholder Management22 sections · 440 questions
1. Solution Architect Role and Accountability20
  1. What is the role of an ETRM Solution Architect?
  2. How does it differ from a functional consultant?
  3. How does it differ from a technical architect?
  4. How does it differ from a senior developer?
  5. How does it differ from a programme manager?
  6. Which decisions should the Solution Architect own?
  7. Which decisions should the business own?
  8. Which decisions require collective governance?
  9. How should the architect remain accountable without controlling every delivery activity?
  10. What artifacts should the architect produce?
  11. How should the architect measure solution quality?
  12. What does end-to-end ownership mean?
  13. How should an architect balance strategic and tactical work?
  14. When should an architect become directly involved in implementation?
  15. How would you prevent becoming a delivery bottleneck?
  16. How should architecture responsibilities change after go-live?
  17. What makes an architect credible with traders?
  18. What makes an architect credible with engineers?
  19. What makes an architect credible with control functions?
  20. How would you demonstrate that architecture created business value?
2. Stakeholder Identification and Analysis20
  1. Who are the principal stakeholders in an ETRM programme?
  2. How would you identify hidden stakeholders?
  3. How do traders, risk, operations and Finance priorities differ?
  4. What concerns would Product Control raise?
  5. What concerns would Credit Risk raise?
  6. What concerns would Treasury raise?
  7. What concerns would Compliance and Internal Audit raise?
  8. What concerns would infrastructure and production support raise?
  9. How would you analyse stakeholder influence and interest?
  10. What is a stakeholder map?
  11. How would you identify decision-makers?
  12. How would you identify subject-matter experts?
  13. How would you distinguish approvers from contributors?
  14. How should external vendors be represented?
  15. How would you engage stakeholders who are affected but unavailable?
  16. What happens when the nominal owner lacks decision authority?
  17. How would you identify conflicting incentives?
  18. How should stakeholder engagement vary by project stage?
  19. How would you maintain a stakeholder register?
  20. What indicates that stakeholder analysis is incomplete?
3. Business Understanding and Discovery20
  1. How would you learn a new trading desk's business?
  2. What questions would you ask traders?
  3. What would you ask risk controllers?
  4. What would you ask schedulers and operations?
  5. What would you ask settlements and Finance?
  6. How would you separate contractual requirements from user preferences?
  7. How would you identify undocumented processes?
  8. What can production incidents reveal about the operating model?
  9. How would you analyse spreadsheets and manual workarounds?
  10. How would you identify the actual system of record?
  11. How would you validate business terminology?
  12. How should process walkthroughs be conducted?
  13. What is a current-state process map?
  14. How would you identify control gaps?
  15. How would you identify duplicate data entry?
  16. How would you quantify operational pain?
  17. How would you challenge “ETRM cannot do this”?
  18. How would you validate vendor claims?
  19. What discovery evidence is sufficient to begin design?
  20. When should discovery be extended?
4. Requirements Leadership20
  1. How would you distinguish business, functional and technical requirements?
  2. What makes a requirement testable?
  3. How would you identify non-functional requirements?
  4. How should regulatory requirements be captured?
  5. How would you prioritise requirements?
  6. What is MoSCoW prioritisation?
  7. What are its limitations?
  8. How would you distinguish need from solution preference?
  9. How would you challenge a requirement that copies a legacy system?
  10. How should conflicting requirements be resolved?
  11. What happens when traders and Product Control disagree?
  12. How would you handle requirements that arrive after design approval?
  13. What is requirements traceability?
  14. Who should own acceptance criteria?
  15. How would you prevent requirements from remaining ambiguous?
  16. How should assumptions be documented?
  17. How should constraints differ from assumptions?
  18. What is an open question register?
  19. When should unresolved requirements block design?
  20. How would you obtain meaningful requirements sign-off?
5. Architecture Vision and Target State20
  1. How would you develop an ETRM target-state vision?
  2. How should business strategy influence architecture?
  3. What principles would guide the target state?
  4. How would you define ETRM's functional boundaries?
  5. How would you decide which capabilities remain outside ETRM?
  6. How would you explain target architecture to executives?
  7. How should current-state constraints influence sequencing?
  8. How would you distinguish target state from an idealised diagram?
  9. What transition architectures may be required?
  10. How should technical debt be represented?
  11. How would you identify architectural runway?
  12. How should scalability and resilience enter the vision?
  13. How would you incorporate data and integration strategy?
  14. How should security and controls be embedded?
  15. How would you align the target state with enterprise architecture?
  16. What happens when enterprise standards conflict with ETRM supportability?
  17. How would you manage exceptions?
  18. How should the target state be reviewed?
  19. What evidence demonstrates stakeholder alignment?
  20. When should the target architecture be revised?
6. Decision-Making and Trade-offs20
  1. How do you make an architecture decision with incomplete information?
  2. What is an architecture decision record?
  3. Which decisions require formal records?
  4. How should options be compared?
  5. What evaluation criteria would you use?
  6. How should cost, time, risk and maintainability be balanced?
  7. How would you evaluate configuration versus customisation?
  8. How would you compare ETRM and external-service implementation?
  9. How should vendor supportability influence decisions?
  10. How would you quantify technical debt?
  11. How should reversible and irreversible decisions differ?
  12. What is a time-boxed proof of concept?
  13. When is a proof of concept necessary?
  14. When can it become a delaying tactic?
  15. How would you prevent analysis paralysis?
  16. Who should accept residual risk?
  17. How would you communicate an unpopular decision?
  18. How should a rejected option remain documented?
  19. When should an earlier decision be reopened?
  20. How would you assess whether a decision produced the expected outcome?
7. Challenging Stakeholders Constructively20
  1. How would you challenge a senior trader's proposed design?
  2. How would you respond when urgency is used to bypass controls?
  3. What if the business insists on direct database updates?
  4. How would you challenge unrestricted manual market-data overrides?
  5. What if users want every legacy screen reproduced?
  6. How would you respond to an unnecessary custom instrument request?
  7. What if Finance requires a process that damages Front Office performance?
  8. How would you challenge an unrealistic delivery date?
  9. What evidence makes a challenge credible?
  10. How would you avoid turning a technical disagreement into a personal conflict?
  11. When should you propose a controlled tactical solution?
  12. How should tactical debt be time-bounded?
  13. What if the stakeholder refuses all alternatives?
  14. When should disagreement be escalated?
  15. How would you record accepted risk?
  16. What if an executive verbally approves an unsupported design?
  17. How would you respond if a vendor promises an unverified capability?
  18. When should an architect refuse approval?
  19. How would you preserve working relationships after disagreement?
  20. What distinguishes constructive challenge from obstruction?
8. Communication and Executive Influence20
  1. How would you explain ETRM architecture to executives?
  2. How would you explain valuation risk without mathematical detail?
  3. How would you present a production-readiness concern?
  4. What should an executive architecture summary contain?
  5. How would you communicate uncertainty?
  6. How would you explain technical debt in business terms?
  7. How should options and recommendations be presented?
  8. What is the role of visual architecture diagrams?
  9. How would you avoid overwhelming stakeholders with detail?
  10. How should communication differ for traders and engineers?
  11. How would you communicate a missed milestone?
  12. How should bad news be escalated?
  13. What should a steering-committee update contain?
  14. How would you distinguish fact, assumption and forecast?
  15. How should decisions and actions be recorded?
  16. How would you handle hostile questioning?
  17. How would you explain why a technically successful release is not business-ready?
  18. How should architecture metrics be presented?
  19. How would you build executive sponsorship?
  20. What indicates that communication was ineffective?
9. Workshop and Facilitation Skills20
  1. How would you plan a product-design workshop?
  2. Who should attend?
  3. What pre-reading should be supplied?
  4. How would you define workshop outcomes?
  5. How should competing perspectives be managed?
  6. How would you ensure quieter participants contribute?
  7. What happens when one stakeholder dominates?
  8. How would you separate requirements from solution design?
  9. How would you resolve terminology differences?
  10. What should be captured in real time?
  11. How would you manage unresolved questions?
  12. When should a workshop be stopped?
  13. How should decisions be confirmed afterward?
  14. What is a playback session?
  15. How would you prevent workshop fatigue?
  16. How should remote workshops be structured?
  17. How would you facilitate a failure-mode review?
  18. How would you run a production-readiness workshop?
  19. What evidence demonstrates workshop success?
  20. When is a workshop inappropriate?
10. Architecture Governance20
  1. What is architecture governance?
  2. Which ETRM decisions require governance?
  3. How would you establish an architecture-review board?
  4. Who should participate?
  5. What should a design review evaluate?
  6. What evidence should accompany a review?
  7. How would you prevent governance becoming bureaucratic?
  8. How should low-risk changes be handled?
  9. How should architecture exceptions be approved?
  10. What is an exception-expiry date?
  11. How would you monitor compliance with decisions?
  12. How should implementation deviations be managed?
  13. What is design assurance?
  14. How does design assurance continue during delivery?
  15. How should reusable patterns be governed?
  16. How would you prevent multiple teams solving the same problem differently?
  17. How should vendor designs be reviewed?
  18. What happens when delivery begins before architecture approval?
  19. How should recurring exceptions influence standards?
  20. What makes governance effective?
11. Design Reviews and Quality Assurance20
  1. How would you conduct an ETRM solution-design review?
  2. What functional areas must be represented?
  3. How should trade-lifecycle completeness be assessed?
  4. How would you evaluate data-model impact?
  5. How should integration reliability be reviewed?
  6. How would you assess performance impact?
  7. How should security and entitlement design be evaluated?
  8. How would you review operational supportability?
  9. What upgrade risks should be considered?
  10. How would you identify hidden dependencies?
  11. What questions expose incomplete designs?
  12. How should assumptions be validated?
  13. How would you classify review findings?
  14. What constitutes a blocking finding?
  15. How should findings be tracked?
  16. Who confirms closure?
  17. How would you manage conditional approval?
  18. What if the implementation differs from the approved design?
  19. How should post-implementation architecture validation work?
  20. How would you measure design-review effectiveness?
12. Delivery Planning and Estimation20
  1. How would you estimate a new ETRM product implementation?
  2. What factors drive complexity?
  3. How should uncertainty affect estimates?
  4. What is a discovery estimate?
  5. How does it differ from a delivery commitment?
  6. How would you identify dependencies?
  7. What is the critical path?
  8. How should vendor lead times be incorporated?
  9. How would you estimate testing effort?
  10. How should migration and reconciliation be estimated?
  11. How would you account for business availability?
  12. What contingency is appropriate?
  13. How should assumptions accompany estimates?
  14. How would you challenge politically imposed dates?
  15. What could be phased to meet a fixed deadline?
  16. What cannot safely be compressed?
  17. How would you communicate confidence ranges?
  18. What early warning signs indicate schedule risk?
  19. How should architecture support incremental delivery?
  20. What makes an estimate credible?
13. Programme and Portfolio Alignment20
  1. How should an ETRM solution align with the wider programme?
  2. How would you identify cross-project dependencies?
  3. What happens when several projects change the same configuration?
  4. How should shared environments be governed?
  5. How would you manage competing release priorities?
  6. What is a release train?
  7. How should architecture work align with delivery increments?
  8. How would you prevent local optimisation?
  9. What is portfolio-level technical debt?
  10. How should enterprise data and integration initiatives be coordinated?
  11. How would you align an legacy-to-modern ETRM upgrade with product onboarding?
  12. When should initiatives be separated?
  13. How should resource conflicts be escalated?
  14. What should a programme architecture forum achieve?
  15. How would you avoid duplicated platform capabilities?
  16. How should roadmaps reflect architectural dependencies?
  17. How would you communicate cumulative risk?
  18. What metrics should programme governance review?
  19. When should architecture recommend resequencing?
  20. What demonstrates successful programme alignment?
14. Team Leadership and Collaboration20
  1. How would you structure an ETRM delivery team?
  2. What responsibilities belong to functional consultants?
  3. What responsibilities belong to developers?
  4. What responsibilities belong to quantitative analysts?
  5. What responsibilities belong to data and integration engineers?
  6. What responsibilities belong to testers?
  7. How should infrastructure and security teams participate?
  8. How would you clarify accountability?
  9. What is a RACI matrix?
  10. What are the limitations of RACI?
  11. How would you delegate architecture work?
  12. How should delegated designs be reviewed?
  13. How would you mentor developing architects?
  14. How should technical disagreement within the team be resolved?
  15. What if the strongest technical contributor communicates poorly?
  16. How would you handle consistently weak delivery?
  17. How would you create psychological safety while maintaining standards?
  18. How should knowledge be shared?
  19. How would you reduce dependence on individual specialists?
  20. What indicates a high-performing architecture team?
15. Vendor and Systems-Integrator Management20
  1. How would you evaluate an ETRM implementation partner?
  2. What evidence should support vendor capability claims?
  3. How should vendor responsibilities be defined?
  4. How would you prevent knowledge remaining exclusively with the vendor?
  5. What design artifacts must vendors deliver?
  6. How should vendor estimates be challenged?
  7. How would you review vendor-created customisations?
  8. What if the vendor recommends a highly customised solution?
  9. How should vendor accelerators be evaluated?
  10. Who owns intellectual property and source code?
  11. How should product defects differ from implementation defects?
  12. When should an issue be escalated to the software vendor?
  13. What information should accompany a vendor support case?
  14. How would you manage conflicting vendor recommendations?
  15. How should commercial incentives be considered?
  16. What acceptance criteria should apply to vendor deliverables?
  17. How should knowledge transfer be tested?
  18. What happens when a vendor misses quality thresholds?
  19. How would you transition away from a partner?
  20. What makes a vendor relationship effective without becoming dependent?
16. Risk, Issue and Dependency Management20
  1. How do risks, issues, assumptions and dependencies differ?
  2. What belongs in an architecture-risk register?
  3. How should risk probability and impact be assessed?
  4. How would you identify architectural risks early?
  5. Who should own mitigation?
  6. What is residual risk?
  7. Who may accept residual risk?
  8. How should risk triggers be defined?
  9. How would you monitor risk exposure?
  10. What makes a mitigation credible?
  11. How should technical debt appear as risk?
  12. How would you escalate a dependency outside your control?
  13. What happens when a critical assumption becomes invalid?
  14. How should issues be connected to decisions?
  15. How would you avoid risk registers becoming passive documents?
  16. What risks should be discussed at steering committee?
  17. How should vendor risks be represented?
  18. How should cumulative delivery risk be assessed?
  19. What evidence demonstrates active risk management?
  20. When should risk require a no-go recommendation?
17. Conflict and Escalation Management20
  1. How would you resolve conflict between Trading and Risk?
  2. What if Front Office speed conflicts with control requirements?
  3. How would you resolve disagreement between architecture and delivery?
  4. What if two architects recommend incompatible designs?
  5. How would you distinguish factual and value-based disagreement?
  6. What evidence should be collected?
  7. How should decision authority be identified?
  8. When is compromise appropriate?
  9. When is compromise unsafe?
  10. How would you escalate without undermining colleagues?
  11. What should an escalation contain?
  12. How would you avoid escalating every disagreement?
  13. What if senior management overrides your recommendation?
  14. How should accepted risk be documented?
  15. How would you respond when an overridden risk materialises?
  16. What if stakeholders withhold necessary decisions?
  17. How should unresolved decisions affect delivery?
  18. How would you facilitate reconciliation after conflict?
  19. What lessons should be captured?
  20. What distinguishes principled leadership from inflexibility?
18. Control, Compliance and Audit Stakeholders20
  1. How would you engage Compliance early?
  2. How should Internal Audit participate without designing controls?
  3. How would you translate regulatory obligations into system requirements?
  4. Who should own control design?
  5. How would you validate that a control is operationally practical?
  6. What is control evidence?
  7. How should manual and automated controls differ?
  8. How would you assess compensating controls?
  9. What if business users consider controls burdensome?
  10. How should audit findings influence architecture?
  11. How would you challenge an ineffective remediation?
  12. What if the proposed control produces excessive false positives?
  13. How should model-risk stakeholders be engaged?
  14. How would you obtain security approval?
  15. What should a regulatory traceability matrix contain?
  16. How should control ownership continue after go-live?
  17. How would you demonstrate control effectiveness?
  18. What if a critical control cannot be automated?
  19. When should compliance risk stop a release?
  20. How would you explain residual control risk to executives?
19. Production Readiness and Operational Leadership20
  1. What does production readiness mean?
  2. Who should participate in readiness review?
  3. What functional evidence is required?
  4. What non-functional evidence is required?
  5. How should unresolved defects be assessed?
  6. What operational documentation must exist?
  7. How should support teams demonstrate readiness?
  8. What monitoring must be operational?
  9. How should data reconciliation be validated?
  10. What rollback capability is required?
  11. Who should make the final go/no-go decision?
  12. What conditions should automatically stop release?
  13. How would you resist schedule pressure?
  14. What is an early-life-support model?
  15. How should hypercare be governed?
  16. How should production issues be prioritised?
  17. When should vendor support be present?
  18. How is ownership transferred to operations?
  19. When is a release considered stable?
  20. How should lessons improve future delivery?
20. Transformation and Change Adoption20
  1. Why can a technically correct ETRM solution fail?
  2. How would you assess organisational readiness?
  3. How should operating-model changes be identified?
  4. What training do traders and operations require?
  5. How would you manage resistance to standardisation?
  6. How should spreadsheet-dependent processes be transitioned?
  7. What is a super-user network?
  8. How can super-users support adoption?
  9. How should communications prepare users for change?
  10. What should business process documentation contain?
  11. How would you measure adoption?
  12. What behaviour indicates users are bypassing the solution?
  13. How would you respond to shadow systems?
  14. How should feedback be collected?
  15. When should feedback change the design?
  16. How should post-go-live improvements be prioritised?
  17. What ownership sustains the new process?
  18. How would you prevent regression to legacy practices?
  19. What metrics demonstrate transformation success?
  20. What is the architect's role in change adoption?
21. Behavioural and Experience Questions20
  1. Describe an ETRM design you rejected and why.
  2. Describe a time you changed your architecture recommendation.
  3. Describe a serious requirement ambiguity you resolved.
  4. Describe a conflict between Trading and a control function.
  5. Describe a production issue caused by an architectural decision.
  6. Describe a difficult stakeholder you influenced.
  7. Describe an unrealistic commitment you challenged.
  8. Describe a tactical solution you approved.
  9. How did you ensure that the tactical solution was later removed?
  10. Describe a vendor recommendation you challenged.
  11. Describe a design review that uncovered a critical issue.
  12. Describe a release you recommended stopping.
  13. Describe an architecture risk management accepted.
  14. Describe a time your recommendation was overruled.
  15. What happened, and what did you learn?
  16. Describe how you developed a junior architect.
  17. Describe how you recovered a failing workstream.
  18. Describe how you simplified an overly complex solution.
  19. Describe an architectural mistake you made.
  20. How did you correct it?
22. Leadership Scenarios20
  1. Traders demand same-day deployment of a new pricing rule. How would you respond?
  2. Risk refuses go-live because one stress scenario is incomplete. What would you do?
  3. Finance wants direct ETRM database access for month-end reporting. How would you challenge it?
  4. A senior executive has promised an impossible delivery date. How would you reframe the plan?
  5. The vendor says custom code is the only option, but no gap analysis exists. What would you require?
  6. Two implementation partners blame each other for an interface failure. How would you establish accountability?
  7. Developers say architecture governance is slowing delivery. How would you assess the claim?
  8. An architect approves designs but does not follow implementation. What risk results?
  9. A technically superior design exceeds budget. How would you structure the decision?
  10. A cheaper design creates long-term operational dependence on one consultant. Would you approve it?
  11. The business wants one global process despite legal regional differences. How would you resolve this?
  12. Product Control and traders use different P&L definitions. How would you establish authority?
  13. A production-readiness review finds missing support documentation. Should release proceed?
  14. A critical defect has a manual workaround. What determines go-live eligibility?
  15. The programme hides technical debt to preserve a green status. How would you respond?
  16. A security control blocks an essential overnight process. How would you manage the conflict?
  17. An offshore team lacks commodity-domain knowledge but owns critical configuration. What should change?
  18. The business refuses to fund disaster recovery while demanding high availability. How would you frame the risk?
  19. A migration rehearsal fails, but management wants to continue. What evidence should drive the decision?
  20. What distinguishes an ETRM architecture leader from a technically strong individual contributor?

Reading the questions is not the same as being able to answer them

The ETRM Pro Bundle covers the material these questions are drawn from: trade capture and product modelling, curves and valuation, position and P&L, risk, settlement and integration architecture.

Get the ETRM Pro Bundle See the ETRM training