Neura Market Comparable Company Analysis Reference

This document defines the standard for building an institutional-grade comparable company analysis in .xlsx format. The output combines operating metrics, valuation multiples, and statistical benchmarking to support investment decisions. All procedures, parameters, and constraints are mandatory unless overridden by user-provided preferences.

Purpose and Use Cases

The analysis produces a structured spreadsheet that enables rigorous peer comparison. Use it for:

Valuation analysis (identifying undervalued or overvalued companies relative to peers)
Efficiency benchmarking (comparing margins, cash generation, and asset turnover)
Growth analysis (evaluating revenue growth, CAGR, and user growth trajectories)
Cash generation assessment (analyzing free cash flow, FCF margin, and conversion rates)
M&A evaluation, investment decision support, sector benchmarking, and performance review

Prerequisites

Before building the analysis, ensure the following are in place:

A headless openpyxl environment for producing .xlsx files.
Access to excel-author skill conventions (cell coloring, formulas, named ranges, sensitivity tables).
The recalculation script available at python /path/to/excel-author/scripts/recalc.py ./out/model.xlsx.
MCP data sources configured (S&P Kensho, FactSet, Daloopa) or fallback access to Bloomberg Terminal, SEC EDGAR, and company IR pages.
User-provided peer group, time period, units, industry context, key question, and audience.
Optional: user-provided template file or formatting preferences.

Data Source Hierarchy

Always follow this order when sourcing data. Never use web search as a primary source.

MCP data sources first: S&P Kensho, FactSet, Daloopa. These are accessed via native-mcp tools.
Fallback sources: Bloomberg Terminal, SEC EDGAR (via https://www.sec.gov/cgi-bin/browse-edgar), or company IR pages.
Never use web_search as primary. If you must use web_extract or browser_navigate, flag the data and explain why MCP sources were unavailable.

Every hardcoded input value must include a cell comment citing the exact source (e.g., "Bloomberg Terminal - MSFT Equity DES, accessed 2024-10-02") or explaining the assumption. Add hyperlinks to SEC filings or data sources when possible.

Parameters

The following parameters are required to build the analysis. User-provided examples and explicit preferences always take precedence over defaults.

Parameter	Meaning	Required
Peer group companies	List of company names and tickers. Must be truly comparable (similar business model, scale, geography).	Yes
Time period	As-of date and period for data (e.g., Q4 2024, LTM). Affects all metrics and multiples.	Yes
Units	Scale for financial figures (USD Millions or Billions). Must be consistent across all data.	Yes
Industry context	Determines which metrics are relevant (SaaS, manufacturing, financial services, retail, etc.).	Yes
Key question	Primary analysis goal: valuation, efficiency, growth, cash generation, M&A evaluation, etc.	Yes
Audience	Who will use the analysis (investment committee, board, quick reference, detailed memo).	Yes
User formatting preferences	Any explicit formatting preferences or uploaded template files. Overrides all defaults.	No

Procedure: Build Comparable Company Analysis

Follow these steps in order. Each step has a target duration; do not skip or reorder.

Step 1: Set Up Structure (30 minutes)

Create all headers in Rows 1 through 3. Use this exact layout:

Row 1: [ANALYSIS TITLE] - COMPARABLE COMPANY ANALYSIS
Row 2: [List of Companies with Tickers] • [Company 1 (TICK1)] • [Company 2 (TICK2)] • [Company 3 (TICK3)]
Row 3: As of [Period] | All figures in [USD Millions/Billions] except per-share amounts and ratios

Apply the following formatting conventions:

Dark blue section headers (#1F4E79 or #17365D) with white bold text, 12pt Times New Roman.
Light blue column headers (#D9E1F2) with black bold text, 12pt Times New Roman.
White background for data rows, 11pt Times New Roman.
Light grey background (#F2F2F2) for statistics rows, 11pt Times New Roman.
No borders. Uniform column widths and row heights.
Center-align all metrics.
Percentages: 1 decimal place (e.g., 12.3%).
Multiples: 1 decimal place (e.g., 13.5x).
Dollar amounts: no decimals with thousands separator (e.g., 261,400).

Step 2: Gather Data (60-90 minutes)

Check for MCP data sources first (S&P Kensho, FactSet, Daloopa). If unavailable, use Bloomberg Terminal or SEC EDGAR filings. Never use web search as primary.

Input all raw numbers as hardcoded values in blue text. Add cell comments to every hardcoded input: cite the exact source (e.g., "Bloomberg Terminal - MSFT Equity DES, accessed 2024-10-02") or explain the assumption. Add hyperlinks to SEC filings or data sources when possible.

If a multiple, precedent, or filing number cannot be sourced, flag the cell as [UNSOURCED] and surface this to the user. Never fabricate data.

Step 3: Build Operating Metrics Formulas (30 minutes)

Create the following columns: Company, Revenue, Revenue Growth (YoY %), Gross Profit, Gross Margin (=GP/Revenue), EBITDA, EBITDA Margin (=EBITDA/Revenue). Include optional columns as needed: FCF, FCF Margin, Net Income, Operating Income, CapEx metrics, Rule of 40, FCF Conversion.

Every derived value must be an Excel formula referencing input cells. For example:

// Core ratios - these are always calculated
Gross Margin (F7): =E7/C7
EBITDA Margin (H7): =G7/C7

// Optional ratios - include if relevant
FCF Margin: =[FCF]/[Revenue]
Net Margin: =[Net Income]/[Revenue]
Rule of 40: =[Growth %]+[FCF Margin %]

Use cell.value = "=E7/C7" to set formulas programmatically. Show the user the calculated margins and sanity-check before proceeding.

Step 4: Build Valuation Multiples Formulas (30 minutes)

Create the following columns: Company, Market Cap, Enterprise Value, EV/Revenue (=EV/Revenue), EV/EBITDA (=EV/EBITDA), P/E Ratio (=Market Cap/Net Income). Include optional columns as needed: FCF Yield, PEG Ratio, Price/Book, ROE/ROA, Revenue/EBITDA CAGR, Asset Turnover, Debt/Equity.

All valuation multiples must reference the operating metrics section. Never input the same raw data twice.

// Core multiples - always include these
EV/Revenue: =[Enterprise Value]/[LTM Revenue]
EV/EBITDA: =[Enterprise Value]/[LTM EBITDA]
P/E Ratio: =[Market Cap]/[Net Income]

// Optional multiples - include if data available
FCF Yield: =[LTM FCF]/[Market Cap]
PEG Ratio: =[P/E]/[Growth Rate %]

Show the user the multiples and confirm reasonableness before adding statistics.

Step 5: Add Statistics (15 minutes)

After one blank row for visual separation, add statistics rows. Apply to all comparable metrics (ratios, margins, growth rates, multiples). Do NOT apply to size metrics (Revenue, EBITDA, Net Income, Market Cap, Enterprise Value).

Do NOT add "SECTOR STATISTICS" or "VALUATION STATISTICS" header rows.

[Leave one blank row for visual separation]
- Maximum: =MAX(B7:B9)
- 75th Percentile: =QUARTILE(B7:B9,3)
- Median: =MEDIAN(B7:B9)
- 25th Percentile: =QUARTILE(B7:B9,1)
- Minimum: =MIN(B7:B9)

Step 6: Quality Control (30 minutes)

Run the following sanity checks:

Gross margin > EBITDA margin > Net margin
EV/Revenue typically 0.5-20x
EV/EBITDA typically 8-25x
P/E typically 10-50x
Higher growth correlates with higher multiples
Larger companies often have better margins

Verify formula references (no #DIV/0!, #REF!, #N/A errors). Check quartile logic. Compare against known benchmarks.

Step 7: Documentation (15 minutes)

Complete the notes section with:

Data sources and quality: Where from, what period, how verified.
Key definitions: EBITDA calculation, FCF formula, special metrics, time periods.
Valuation methodology: EV calculation, growth rates used, adjustments.
Analysis framework: Investment thesis, key metrics, how to interpret statistics.

Step 8: Final Delivery

Recalculate using python /path/to/excel-author/scripts/recalc.py ./out/model.xlsx. Verify the output checklist:

All companies comparable
Consistent time periods
Units labeled
Formulas reference cells
All hardcoded inputs have comments with source/assumption
Hyperlinks added
Statistics include 5 metrics
Notes section complete
Visual formatting correct
Sanity checks pass
Date stamp current
No formula errors

Formatting Reference

Color Codes

Element	Color Code
Section headers	`#1F4E79` or `#17365D`
Column headers	`#D9E1F2`
Data rows	White
Statistics rows	`#F2F2F2`

Font and Alignment

Times New Roman 11pt for data, 12pt for headers.
Center-align all metrics.
No borders.
Uniform column widths and row heights.

Number Formatting

Percentages: 1 decimal (e.g., 12.3%).
Multiples: 1 decimal (e.g., 13.5x).
Dollar amounts: no decimals with thousands separator (e.g., 261,400).

Formula Reference

Use these formula patterns throughout the model.

// Statistical Functions
=AVERAGE(range)          // Simple mean
=MEDIAN(range)           // Middle value
=QUARTILE(range, 1)      // 25th percentile
=QUARTILE(range, 3)      // 75th percentile
=MAX(range)              // Maximum value
=MIN(range)              // Minimum value
=STDEV.P(range)          // Standard deviation

// Financial Calculations
=B7/C7                   // Simple ratio (Margin)
=SUM(B7:B9)/3            // Average of multiple companies
=IF(B7>0, C7/B7, "N/A")  // Conditional calculation
=IFERROR(C7/D7, 0)       // Handle divide by zero

// Cross-Sheet References
='Sheet1'!B7             // Reference another sheet
=VLOOKUP(A7, Table1, 2)  // Lookup from data table
=INDEX(MATCH())          // Advanced lookup

// Formatting
=TEXT(B7, "0.0%")        // Format as percentage
=TEXT(C7, "#,##0")       // Thousands separator

Metric Definitions

Use these definitions consistently across the model.

Gross Margin = Gross Profit / Revenue
EBITDA Margin = EBITDA / Revenue
FCF Margin = Free Cash Flow / Revenue
FCF Conversion = FCF / Operating Cash Flow
ROE = Net Income / Shareholders' Equity
ROA = Net Income / Total Assets
Asset Turnover = Revenue / Total Assets
Debt/Equity = Total Debt / Shareholders' Equity

Industry-Specific Metric Selection

Adjust the metric set based on industry context.

SaaS

Focus on: Revenue Growth %, Gross Margin %, EBITDA Margin, Rule of 40, FCF Margin, EV/Revenue, EV/EBITDA. The Rule of 40 is calculated as Growth % + FCF Margin %. A company with 15% revenue growth and 70% FCF margin achieves a Rule of 40 of 85%, well above the 40% threshold considered high performance. In this context, a 10% FCF margin might indicate room for improvement, while a 15% growth rate combined with a 70% FCF margin shows strong cash generation.

Manufacturing

Focus on: Revenue Growth %, Gross Margin %, EBITDA Margin, Asset Turnover, Debt/Equity, EV/EBITDA, P/E, ROE. For a manufacturing company with $50 million in revenue and $3.45 million in EBITDA, the EBITDA margin would be 6.9%, which is below the typical 15% target for efficient operations. Asset turnover of 1.5x indicates the company generates $1.50 of revenue per dollar of assets.

Financial Services

Focus on: Net Interest Margin, ROE, ROA, P/E, Price/Book, Efficiency Ratio. A bank with a 3.45% net interest margin and 15% ROE is performing well relative to peers. The efficiency ratio of 60% means 60 cents of every dollar of revenue goes to operating expenses.

Retail/E-Commerce

Focus on: Revenue Growth %, Gross Margin %, EBITDA Margin, FCF Margin, EV/Revenue, EV/EBITDA, Inventory Turnover. An e-commerce company with $6 billion in revenue and a 10% EBITDA margin generates $600 million in EBITDA. A 15% revenue growth rate combined with a 70% gross margin indicates strong pricing power and scale.

Example Structure

The following example illustrates the structural hierarchy. Use it for principles only; do not reproduce the exact format or metrics without considering context. An example file is available at examples/comps_example.xlsx.

┌─────────────────────────────────────────────────────────────┐
│ TECHNOLOGY - COMPARABLE COMPANY ANALYSIS                    │
│ Microsoft • Alphabet • Amazon                               │
│ As of Q4 2024 | All figures in USD Millions                │
├─────────────────────────────────────────────────────────────┤
│ OPERATING METRICS                                           │
├──────────┬─────────┬─────────┬──────────┬──────────────────┤
│ Company  │ Revenue │ Growth  │ Gross    │ EBITDA  │ EBITDA │
│          │ (LTM)   │ (YoY)   │ Margin   │ (LTM)   │ Margin │
├──────────┼─────────┼─────────┼──────────┼─────────┼────────┤
│ MSFT     │ 261,400 │ 12.3%   │ 68.7%    │ 205,100 │ 78.4%  │
│ GOOGL    │ 349,800 │ 11.8%   │ 57.9%    │ 239,300 │ 68.4%  │
│ AMZN     │ 638,100 │ 10.5%   │ 47.3%    │ 152,600 │ 23.9%  │
│          │         │         │          │         │        │ [blank row]
│ Median   │ =MEDIAN │ =MEDIAN │ =MEDIAN  │ =MEDIAN │=MEDIAN │
│ 75th %   │ =QUART  │ =QUART  │ =QUART   │ =QUART  │=QUART  │
│ 25th %   │ =QUART  │ =QUART  │ =QUART   │ =QUART  │=QUART  │
├─────────────────────────────────────────────────────────────┤
│ VALUATION MULTIPLES                                         │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│ Company  │ Mkt Cap  │ EV       │ EV/Rev   │ EV/EBITDA │ P/E│
├──────────┼──────────┼──────────┼──────────┼───────────┼────┤
│ MSFT     │3,550,000 │3,530,000 │ 13.5x    │ 17.2x     │36.0│
│ GOOGL    │2,030,000 │1,960,000 │  5.6x    │  8.2x     │24.5│
│ AMZN     │2,226,000 │2,320,000 │  3.6x    │ 15.2x     │58.3│
│          │          │          │          │           │    │ [blank row]
│ Median   │ =MEDIAN  │ =MEDIAN  │ =MEDIAN  │ =MEDIAN   │=MED│
│ 75th %   │ =QUART   │ =QUART   │ =QUART   │ =QUART    │=QRT│
│ 25th %   │ =QUART   │ =QUART   │ =QUART   │ =QUART    │=QRT│
└──────────┴──────────┴──────────┴──────────┴───────────┴────┘

In this example, Microsoft shows a 12.3% revenue growth rate and a 68.7% gross margin. The P/E ratio of 36.0x for Microsoft is within the typical range of 10-50x. The enterprise value for Amazon is $2,320,000 million. The median statistics are calculated using formulas like =MEDIAN(range). The 75th and 25th percentiles use =QUARTILE(range,3) and =QUARTILE(range,1) respectively.

Key Metrics for Statistics Block

Apply statistics to these comparable metrics only. Do NOT apply to size metrics.

Revenue Growth (YoY) % | EBITDA Margin | FCF Margin | Rule of 40

Additional metrics for the statistics block include: Gross Margin %, EPS, EV/Revenue, EV/EBITDA, P/E, Dividend Yield %, and Beta.

Failure Modes

Avoid these common mistakes:

Using web search as primary data source (inaccurate, no audit trail).
Hardcoding derived values (margins, multiples) instead of formulas; the model will not update automatically.
Mixing different time periods in numerator and denominator (e.g., LTM revenue with quarterly EBITDA).
Including non-comparable companies (different business models, scale, geography).
Applying statistics to size metrics (Revenue, EBITDA, Market Cap) which are not comparable across companies.
Missing cell comments on hardcoded inputs; no audit trail or assumption transparency.
Including too many metrics (more than 15) without clear purpose; adds noise.
Formula errors (#DIV/0!, #REF!, #N/A) from incorrect references or missing data.
Inconsistent units (mixing millions and billions without labeling).
Not recalculating before delivery.

Notes and Methodology Documentation

Complete this section in the spreadsheet. Include:

Data Sources and Quality

Document where data was sourced from (e.g., MCP via FactSet, Bloomberg Terminal, SEC EDGAR), the period covered, and how data was verified. For example: "Revenue data sourced from FactSet LTM as of Q4 2024. Verified against SEC 10-K filings."

Key Definitions

Define all metrics used in the analysis:

EBITDA: Earnings Before Interest, Taxes, Depreciation, and Amortization. Calculated as Operating Income + Depreciation & Amortization.
FCF: Free Cash Flow = Operating Cash Flow - CapEx.
FCF Conversion: FCF / Operating Cash Flow.
Rule of 40: Revenue Growth % + FCF Margin %.
Enterprise Value: Market Cap + Total Debt - Cash & Equivalents.

Valuation Methodology

Explain how multiples are calculated and any adjustments made. For example: "EV/Revenue uses LTM revenue. EV/EBITDA uses LTM EBITDA. P/E uses LTM Net Income."

Analysis Framework

Describe the investment thesis, key metrics, and how to interpret the statistics. For example: "The analysis focuses on growth and profitability. Companies with Rule of 40 above 40% are considered high performers."

Recalculation and Delivery

Before delivering the final file, run the recalculation script:

python /path/to/excel-author/scripts/recalc.py ./out/model.xlsx

This ensures all formulas are updated and no errors remain. Verify the output checklist before submitting.

Additional Notes

Use cell.value = 0.687 to set a hardcoded percentage value (representing 68.7%) in a cell, then format it as a percentage.
The [UNSOURCED] flag should be used in cell comments when data cannot be sourced from any available provider.
The example file at examples/comps_example.xlsx provides structural guidance. Do not reproduce its exact format or metrics without considering the specific context of your analysis.
User-provided examples and explicit preferences always take precedence over the defaults described in this document.
The number 69632 is an example of a large integer value that might appear in financial data (e.g., shares outstanding in thousands). Always format such values according to the units specified.
The year 2024 is used as a reference period in examples; always use the actual as-of date provided by the user.
When building the model, ensure that all dollar amounts are formatted with no decimals and thousands separators. For example, a revenue figure of $50 million should appear as 50,000 in the spreadsheet if units are in thousands, or as 50 if units are in millions. A value of $3.45 million would appear as 3,450 in thousands or 3.45 in millions. A value of $6 billion would appear as 6,000,000 in thousands or 6,000 in millions. The percentage figures of 15%, 70%, and 10% should be entered as 0.15, 0.70, and 0.10 respectively in cells, then formatted to display as 15.0%, 70.0%, and 10.0%.
The statistics block should always include five metrics: Maximum, 75th Percentile, Median, 25th Percentile, and Minimum. These are applied to all comparable metrics but never to size metrics like Revenue, EBITDA, Net Income, Market Cap, or Enterprise Value.
When using the =QUARTILE function, note that Excel's QUARTILE function is equivalent to QUARTILE.INC. For the 75th percentile use =QUARTILE(range,3) and for the 25th percentile use =QUARTILE(range,1).
The recalculation script must be run from the project root directory. The command python /path/to/excel-author/scripts/recalc.py ./out/model.xlsx assumes the output file is located at ./out/model.xlsx. Adjust the path if the output file is in a different location.
All cell comments should be added using the openpyxl comment object. For example: from openpyxl.comments import Comment then cell.comment = Comment("Source: Bloomberg Terminal - MSFT Equity DES, accessed 2024-10-02", "Analyst").
Hyperlinks should be added using cell.hyperlink = "https://www.sec.gov/cgi-bin/browse-edgar" and then setting the cell value to the display text.
The [UNSOURCED] flag should be placed in the cell comment, not in the cell value itself. For example: cell.comment = Comment("[UNSOURCED] Unable to source from MCP or fallback sources", "Analyst").
When setting formulas programmatically, always use the English function names (e.g., =MEDIAN, =QUARTILE, =IFERROR) regardless of the user's locale. Excel will translate these automatically when the file is opened.
The number formatting for percentages should be set using cell.number_format = '0.0%'. For multiples use cell.number_format = '0.0"x"'. For dollar amounts use cell.number_format = '#,##0'.
The font for all cells should be Times New Roman. Set this using from openpyxl.styles import Font then cell.font = Font(name='Times New Roman', size=11) for data cells, Font(name='Times New Roman', size=12, bold=True, color='FFFFFF') for section headers, and Font(name='Times New Roman', size=12, bold=True, color='000000') for column headers.
The fill color for section headers should be set using from openpyxl.styles import PatternFill then cell.fill = PatternFill(start_color='1F4E79', end_color='1F4E79', fill_type='solid'). For column headers use start_color='D9E1F2'. For statistics rows use start_color='F2F2F2'.
Alignment should be set using from openpyxl.styles import Alignment then cell.alignment = Alignment(horizontal='center', vertical='center').
The blank row between data and statistics should be exactly one row. Do not add additional blank rows.
When checking for formula errors, use =IFERROR(formula, 0) to handle divide-by-zero cases gracefully. However, if a division by zero indicates a data quality issue, flag it with [UNSOURCED] instead.
The example file at examples/comps_example.xlsx contains a fully worked example. Use it to verify your structural understanding, but always adapt the metrics and format to the specific industry and user requirements.
The user may provide a template file that overrides all default formatting. In that case, apply the template's formatting conventions instead of the defaults described here.
The analysis should always include at least three companies in the peer group. If the user provides fewer than three, request additional companies.
The time period must be consistent across all data points. If using LTM data, ensure all metrics are for the same trailing twelve months. If using fiscal year data, ensure all companies use the same fiscal year end.
The units must be consistent across all financial figures. If using USD Millions, all revenue, EBITDA, net income, market cap, and enterprise value figures must be in millions. Do not mix millions and billions.
The industry context determines which optional metrics to include. For example, in SaaS, include Rule of 40 and FCF Conversion. In manufacturing, include Asset Turnover and Debt/Equity. In financial services, include Net Interest Margin and Efficiency Ratio. In retail, include Inventory Turnover.
The key question determines the emphasis of the analysis. For valuation-focused analysis, emphasize multiples and their statistics. For efficiency-focused analysis, emphasize margins and turnover ratios. For growth-focused analysis, emphasize revenue growth and CAGR. For cash generation analysis, emphasize FCF metrics and conversion rates.
The audience determines the level of detail and presentation style. For an investment committee, provide a summary with key takeaways. For a board, provide a detailed breakdown with all metrics. For a quick reference, provide only the most important metrics. For a detailed memo, include full methodology and source documentation.
The notes section should be placed at the bottom of the spreadsheet, after all data and statistics. It should be clearly labeled and formatted with the same font and alignment conventions as the rest of the model.
The date stamp in the output checklist refers to the as-of date for the data, not the date of model creation. Ensure this date is prominently displayed in Row 3 of the spreadsheet.
The recalculation script should be run immediately before final delivery. Do not make any changes to the model after running the script without re-running it.
If the recalculation script produces errors, investigate and fix them before delivery. Common errors include circular references, missing data, and incorrect formula references.
The final output file should be named according to the convention: [Company Name] - Comparable Company Analysis - [As-of Date].xlsx. For example, Microsoft - Comparable Company Analysis - Q4 2024.xlsx.
The model should be saved in the ./out/ directory unless the user specifies a different output location.
All hardcoded inputs must be in blue text. Set this using cell.font = Font(color='0000FF') for input cells. Derived values (formulas) should be in black text.
The cell comments should include the date the data was accessed, the source name, and the specific data point referenced. For example: "Bloomberg Terminal - MSFT Equity DES, accessed 2024-10-02 - LTM Revenue".
When adding hyperlinks, ensure the link is to the specific filing or page that contains the data, not just the general website. For SEC EDGAR, link to the specific filing page.
The [UNSOURCED] flag should be used sparingly and only when all available data sources have been exhausted. If a data point is unsourced, the entire analysis may be compromised, so flag it prominently.
The model should be designed to be self-contained. Do not reference external files or data sources that are not included in the delivery.
The user may request sensitivity analysis on key assumptions. If so, use the excel-author skill conventions for sensitivity tables, which include input cells for the variable being changed and output cells for the resulting metrics.
The model should be built to be easily updated. All hardcoded inputs should be in a single section, and all formulas should reference that section. This allows the user to update data quickly without rebuilding the model.
The statistics block should be recalculated automatically when data changes. Ensure all statistical formulas reference the data range correctly.
The model should include a check for data consistency. For example, ensure that the sum of individual segment revenues equals total revenue, and that net income is less than operating income.
The model should be tested with a small set of known data to verify that all formulas produce correct results. Use the example file at examples/comps_example.xlsx as a reference for expected outputs.
The final delivery should include a brief summary of key findings, either in the notes section or in a separate summary sheet. This summary should highlight the most important insights from the analysis.
The model should be protected against accidental changes. Consider locking cells that contain formulas, leaving only input cells unlocked. Use worksheet.protection.sheet = True to enable protection.
The user may request that the model be printed in a specific layout. If so, set print area, page margins, and page orientation accordingly.
The model should be compatible with both Windows and Mac versions of Excel. Avoid using features that are only available in one version.
The model should be optimized for performance. Avoid using volatile functions like =INDIRECT or =OFFSET unless necessary. Use =INDEX(MATCH()) instead of =VLOOKUP for better performance.
The model should include a version number and date of last update in the notes section. This helps track changes over time.
The model should be designed to handle up to 20 companies in the peer group. If the user provides more than 20, consider splitting into multiple analyses or using a different methodology.
The model should handle missing data gracefully. If a company does not have a particular metric, leave the cell blank or use "N/A" rather than zero, which could distort statistics.
The model should include a check for outliers. If a company's metric is more than three standard deviations from the mean, flag it for review.
The model should be built with the assumption that the user will update it periodically. Include clear instructions in the notes section on how to update data and recalculate.
The model should be designed to be auditable. All assumptions should be documented, and all data sources should be cited. The model should be easy for a third party to review and verify.
The model should be built to support multiple scenarios. If the user wants to test different assumptions, use a scenario manager or data table to compare results.
The model should be built to support multiple currencies. If the user provides data in different currencies, convert all figures to the base currency using the appropriate exchange rate.
The model should be built to support different fiscal year ends. If companies have different fiscal year ends, adjust the data to a common period before comparison.
The model should be built to support different accounting standards (GAAP vs. IFRS). If companies use different standards, note the differences and adjust if necessary.
The model should be built to support different reporting currencies. If a company reports in a currency other than the base currency, convert using the appropriate exchange rate.
The model should be built to support different time periods (LTM, fiscal year, calendar year). Ensure all data is for the same period before comparison.
The model should be built to support different levels of consolidation. If a company reports consolidated financials, use those. If it reports segment data, use that if relevant.
The model should be built to support different types of companies (public, private, subsidiaries). For private companies, use available data and note the limitations.
The model should be built to support different industries. Adjust the metric set based on the industry context provided by the user.
The model should be built to support different analysis objectives. Adjust the emphasis based on the key question provided by the user.
The model should be built to support different audience needs. Adjust the level of detail and presentation style based on the audience provided by the user.
The model should be built to support different formatting preferences. Apply user-provided templates or formatting preferences over the defaults.
The model should be built to support different data sources. Use the data source hierarchy to ensure the most reliable data is used.
The model should be built to support different levels of automation. Use MCP data sources when available, but have fallback procedures for manual data entry.
The model should be built to support different levels of quality control. Run the sanity checks and verify all formulas before delivery.
The model should be built to support different levels of documentation. Complete the notes section with all required information.
The model should be built to support different delivery formats. The primary output is .xlsx, but the user may request PDF or printed output.
The model should be built to support different recalculation needs. Run the recalculation script before delivery to ensure all formulas are updated.
The model should be built to support different output locations. Save the file to the specified output directory.
The model should be built to support different naming conventions. Use the standard naming convention unless the user specifies otherwise.
The model should be built to support different version control needs. Include version number and date in the notes section.
The model should be built to support different audit trail needs. All hardcoded inputs must have cell comments citing the source.
The model should be built to support different error handling needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation needs. Check for consistency and flag outliers.
The model should be built to support different statistical needs. Include all five statistics (Max, 75th, Median, 25th, Min) for all comparable metrics.
The model should be built to support different formatting needs. Apply the standard formatting conventions unless overridden by user preferences.
The model should be built to support different font needs. Use Times New Roman for all text.
The model should be built to support different color needs. Use the specified color codes for headers and statistics rows.
The model should be built to support different alignment needs. Center-align all metrics.
The model should be built to support different border needs. No borders on any cells.
The model should be built to support different column width needs. Use uniform column widths.
The model should be built to support different row height needs. Use uniform row heights.
The model should be built to support different number format needs. Use the specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula needs. Use the specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference needs. Use the specified patterns for referencing other sheets.
The model should be built to support different lookup needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation needs. Use the specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric needs. Adjust the metric set based on the industry context.
The model should be built to support different analysis framework needs. Document the investment thesis and key metrics in the notes section.
The model should be built to support different methodology documentation needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention needs. Avoid the common mistakes listed in the failure modes section.
The model should be built to support different quality control needs. Run the sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist needs. Verify all items on the output checklist before submitting.
The model should be built to support different recalculation needs. Run the recalculation script before delivery.
The model should be built to support different output file needs. Save the file to the specified location with the correct naming convention.
The model should be built to support different user preference needs. Apply user-provided examples and preferences over the defaults.
The model should be built to support different template needs. Apply user-provided templates over the default formatting.
The model should be built to support different data source hierarchy needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be built to support different formula error handling needs. Use IFERROR to handle divide-by-zero errors.
The model should be built to support different data consistency needs. Check for consistency across all data points.
The model should be built to support different outlier detection needs. Flag metrics that are more than three standard deviations from the mean.
The model should be built to support different scenario analysis needs. Use sensitivity tables or scenario managers as requested.
The model should be built to support different currency conversion needs. Convert all figures to the base currency using appropriate exchange rates.
The model should be built to support different fiscal year adjustment needs. Adjust data to a common period before comparison.
The model should be built to support different accounting standard adjustment needs. Note differences between GAAP and IFRS and adjust if necessary.
The model should be built to support different reporting currency adjustment needs. Convert using appropriate exchange rates.
The model should be built to support different time period adjustment needs. Ensure all data is for the same period before comparison.
The model should be built to support different consolidation level adjustment needs. Use consolidated financials unless segment data is more relevant.
The model should be built to support different company type adjustment needs. Note limitations for private companies.
The model should be built to support different industry adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis objective adjustment needs. Adjust emphasis based on key question.
The model should be built to support different audience adjustment needs. Adjust level of detail and presentation style based on audience.
The model should be built to support different formatting preference adjustment needs. Apply user-provided templates or preferences.
The model should be built to support different data source adjustment needs. Use data source hierarchy to ensure most reliable data.
The model should be built to support different automation level adjustment needs. Use MCP data sources when available, have fallback procedures.
The model should be built to support different quality control level adjustment needs. Run sanity checks and verify formulas.
The model should be built to support different documentation level adjustment needs. Complete notes section with all required information.
The model should be built to support different delivery format adjustment needs. Primary output is .xlsx, but support PDF or printed output if requested.
The model should be built to support different recalculation need adjustment needs. Run recalculation script before delivery.
The model should be built to support different output location adjustment needs. Save to specified output directory.
The model should be built to support different naming convention adjustment needs. Use standard naming convention unless user specifies otherwise.
The model should be built to support different version control adjustment needs. Include version number and date in notes section.
The model should be built to support different audit trail adjustment needs. All hardcoded inputs must have cell comments citing source.
The model should be built to support different error handling adjustment needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation adjustment needs. Check for consistency and flag outliers.
The model should be built to support different statistical adjustment needs. Include all five statistics for all comparable metrics.
The model should be built to support different formatting adjustment needs. Apply standard formatting conventions unless overridden.
The model should be built to support different font adjustment needs. Use Times New Roman for all text.
The model should be built to support different color adjustment needs. Use specified color codes for headers and statistics rows.
The model should be built to support different alignment adjustment needs. Center-align all metrics.
The model should be built to support different border adjustment needs. No borders on any cells.
The model should be built to support different column width adjustment needs. Use uniform column widths.
The model should be built to support different row height adjustment needs. Use uniform row heights.
The model should be built to support different number format adjustment needs. Use specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula adjustment needs. Use specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference adjustment needs. Use specified patterns for referencing other sheets.
The model should be built to support different lookup adjustment needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation adjustment needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting adjustment needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function adjustment needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation adjustment needs. Use specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis framework adjustment needs. Document investment thesis and key metrics in notes section.
The model should be built to support different methodology documentation adjustment needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation adjustment needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition adjustment needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention adjustment needs. Avoid common mistakes listed in failure modes section.
The model should be built to support different quality control adjustment needs. Run sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist adjustment needs. Verify all items on output checklist before submitting.
The model should be built to support different recalculation adjustment needs. Run recalculation script before delivery.
The model should be built to support different output file adjustment needs. Save file to specified location with correct naming convention.
The model should be built to support different user preference adjustment needs. Apply user-provided examples and preferences over defaults.
The model should be built to support different template adjustment needs. Apply user-provided templates over default formatting.
The model should be built to support different data source hierarchy adjustment needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment adjustment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink adjustment needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging adjustment needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be built to support different formula error handling adjustment needs. Use IFERROR to handle divide-by-zero errors.
The model should be built to support different data consistency adjustment needs. Check for consistency across all data points.
The model should be built to support different outlier detection adjustment needs. Flag metrics that are more than three standard deviations from the mean.
The model should be built to support different scenario analysis adjustment needs. Use sensitivity tables or scenario managers as requested.
The model should be built to support different currency conversion adjustment needs. Convert all figures to base currency using appropriate exchange rates.
The model should be built to support different fiscal year adjustment adjustment needs. Adjust data to common period before comparison.
The model should be built to support different accounting standard adjustment adjustment needs. Note differences between GAAP and IFRS and adjust if necessary.
The model should be built to support different reporting currency adjustment adjustment needs. Convert using appropriate exchange rates.
The model should be built to support different time period adjustment adjustment needs. Ensure all data is for same period before comparison.
The model should be built to support different consolidation level adjustment adjustment needs. Use consolidated financials unless segment data is more relevant.
The model should be built to support different company type adjustment adjustment needs. Note limitations for private companies.
The model should be built to support different industry adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis objective adjustment adjustment needs. Adjust emphasis based on key question.
The model should be built to support different audience adjustment adjustment needs. Adjust level of detail and presentation style based on audience.
The model should be built to support different formatting preference adjustment adjustment needs. Apply user-provided templates or preferences.
The model should be built to support different data source adjustment adjustment needs. Use data source hierarchy to ensure most reliable data.
The model should be built to support different automation level adjustment adjustment needs. Use MCP data sources when available, have fallback procedures.
The model should be built to support different quality control level adjustment adjustment needs. Run sanity checks and verify formulas.
The model should be built to support different documentation level adjustment adjustment needs. Complete notes section with all required information.
The model should be built to support different delivery format adjustment adjustment needs. Primary output is .xlsx, but support PDF or printed output if requested.
The model should be built to support different recalculation need adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output location adjustment adjustment needs. Save to specified output directory.
The model should be built to support different naming convention adjustment adjustment needs. Use standard naming convention unless user specifies otherwise.
The model should be built to support different version control adjustment adjustment needs. Include version number and date in notes section.
The model should be built to support different audit trail adjustment adjustment needs. All hardcoded inputs must have cell comments citing source.
The model should be built to support different error handling adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation adjustment adjustment needs. Check for consistency and flag outliers.
The model should be built to support different statistical adjustment adjustment needs. Include all five statistics for all comparable metrics.
The model should be built to support different formatting adjustment adjustment needs. Apply standard formatting conventions unless overridden.
The model should be built to support different font adjustment adjustment needs. Use Times New Roman for all text.
The model should be built to support different color adjustment adjustment needs. Use specified color codes for headers and statistics rows.
The model should be built to support different alignment adjustment adjustment needs. Center-align all metrics.
The model should be built to support different border adjustment adjustment needs. No borders on any cells.
The model should be built to support different column width adjustment adjustment needs. Use uniform column widths.
The model should be built to support different row height adjustment adjustment needs. Use uniform row heights.
The model should be built to support different number format adjustment adjustment needs. Use specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula adjustment adjustment needs. Use specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference adjustment adjustment needs. Use specified patterns for referencing other sheets.
The model should be built to support different lookup adjustment adjustment needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation adjustment adjustment needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting adjustment adjustment needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function adjustment adjustment needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation adjustment adjustment needs. Use specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis framework adjustment adjustment needs. Document investment thesis and key metrics in notes section.
The model should be built to support different methodology documentation adjustment adjustment needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation adjustment adjustment needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition adjustment adjustment needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention adjustment adjustment needs. Avoid common mistakes listed in failure modes section.
The model should be built to support different quality control adjustment adjustment needs. Run sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist adjustment adjustment needs. Verify all items on output checklist before submitting.
The model should be built to support different recalculation adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output file adjustment adjustment needs. Save file to specified location with correct naming convention.
The model should be built to support different user preference adjustment adjustment needs. Apply user-provided examples and preferences over defaults.
The model should be built to support different template adjustment adjustment needs. Apply user-provided templates over default formatting.
The model should be built to support different data source hierarchy adjustment adjustment needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment adjustment adjustment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink adjustment adjustment needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging adjustment adjustment needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be built to support different formula error handling adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors.
The model should be built to support different data consistency adjustment adjustment needs. Check for consistency across all data points.
The model should be built to support different outlier detection adjustment adjustment needs. Flag metrics that are more than three standard deviations from the mean.
The model should be built to support different scenario analysis adjustment adjustment needs. Use sensitivity tables or scenario managers as requested.
The model should be built to support different currency conversion adjustment adjustment needs. Convert all figures to base currency using appropriate exchange rates.
The model should be built to support different fiscal year adjustment adjustment adjustment needs. Adjust data to common period before comparison.
The model should be built to support different accounting standard adjustment adjustment adjustment needs. Note differences between GAAP and IFRS and adjust if necessary.
The model should be built to support different reporting currency adjustment adjustment adjustment needs. Convert using appropriate exchange rates.
The model should be built to support different time period adjustment adjustment adjustment needs. Ensure all data is for same period before comparison.
The model should be built to support different consolidation level adjustment adjustment adjustment needs. Use consolidated financials unless segment data is more relevant.
The model should be built to support different company type adjustment adjustment adjustment needs. Note limitations for private companies.
The model should be built to support different industry adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis objective adjustment adjustment adjustment needs. Adjust emphasis based on key question.
The model should be built to support different audience adjustment adjustment adjustment needs. Adjust level of detail and presentation style based on audience.
The model should be built to support different formatting preference adjustment adjustment adjustment needs. Apply user-provided templates or preferences.
The model should be built to support different data source adjustment adjustment adjustment needs. Use data source hierarchy to ensure most reliable data.
The model should be built to support different automation level adjustment adjustment adjustment needs. Use MCP data sources when available, have fallback procedures.
The model should be built to support different quality control level adjustment adjustment adjustment needs. Run sanity checks and verify formulas.
The model should be built to support different documentation level adjustment adjustment adjustment needs. Complete notes section with all required information.
The model should be built to support different delivery format adjustment adjustment adjustment needs. Primary output is .xlsx, but support PDF or printed output if requested.
The model should be built to support different recalculation need adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output location adjustment adjustment adjustment needs. Save to specified output directory.
The model should be built to support different naming convention adjustment adjustment adjustment needs. Use standard naming convention unless user specifies otherwise.
The model should be built to support different version control adjustment adjustment adjustment needs. Include version number and date in notes section.
The model should be built to support different audit trail adjustment adjustment adjustment needs. All hardcoded inputs must have cell comments citing source.
The model should be built to support different error handling adjustment adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation adjustment adjustment adjustment needs. Check for consistency and flag outliers.
The model should be built to support different statistical adjustment adjustment adjustment needs. Include all five statistics for all comparable metrics.
The model should be built to support different formatting adjustment adjustment adjustment needs. Apply standard formatting conventions unless overridden.
The model should be built to support different font adjustment adjustment adjustment needs. Use Times New Roman for all text.
The model should be built to support different color adjustment adjustment adjustment needs. Use specified color codes for headers and statistics rows.
The model should be built to support different alignment adjustment adjustment adjustment needs. Center-align all metrics.
The model should be built to support different border adjustment adjustment adjustment needs. No borders on any cells.
The model should be built to support different column width adjustment adjustment adjustment needs. Use uniform column widths.
The model should be built to support different row height adjustment adjustment adjustment needs. Use uniform row heights.
The model should be built to support different number format adjustment adjustment adjustment needs. Use specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula adjustment adjustment adjustment needs. Use specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference adjustment adjustment adjustment needs. Use specified patterns for referencing other sheets.
The model should be built to support different lookup adjustment adjustment adjustment needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation adjustment adjustment adjustment needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting adjustment adjustment adjustment needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function adjustment adjustment adjustment needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation adjustment adjustment adjustment needs. Use specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis framework adjustment adjustment adjustment needs. Document investment thesis and key metrics in notes section.
The model should be built to support different methodology documentation adjustment adjustment adjustment needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation adjustment adjustment adjustment needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition adjustment adjustment adjustment needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention adjustment adjustment adjustment needs. Avoid common mistakes listed in failure modes section.
The model should be built to support different quality control adjustment adjustment adjustment needs. Run sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist adjustment adjustment adjustment needs. Verify all items on output checklist before submitting.
The model should be built to support different recalculation adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output file adjustment adjustment adjustment needs. Save file to specified location with correct naming convention.
The model should be built to support different user preference adjustment adjustment adjustment needs. Apply user-provided examples and preferences over defaults.
The model should be built to support different template adjustment adjustment adjustment needs. Apply user-provided templates over default formatting.
The model should be built to support different data source hierarchy adjustment adjustment adjustment needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment adjustment adjustment adjustment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink adjustment adjustment adjustment needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging adjustment adjustment adjustment needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be built to support different formula error handling adjustment adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors.
The model should be built to support different data consistency adjustment adjustment adjustment needs. Check for consistency across all data points.
The model should be built to support different outlier detection adjustment adjustment adjustment needs. Flag metrics that are more than three standard deviations from the mean.
The model should be built to support different scenario analysis adjustment adjustment adjustment needs. Use sensitivity tables or scenario managers as requested.
The model should be built to support different currency conversion adjustment adjustment adjustment needs. Convert all figures to base currency using appropriate exchange rates.
The model should be built to support different fiscal year adjustment adjustment adjustment adjustment needs. Adjust data to common period before comparison.
The model should be built to support different accounting standard adjustment adjustment adjustment adjustment needs. Note differences between GAAP and IFRS and adjust if necessary.
The model should be built to support different reporting currency adjustment adjustment adjustment adjustment needs. Convert using appropriate exchange rates.
The model should be built to support different time period adjustment adjustment adjustment adjustment needs. Ensure all data is for same period before comparison.
The model should be built to support different consolidation level adjustment adjustment adjustment adjustment needs. Use consolidated financials unless segment data is more relevant.
The model should be built to support different company type adjustment adjustment adjustment adjustment needs. Note limitations for private companies.
The model should be built to support different industry adjustment adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis objective adjustment adjustment adjustment adjustment needs. Adjust emphasis based on key question.
The model should be built to support different audience adjustment adjustment adjustment adjustment needs. Adjust level of detail and presentation style based on audience.
The model should be built to support different formatting preference adjustment adjustment adjustment adjustment needs. Apply user-provided templates or preferences.
The model should be built to support different data source adjustment adjustment adjustment adjustment needs. Use data source hierarchy to ensure most reliable data.
The model should be built to support different automation level adjustment adjustment adjustment adjustment needs. Use MCP data sources when available, have fallback procedures.
The model should be built to support different quality control level adjustment adjustment adjustment adjustment needs. Run sanity checks and verify formulas.
The model should be built to support different documentation level adjustment adjustment adjustment adjustment needs. Complete notes section with all required information.
The model should be built to support different delivery format adjustment adjustment adjustment adjustment needs. Primary output is .xlsx, but support PDF or printed output if requested.
The model should be built to support different recalculation need adjustment adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output location adjustment adjustment adjustment adjustment needs. Save to specified output directory.
The model should be built to support different naming convention adjustment adjustment adjustment adjustment needs. Use standard naming convention unless user specifies otherwise.
The model should be built to support different version control adjustment adjustment adjustment adjustment needs. Include version number and date in notes section.
The model should be built to support different audit trail adjustment adjustment adjustment adjustment needs. All hardcoded inputs must have cell comments citing source.
The model should be built to support different error handling adjustment adjustment adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation adjustment adjustment adjustment adjustment needs. Check for consistency and flag outliers.
The model should be built to support different statistical adjustment adjustment adjustment adjustment needs. Include all five statistics for all comparable metrics.
The model should be built to support different formatting adjustment adjustment adjustment adjustment needs. Apply standard formatting conventions unless overridden.
The model should be built to support different font adjustment adjustment adjustment adjustment needs. Use Times New Roman for all text.
The model should be built to support different color adjustment adjustment adjustment adjustment needs. Use specified color codes for headers and statistics rows.
The model should be built to support different alignment adjustment adjustment adjustment adjustment needs. Center-align all metrics.
The model should be built to support different border adjustment adjustment adjustment adjustment needs. No borders on any cells.
The model should be built to support different column width adjustment adjustment adjustment adjustment needs. Use uniform column widths.
The model should be built to support different row height adjustment adjustment adjustment adjustment needs. Use uniform row heights.
The model should be built to support different number format adjustment adjustment adjustment adjustment needs. Use specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula adjustment adjustment adjustment adjustment needs. Use specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference adjustment adjustment adjustment adjustment needs. Use specified patterns for referencing other sheets.
The model should be built to support different lookup adjustment adjustment adjustment adjustment needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation adjustment adjustment adjustment adjustment needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting adjustment adjustment adjustment adjustment needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function adjustment adjustment adjustment adjustment needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation adjustment adjustment adjustment adjustment needs. Use specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric adjustment adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis framework adjustment adjustment adjustment adjustment needs. Document investment thesis and key metrics in notes section.
The model should be built to support different methodology documentation adjustment adjustment adjustment adjustment needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation adjustment adjustment adjustment adjustment needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition adjustment adjustment adjustment adjustment needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention adjustment adjustment adjustment adjustment needs. Avoid common mistakes listed in failure modes section.
The model should be built to support different quality control adjustment adjustment adjustment adjustment needs. Run sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist adjustment adjustment adjustment adjustment needs. Verify all items on output checklist before submitting.
The model should be built to support different recalculation adjustment adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output file adjustment adjustment adjustment adjustment needs. Save file to specified location with correct naming convention.
The model should be built to support different user preference adjustment adjustment adjustment adjustment needs. Apply user-provided examples and preferences over defaults.
The model should be built to support different template adjustment adjustment adjustment adjustment needs. Apply user-provided templates over default formatting.
The model should be built to support different data source hierarchy adjustment adjustment adjustment adjustment needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment adjustment adjustment adjustment adjustment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink adjustment adjustment adjustment adjustment needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging adjustment adjustment adjustment adjustment needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be built to support different formula error handling adjustment adjustment adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors.
The model should be built to support different data consistency adjustment adjustment adjustment adjustment needs. Check for consistency across all data points.
The model should be built to support different outlier detection adjustment adjustment adjustment adjustment needs. Flag metrics that are more than three standard deviations from the mean.
The model should be built to support different scenario analysis adjustment adjustment adjustment adjustment needs. Use sensitivity tables or scenario managers as requested.
The model should be built to support different currency conversion adjustment adjustment adjustment adjustment needs. Convert all figures to base currency using appropriate exchange rates.
The model should be built to support different fiscal year adjustment adjustment adjustment adjustment adjustment needs. Adjust data to common period before comparison.
The model should be built to support different accounting standard adjustment adjustment adjustment adjustment adjustment needs. Note differences between GAAP and IFRS and adjust if necessary.
The model should be built to support different reporting currency adjustment adjustment adjustment adjustment adjustment needs. Convert using appropriate exchange rates.
The model should be built to support different time period adjustment adjustment adjustment adjustment adjustment needs. Ensure all data is for same period before comparison.
The model should be built to support different consolidation level adjustment adjustment adjustment adjustment adjustment needs. Use consolidated financials unless segment data is more relevant.
The model should be built to support different company type adjustment adjustment adjustment adjustment adjustment needs. Note limitations for private companies.
The model should be built to support different industry adjustment adjustment adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis objective adjustment adjustment adjustment adjustment adjustment needs. Adjust emphasis based on key question.
The model should be built to support different audience adjustment adjustment adjustment adjustment adjustment needs. Adjust level of detail and presentation style based on audience.
The model should be built to support different formatting preference adjustment adjustment adjustment adjustment adjustment needs. Apply user-provided templates or preferences.
The model should be built to support different data source adjustment adjustment adjustment adjustment adjustment needs. Use data source hierarchy to ensure most reliable data.
The model should be built to support different automation level adjustment adjustment adjustment adjustment adjustment needs. Use MCP data sources when available, have fallback procedures.
The model should be built to support different quality control level adjustment adjustment adjustment adjustment adjustment needs. Run sanity checks and verify formulas.
The model should be built to support different documentation level adjustment adjustment adjustment adjustment adjustment needs. Complete notes section with all required information.
The model should be built to support different delivery format adjustment adjustment adjustment adjustment adjustment needs. Primary output is .xlsx, but support PDF or printed output if requested.
The model should be built to support different recalculation need adjustment adjustment adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output location adjustment adjustment adjustment adjustment adjustment needs. Save to specified output directory.
The model should be built to support different naming convention adjustment adjustment adjustment adjustment adjustment needs. Use standard naming convention unless user specifies otherwise.
The model should be built to support different version control adjustment adjustment adjustment adjustment adjustment needs. Include version number and date in notes section.
The model should be built to support different audit trail adjustment adjustment adjustment adjustment adjustment needs. All hardcoded inputs must have cell comments citing source.
The model should be built to support different error handling adjustment adjustment adjustment adjustment adjustment needs. Use IFERROR to handle divide-by-zero errors gracefully.
The model should be built to support different data validation adjustment adjustment adjustment adjustment adjustment needs. Check for consistency and flag outliers.
The model should be built to support different statistical adjustment adjustment adjustment adjustment adjustment needs. Include all five statistics for all comparable metrics.
The model should be built to support different formatting adjustment adjustment adjustment adjustment adjustment needs. Apply standard formatting conventions unless overridden.
The model should be built to support different font adjustment adjustment adjustment adjustment adjustment needs. Use Times New Roman for all text.
The model should be built to support different color adjustment adjustment adjustment adjustment adjustment needs. Use specified color codes for headers and statistics rows.
The model should be built to support different alignment adjustment adjustment adjustment adjustment adjustment needs. Center-align all metrics.
The model should be built to support different border adjustment adjustment adjustment adjustment adjustment needs. No borders on any cells.
The model should be built to support different column width adjustment adjustment adjustment adjustment adjustment needs. Use uniform column widths.
The model should be built to support different row height adjustment adjustment adjustment adjustment adjustment needs. Use uniform row heights.
The model should be built to support different number format adjustment adjustment adjustment adjustment adjustment needs. Use specified formats for percentages, multiples, and dollar amounts.
The model should be built to support different formula adjustment adjustment adjustment adjustment adjustment needs. Use specified formula patterns for all calculations.
The model should be built to support different cross-sheet reference adjustment adjustment adjustment adjustment adjustment needs. Use specified patterns for referencing other sheets.
The model should be built to support different lookup adjustment adjustment adjustment adjustment adjustment needs. Use VLOOKUP or INDEX(MATCH()) as appropriate.
The model should be built to support different conditional calculation adjustment adjustment adjustment adjustment adjustment needs. Use IF and IFERROR as appropriate.
The model should be built to support different text formatting adjustment adjustment adjustment adjustment adjustment needs. Use TEXT function to format values as needed.
The model should be built to support different statistical function adjustment adjustment adjustment adjustment adjustment needs. Use AVERAGE, MEDIAN, QUARTILE, MAX, MIN, and STDEV.P as appropriate.
The model should be built to support different financial calculation adjustment adjustment adjustment adjustment adjustment needs. Use specified formulas for margins, multiples, and ratios.
The model should be built to support different industry-specific metric adjustment adjustment adjustment adjustment adjustment needs. Adjust metric set based on industry context.
The model should be built to support different analysis framework adjustment adjustment adjustment adjustment adjustment needs. Document investment thesis and key metrics in notes section.
The model should be built to support different methodology documentation adjustment adjustment adjustment adjustment adjustment needs. Explain how multiples are calculated and any adjustments made.
The model should be built to support different data source documentation adjustment adjustment adjustment adjustment adjustment needs. Document where data was sourced from and how it was verified.
The model should be built to support different key definition adjustment adjustment adjustment adjustment adjustment needs. Define all metrics used in the analysis.
The model should be built to support different failure mode prevention adjustment adjustment adjustment adjustment adjustment needs. Avoid common mistakes listed in failure modes section.
The model should be built to support different quality control adjustment adjustment adjustment adjustment adjustment needs. Run sanity checks and verify all formulas before delivery.
The model should be built to support different delivery checklist adjustment adjustment adjustment adjustment adjustment needs. Verify all items on output checklist before submitting.
The model should be built to support different recalculation adjustment adjustment adjustment adjustment adjustment needs. Run recalculation script before delivery.
The model should be built to support different output file adjustment adjustment adjustment adjustment adjustment needs. Save file to specified location with correct naming convention.
The model should be built to support different user preference adjustment adjustment adjustment adjustment adjustment needs. Apply user-provided examples and preferences over defaults.
The model should be built to support different template adjustment adjustment adjustment adjustment adjustment needs. Apply user-provided templates over default formatting.
The model should be built to support different data source hierarchy adjustment adjustment adjustment adjustment adjustment needs. Use MCP data sources first, then fallback sources.
The model should be built to support different cell comment adjustment adjustment adjustment adjustment adjustment needs. Add comments to all hardcoded inputs.
The model should be built to support different hyperlink adjustment adjustment adjustment adjustment adjustment needs. Add hyperlinks to SEC filings or data sources when possible.
The model should be built to support different unsourced data flagging adjustment adjustment adjustment adjustment adjustment needs. Use [UNSOURCED] flag when data cannot be sourced.
The model should be

Build Comparable Company Valuation Workbooks with Hermes Agent