# Venture Launch Case Creation (`fifthrow/venture-portfolio-gate-readiness`) Actor

Turns a validated venture concept into a complete launch case and tests whether it is ready for the parent company's formal portfolio gate. It checks the validation evidence and fit with the parent's existing businesses, sizes the market and... Returns HTML, Markdown, JSON, and dataset rows.

- **URL**: https://apify.com/fifthrow/venture-portfolio-gate-readiness.md
- **Developed by:** [FifthRow](https://apify.com/fifthrow) (community)
- **Categories:** AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$25.00 / venture launch case creation report

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Turns a validated venture concept into a complete launch case and tests whether it is ready for the parent company's formal portfolio gate. It checks the validation evidence and fit with the parent's existing businesses, sizes the market and competition, works out the operating model, unit economics and funding need, and stages the ask into milestone-linked tranches with risks and stop triggers. The result is a gate-ready case with one call: submit, revise first, or stop before the gate, plus the revisions needed to get there.

It returns a decision report in HTML, Markdown, JSON, and dataset rows.

### Runtime

Typical runtime: about 36 minutes.

### Summary

Evaluate whether {VENTURE_CONCEPT} is ready for {COMPANY}'s portfolio gate using the supplied {VALIDATION_EVIDENCE} and {LAUNCH_ASK}. The analysis examines customer and market evidence, competition, fit with existing parent businesses, operating capabilities, unit economics, funding coverage, milestone staging, and material risks. It distinguishes validated claims from public evidence, assumptions, and unknowns, and identifies gaps that could change the recommendation.

The case includes an executive recommendation to submit, revise before submitting, or stop before the gate; a venture thesis and market assessment; operating-model and economics analysis; a milestone-linked tranche plan; key risks; and the requested resources, conditions, and pre-submission actions. These findings help venture leads and sponsors judge readiness and focus remaining work before formal portfolio review.

### Methodology

Use {VENTURE_CONCEPT} to define the customer, offer, business model, and launch scope; assess {COMPANY}'s relevant assets and potential business overlap using sourced evidence. Preserve the claims and results in {VALIDATION_EVIDENCE} without reinterpreting experiments, and distinguish those results from public-source findings and assumptions. Evaluate market size, demand drivers, alternatives, operating capabilities, and organizational fit using relevant, dated evidence where available.

Reconcile the unit economics and funding coverage with the resources, period, and vehicle in {LAUNCH_ASK}. Show calculations and evidence status for representative-unit scenarios, payback, break-even, and funding-envelope tests; flag unknowns rather than inventing values. Assess material risks, mitigations, and milestone-linked tranches, then apply consistent readiness criteria to make one draft call: submit, revise, or stop before the gate. The formal decision remains with the portfolio gate.

### Inputs

- `COMPANY` (text): Company. The parent company that would own the venture, with its website. Example: ENGIE (engie.com)
- `LAUNCH_ASK` (text): Launch Ask. What the team will ask the gate for: money, people, period and vehicle. Example: EUR 4m seed over 18 months inside ENGIE New Ventures for the first 10 sites
- `VALIDATION_EVIDENCE` (text): Validation Evidence. What was tested and what it showed, with numbers. A line or two is enough; the App researches the market side. Example: 6-month pilot at 3 sites, 18 interviews, 2 signed LOIs, 11% peak-charge saving
- `VENTURE_CONCEPT` (text): Venture Concept. The validated concept: customer, problem, offer, business model and launch market. Example: Battery flexibility-as-a-service for mid-size industrial sites in Belgium, no upfront cost

### Outputs

Finished runs write files to the Actor **key-value store**, plus tabular rows in the default dataset.

#### HTML report (`REPORT.html`)

A self-contained HTML brief for reading the result in a browser. Use this when you want the formatted decision output,
including headings, lists, and cited source links from the App run.

#### Markdown report (`REPORT.md`)

A portable markdown document with the same narrative as the HTML report. Use this when you want to paste the output
into docs, tickets, or another markdown editor without HTML chrome.

#### Structured JSON (`OUTPUT`)

Machine-readable JSON in the key-value store under the `OUTPUT` key. The object includes:

- `id`, `status`, `ready`: App run identity and completion state
- `title`, `catalog_url`: display title and FifthRow catalog URL
- `started_at`, `finished_at`, `duration_seconds`: run timing
- `summary`: executive summary text
- `company_impact`: implied impact narrative, when the App produced one
- `sections`: sectioned App results
- `answers`: visible answer objects (title, markdown, sources)
- `questions`: Q\&A objects produced by the run
- `sources`: deduplicated source URLs
- `dataset_items`: source rows for the default dataset (oversized dataset writes may omit markdown)
- `report_markdown`: full markdown body also stored as `REPORT.md`

#### Dataset rows

The default dataset stores rows (`run`, `summary`, `company_impact`, `answer`, `qna`)
with `title`, `markdown`, and `sources`. Rows that exceed the dataset item size limit are stored with empty markdown.

# Changelog

This Actor's version history is a separate document: https://apify.com/fifthrow/venture-portfolio-gate-readiness/changelog.md

# Actor input Schema

## `COMPANY` (type: `string`):

The parent company that would own the venture, with its website. Example: ENGIE (engie.com) Suggested examples: ENGIE (engie.com); Shell (shell.com); Siemens (siemens.com). Other clear text values are also accepted.

## `LAUNCH_ASK` (type: `string`):

What the team will ask the gate for: money, people, period and vehicle. Example: EUR 4m seed over 18 months inside ENGIE New Ventures for the first 10 sites Suggested examples: EUR 4m, 18 months, seed; USD 2m, 12 months, pilot; GBP 1m, 9 months, venture. Other clear text values are also accepted.

## `VALIDATION_EVIDENCE` (type: `string`):

What was tested and what it showed, with numbers. A line or two is enough; the App researches the market side. Example: 6-month pilot at 3 sites, 18 interviews, 2 signed LOIs, 11% peak-charge saving Suggested examples: 6-month pilot, 3 sites; 18 customer interviews; 2 signed LOIs. Other clear text values are also accepted.

## `VENTURE_CONCEPT` (type: `string`):

The validated concept: customer, problem, offer, business model and launch market. Example: Battery flexibility-as-a-service for mid-size industrial sites in Belgium, no upfront cost Suggested examples: Industrial battery flexibility Belgium; Solar leasing for SMEs France; Heat pumps for Dutch homes. Other clear text values are also accepted.

## Actor input object example

```json
{
  "COMPANY": "ENGIE (engie.com)",
  "LAUNCH_ASK": "EUR 4m, 18 months, seed",
  "VALIDATION_EVIDENCE": "6-month pilot, 3 sites",
  "VENTURE_CONCEPT": "Industrial battery flexibility Belgium"
}
```

# Actor output Schema

## `OUTPUT` (type: `string`):

Complete structured JSON result stored as KVS OUTPUT.

## `markdown` (type: `string`):

Portable markdown report stored as KVS REPORT.md.

## `overview` (type: `string`):

Run overview plus summary, company impact, answers, and Q\&A as default dataset items.

## `report` (type: `string`):

Self-contained HTML report stored as KVS REPORT.html.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "COMPANY": "ENGIE (engie.com)",
    "LAUNCH_ASK": "EUR 4m, 18 months, seed",
    "VALIDATION_EVIDENCE": "6-month pilot, 3 sites",
    "VENTURE_CONCEPT": "Industrial battery flexibility Belgium"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fifthrow/venture-portfolio-gate-readiness").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "COMPANY": "ENGIE (engie.com)",
    "LAUNCH_ASK": "EUR 4m, 18 months, seed",
    "VALIDATION_EVIDENCE": "6-month pilot, 3 sites",
    "VENTURE_CONCEPT": "Industrial battery flexibility Belgium",
}

# Run the Actor and wait for it to finish
run = client.actor("fifthrow/venture-portfolio-gate-readiness").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "COMPANY": "ENGIE (engie.com)",
  "LAUNCH_ASK": "EUR 4m, 18 months, seed",
  "VALIDATION_EVIDENCE": "6-month pilot, 3 sites",
  "VENTURE_CONCEPT": "Industrial battery flexibility Belgium"
}' |
apify call fifthrow/venture-portfolio-gate-readiness --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fifthrow/venture-portfolio-gate-readiness"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5nh1OHi3dR1wUQGZ6/builds/zlkb9apCodElQjeSz/openapi.json
