From the free course Technical Writing on Lykke
Proposals and the Technical Report Process
Key concepts: Request for Proposals (RFP) · Solicited vs. Unsolicited Proposals · Project Scope · Technical Report Lifecycle · Feasibility
Covers the creation of persuasive proposals and the multi-stage lifecycle of technical report writing.
Proposals and the Technical Report Process
In the professional engineering and technical communication landscape, a proposal serves as a foundational persuasive instrument. Far from being a mere administrative formality, a proposal is a high-stakes "contractual precursor" that bridges the gap between a perceived organizational problem and a researched, viable solution. It is the mechanism by which resources—capital, time, and personnel—are allocated to complex projects.
1. The Taxonomy of Proposals: Strategic Intent and Origins
Proposals are categorized based on their origin, target audience, and the nature of the relationship between the proposer and the recipient. Understanding these distinctions is critical for setting the correct tone and level of technical detail.
Solicited vs. Unsolicited Proposals
A Solicited Proposal is a direct response to a formal request issued by an organization. This request is typically codified as a Request for Proposals (RFP), a Request for Quotations (RFQ), or a Request for Information (RFI). Because the recipient has already acknowledged a need, the writer can focus more on the "how" (methodology) and "how much" (budget) rather than the "why" (problem identification).
An Unsolicited Proposal is sent to a recipient who has not formally requested it. These are significantly more difficult to write because they must first convince the reader that a problem exists before pitching the solution. They function as a "cold call" in document form, requiring a high degree of persuasive "hooking" and a deep understanding of the recipient's latent pain points.
Internal vs. External Proposals
- Internal Proposals: Targeted at stakeholders within the same organization (e.g., a DevOps lead proposing a shift from Jenkins to GitHub Actions to the CTO). These rely on shared organizational context and often use internal jargon.
- External Proposals: Targeted at separate entities. These are legally sensitive documents that often form the basis of a contract. They require a more formal tone and a comprehensive explanation of the proposer's qualifications.
| Feature | Solicited Proposal | Unsolicited Proposal |
|---|---|---|
| Trigger | Formal RFP/RFQ issued by client | Proposer identifies a hidden need |
| Primary Goal | Outperform competitors on specific criteria | Prove a problem exists and offer a fix |
| Audience Mindset | Evaluation-oriented; looking for compliance | Skeptical; looking for ROI and urgency |
| Structure | Strictly follows RFP requirements | Flexible, problem-solution focused |
| Risk Level | Lower (budget is likely already allocated) | Higher (budget must be "found" or created) |
2. The RFP Mechanism and Technical Compliance
The Request for Proposals (RFP) is a document that outlines a project's requirements, the scope of work, and the criteria by which submissions will be judged. For a senior engineer or project manager, the RFP is the "source of truth."
Definition: Technical Compliance The degree to which a proposal meets the explicit requirements stated in an RFP. Failure to meet even a minor requirement (e.g., font size, page limit, or a specific ISO certification) can lead to immediate disqualification regardless of the technical merit of the solution.
The "Go/No-Go" Decision
Before writing, a team must perform a Feasibility Analysis. This involves evaluating whether the organization has the technical expertise, the available bandwidth, and the financial stability to execute the project if the proposal is accepted.
3. Project Scope and Feasibility Logic
Defining the Project Scope is the most critical technical task in the proposal process. Scope defines the boundaries of the project: what is included, and—equally importantly—what is excluded. This prevents "scope creep," where a project's requirements expand uncontrollably during execution.
To determine feasibility, engineers often use a Weighted Scoring Model to evaluate potential projects against organizational goals.
Implementation: Weighted Feasibility Scoring
The following Python script demonstrates a programmatic approach to the "Go/No-Go" decision, allowing a team to quantify the risk and reward of a proposal opportunity.
import numpy as np
def calculate_proposal_score(criteria, weights):
"""
Calculates the feasibility score of a project proposal.
Args:
criteria (dict): A dictionary of criteria scores (0-10).
weights (dict): A dictionary of weights for each criterion (must sum to 1.0).
Returns:
float: The final weighted score.
"""
if not np.isclose(sum(weights.values()), 1.0):
raise ValueError("Weights must sum to 1.0")
score = sum(criteria[key] * weights[key] for key in criteria)
return round(score, 2)
# Configuration for a New Infrastructure Proposal
project_criteria = {
"technical_capability": 9, # We have the expertise
"resource_availability": 4, # Team is currently overbooked
"profit_margin": 8, # High ROI
"strategic_alignment": 7, # Fits our 3-year plan
"client_reputation": 6 # New client, moderate risk
}
project_weights = {
"technical_capability": 0.30,
"resource_availability": 0.25,
"profit_margin": 0.20,
"strategic_alignment": 0.15,
"client_reputation": 0.10
}
final_score = calculate_proposal_score(project_criteria, project_weights)
print(f"Project Feasibility Score: {final_score}/10")
if final_score >= 7.0:
print("Decision: PROCEED with Proposal.")
else:
print("Decision: REJECT/NO-GO.")
4. The Technical Report Lifecycle
The proposal is not a standalone document; it is the genesis of a multi-stage Technical Report Lifecycle. This lifecycle ensures that information remains accurate, stakeholders remain informed, and the final output meets the rigorous standards of professional communication.
- The Proposal (Planning Phase): The "pitch." Defines the problem, scope, and methodology.
- The Progress Report (Execution Phase): Periodic updates. These serve to reassure stakeholders, document completed milestones, and flag "blockers" early.
- The Draft and Peer Review (Refinement Phase): The iterative stage where technical accuracy is verified and the CRAP (Contrast, Repetition, Alignment, Proximity) principles of document design are applied.
- The Final Technical Report (Completion Phase): The comprehensive document that includes the research findings, final graphics, and actionable recommendations.
Mathematical Derivation: Cost-Benefit Analysis (CBA)
A proposal must often include a financial justification. The Net Present Value (NPV) is frequently used to show the long-term value of the proposed solution.
NPV = \sum_{t=1}^{n} \frac{R_t}{(1 + i)^t} - Initial\_Investment
Where:
- $R_t$ = Net cash inflow-outflows during a single period $t$
- $i$ = Discount rate or return that could be earned in alternative investments
- $t$ = Number of timer periods
Pseudocode: Project Scheduling Logic (Gantt Logic)
In the methodology section, you must prove you can meet the deadline. This is often represented via a Gantt chart, calculated using the Critical Path Method (CPM).
FUNCTION CalculateProjectTimeline(Tasks):
SET ProjectStart = CurrentDate
FOR EACH Task IN Tasks:
IF Task.Dependencies ARE Empty:
Task.EarliestStart = ProjectStart
ELSE:
Task.EarliestStart = MAX(Dependency.FinishTime FOR Dependency IN Task.Dependencies)
Task.FinishTime = Task.EarliestStart + Task.Duration
RETURN MAX(Task.FinishTime FOR Task IN Tasks)
5. Essential Components of a Technical Proposal
A professional proposal follows a standardized structure to ensure that evaluators can find information quickly.
| Section | Purpose | Key Content |
|---|---|---|
| Executive Summary | High-level overview for decision-makers. | The "Bottom Line Up Front" (BLUF); the core value proposition. |
| Introduction | Sets the stage and defines the problem. | Problem statement, background, and scope of the proposal. |
| Technical Methodology | The "How." Proves technical competence. | Detailed steps, tools used (e.g., Python, AWS), and quality control. |
| Schedule/Milestones | Proves the project is time-feasible. | Gantt charts, delivery dates for progress reports. |
| Budget/Cost Analysis | The "How Much." Justifies the expense. | Itemized costs, labor hours, and ROI calculations. |
| Qualifications | Proves the team can do the work. | Resumes, past project performance, and certifications. |
6. Information Literacy and Source Evaluation
Technical writing is only as good as the data supporting it. Information Literacy in a professional context involves the ability to find, evaluate, and synthesize diverse sources—ranging from internal database logs to peer-reviewed journals and white papers.
The SIFT Method for Technical Sources:
- Stop: Check the reputation of the source.
- Investigate the source: Who wrote it? Is it a vendor-neutral white paper or a marketing brochure?
- Find better coverage: Look for consensus in the field.
- Trace claims to the original context: Did the study actually say what the blog post claims it said?
7. Ethics and Professional Conduct
Proposals are persuasive, but they must remain ethical. Over-promising on a project's capabilities or under-estimating costs (low-balling) to win a contract is a violation of professional ethics.
Key Insight: The Incident Report Connection In the same way an Incident Report (like those used in campus security or industrial safety) requires objective, factual reporting of a problem, a proposal requires an objective, factual assessment of a solution. Distorting the truth in a proposal leads to project failure, legal liability, and loss of professional reputation.
Example: Real-world Build Pipeline for Technical Reports
For large-scale engineering projects, reports are often generated using "Docs-as-Code" workflows. This ensures version control and consistency.
# .github/workflows/generate-report.yml
name: Build Technical Report
on:
push:
branches: [ main ]
jobs:
build-pdf:
runs-on: ubuntu-latest
steps:
- name: Checkout Code
uses: actions/checkout@v3
- name: Install Pandoc and LaTeX
run: |
sudo apt-get update
sudo apt-get install -y pandoc texlive-xetex
- name: Compile Markdown to PDF
run: |
pandoc proposal_v1.md \
--from markdown \
--template=company_template.tex \
--pdf-engine=xelatex \
-o final_technical_proposal.pdf
- name: Upload Artifact
uses: actions/upload-artifact@v3
with:
name: proposal-pdf
path: final_technical_proposal.pdf
8. Common Pitfalls in the Proposal Process
- Audience Misalignment: Writing a highly technical methodology for a non-technical manager who only cares about the budget and timeline.
- Vague Scope: Using terms like "as needed" or "optimized" without defining the metrics. This leads to disputes during the final report phase.
- Ignoring the RFP's "Hidden" Requirements: Many RFPs include "soft" requirements, such as a commitment to sustainability or local hiring, which can be the tie-breaker in a competitive bid.
- Lack of Visual Planning: Failing to include graphics (flowcharts, diagrams, data visualizations) makes the document dense and difficult to parse.
9. Conclusion: The Persuasive Bridge
The technical report process is a journey from uncertainty to clarity. The proposal acts as the map for that journey. By combining rigorous audience analysis, ethical data synthesis, and clear project scoping, the technical writer transforms a complex problem into a manageable, fundable reality. Whether it is a solicited response to a government RFP or an internal push for better infrastructure, the proposal is the most powerful tool in a professional's arsenal for driving organizational change.
Source Materials
Study Technical Writing on Lykke
This course page is free to open: signed out, you can read its first two sections, and signing in, on any plan, opens the rest. The free Lykke Chrome extension syncs your own Canvas courses, so ChatGPT, Claude and Muse can answer from your classes and deadlines. It only reads Canvas.
Add the free extensionSign in to open every sectionAll sections of Technical Writing · Browse more course pages