# TechPath Learning Intelligence Engine (`successful_yearning/techpath-learning-intelligence`) Actor
Turn the scattered technical-learning web into a structured, dependency-aware development pathway with skill checks, projects, and hackathon matches.
- **URL**: https://apify.com/successful_yearning/techpath-learning-intelligence.md
- **Developed by:** [Ella](https://apify.com/successful_yearning) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.05 / result
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
## TechPath Learning Intelligence
### What can TechPath do?
TechPath **builds a personalized, dependency-aware learning roadmap from across the open web** in a single tool: real courses, tutorials, and videos for your goal, staged from your current level to interview-ready, plus quizzes, projects, and matched opportunities. Add a goal with your current level and you can:
| π¦ What you can build | βοΈ Features & integrations |
|---|---|
| πΊοΈ **Staged roadmaps** from beginner foundations to advanced, interview-ready skill | π **Live discovery** across search results and YouTube, not a static curated list |
| π **Quizzes** per stage to check you're actually ready to move on | π
**Freshness-aware** β every resource is discovered at run time, not hardcoded |
| π οΈ **Projects and a capstone brief** β problem statement, milestones, rubric | β¬οΈ **Export data** to JSON, CSV, or Excel |
| π― **Opportunity matches** β hackathons, internships fit to your current stage, not just the most popular one | π **API access** via the Apify API and CLI |
| π **Human-readable report** as well as structured data | π€ **LLM-structured** output, built for MCP, Claude, Gemini, or ChatGPT to consume downstream |
If you're a beginner without a mentor, an intermediate learner who doesn't know what's next, a career switcher, a student prepping for interviews, or an educator building a curriculum, you can get a full personalized path from a single tool.
### What data can I get from TechPath?
TechPath is the structure the open web is missing β the roadmap, the proof-of-readiness, and the next real opportunity behind any tech-learning goal:
- **Roadmap stages:** *what to learn, and in what order.* Foundations β Core Skills β Specialization β Build β Prove β Advance, each with the specific skills that stage covers.
- **Resources:** *real, live links β not a stale list.* Articles, docs, and videos discovered from the web at the moment you run it, each with its title, URL, and type.
- **Quizzes:** *proof you're ready to move on.* A short skill check per stage β conceptual questions, coding prompts, or mini tasks.
- **Projects:** *proof you can build it.* A practical project per stage, plus a full capstone brief β problem statement, objectives, stack, milestones, evaluation rubric β for your target role.
- **Opportunity matches:** *what's actually next for you.* Hackathons, internships, and competitions matched to your current stage, with the reason each one fits.
You can generate a roadmap from just a goal and level, or refine it with your known skills, hours per week, and interests for a more personalized path.
### How It Works β Step by Step
#### 1. You submit a learner profile
You fill in your `goal`, `currentLevel`, and β optionally β your `knownSkills`, `hoursPerWeek`, and `interests`. Apify auto-generates this form directly from the input schema, so no coding is needed to try it from the Console.
#### 2. TechPath calls other Actors to discover real resources
Once you click Start, TechPath's own code (`main.py`) runs on Apify's servers. The first thing it does is call two other Actors already published on the Apify Store, as sub-runs:
- `apify/google-search-scraper` β searches the live web for courses, tutorials, and roadmap content matching your goal
- `streamers/youtube-scraper` β searches YouTube for relevant tutorial videos
This is genuine Actor-to-Actor composition, not a single monolithic scraper: TechPath's code calls `Actor.call(actor_id=..., run_input=...)`, which starts each of those Actors as its own independent run, waits for it to finish, and pulls its dataset back in. Nothing here is hardcoded β every resource returned is whatever those Actors find live, at the exact moment you run TechPath.
*Screenshot to insert: either the `main.py` source showing the `Actor.call()` lines, or the Console "Runs" view showing the nested `google-search-scraper` and `youtube-scraper` runs kicking off underneath your TechPath run.*
#### 3. The LLM structures the raw data into a roadmap
Raw scraped titles, URLs, and descriptions are just a messy list on their own β not a roadmap. TechPath sends that raw data, together with your profile, to an LLM with strict instructions: build a staged roadmap (Foundations β Core Skills β Specialization β Build β Prove β Advance), generate a short quiz and a practical project for every stage, and only ever reference resources that actually appeared in the scraped data β never invent a URL. The LLM returns this as one structured JSON object, which TechPath validates before using it.
#### 4. Results are saved two ways
Each roadmap stage is pushed to the Actor's dataset as its own row β one `Actor.push_data()` call per stage β giving you structured, machine-readable output. At the same time, TechPath renders a styled HTML version of the same roadmap and saves it to the key-value store under the key `REPORT`, so a non-technical learner can open one link and read a clean page instead of raw JSON.
\*Screenshot to insert: the Storage β Dataset tab, showing the actual roadmap-stage rows TechPath returned for a real
#### 5. You're charged per what was actually produced
Because every dataset row comes from a real `push_data()` call, turning on the `apify-default-dataset-item` synthetic PPE event means every roadmap stage automatically generates a small charge β no separate billing code anywhere in `main.py`. Turning on `apify-actor-start` charges once per run, the moment it begins.
### Mode 1: Quick roadmap
Enter your **target role** and **current level**, and TechPath builds a full staged roadmap using sensible defaults for hours per week and interests.
- `goal`, e.g. `"Machine Learning Engineer"`
- `currentLevel`: `beginner`, `intermediate`, or `advanced`
### Mode 2: Personalized deep roadmap
Add your **known skills**, **hours per week**, and **interests**, and TechPath tailors resource selection, pacing, and the capstone project to you specifically β e.g. an ML roadmap that leans into healthcare AI because that's what you told it you care about.
| Add this field | And you get |
|---|---|
| `knownSkills` | Skill gaps calculated against your actual starting point, not a generic beginner |
| `hoursPerWeek` | A pace-aware roadmap rather than a one-size-fits-all timeline |
| `interests` | Specialization stages and capstone project themed to what you actually want to build |
### Output and setup
Results land in a **dataset** β one row per roadmap stage. View it as a table in the Storage tab, download as **JSON, CSV, or Excel**, or pull it via the API. A parallel **human-readable HTML report** is saved to the key-value store under `REPORT`, so non-technical learners never have to read raw JSON.
Dataset sample:
```json
{
"stage": "Core ML",
"skills": ["supervised learning", "scikit-learn"],
"resources": [
{"title": "Intro to Scikit-learn", "url": "https://...", "type": "article"}
],
"quiz": [
{"question": "What is overfitting?", "answer": "..."}
],
"project": "Build and evaluate a classification model on a public dataset"
}
```
### How much will TechPath cost?
TechPath uses a **pay-per-event (PPE)** pricing model β you're charged for what the run actually produces, not a flat run fee:
| Event | What it means |
|---|---|
| `apify-actor-start` | Charged once when your roadmap run starts |
| `apify-default-dataset-item` | Charged per roadmap stage returned |
### Team
Udotong Peace
Mayowa Titilola
Obiajulum Ndubuisi
**Track:** EduTech β Access to education and scholarships
**Built for:** Apify x She Code Africa BuildHer Hackathon 2026 β *Ship and Earn Africa*
# Actor input Schema
## `goal` (type: `string`):
The technical career role or goal you want to achieve (e.g. 'Machine Learning Engineer', 'Software Engineer', 'Data Scientist', 'AI Engineer').
## `currentLevel` (type: `string`):
Your current overall level in this technical domain.
## `knownSkills` (type: `array`):
List of skills, programming languages, or tools you already know well.
## `hoursPerWeek` (type: `integer`):
Estimated hours per week dedicated to learning.
## `location` (type: `string`):
Learner's country/region for localized opportunity & hackathon matching.
## `interests` (type: `array`):
Specific subfields or domain applications of interest (e.g. \['NLP', 'healthcare AI']).
## `learningPreferences` (type: `array`):
Preferred content formats (e.g. \['video', 'hands-on', 'docs', 'interactive']).
## `depth` (type: `string`):
Level of detail for the generated path.
## `llmProvider` (type: `string`):
Which model backend to use. 'auto' tries Gemini Flash latest, then Claude.
## `geminiApiKey` (type: `string`):
Google Gemini API key (model: gemini-flash-latest). Can also be set as GEMINI_API_KEY.
## `anthropicApiKey` (type: `string`):
Claude API key (model: claude-sonnet-4-5). Can also be set as ANTHROPIC_API_KEY.
## `llmApiKey` (type: `string`):
Optional single key used when provider-specific keys are empty. Interpreted according to LLM Provider.
## `apifyToken` (type: `string`):
Optional Apify API token for live web scraping & search discovery.
## `email` (type: `string`):
Optional email address to automatically send the formatted TechPath HTML report to via apify/send-email Actor.
## Actor input object example
```json
{
"goal": "Machine Learning Engineer",
"currentLevel": "Beginner",
"knownSkills": [
"Python basics"
],
"hoursPerWeek": 8,
"location": "Nigeria",
"interests": [
"NLP",
"healthcare AI"
],
"learningPreferences": [
"video",
"hands-on"
],
"depth": "deep",
"llmProvider": "auto"
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {};
// Run the Actor and wait for it to finish
const run = await client.actor("successful_yearning/techpath-learning-intelligence").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {}
# Run the Actor and wait for it to finish
run = client.actor("successful_yearning/techpath-learning-intelligence").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 '{}' |
apify call successful_yearning/techpath-learning-intelligence --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,successful_yearning/techpath-learning-intelligence"
}
}
}
```
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 ` 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/3cGQUsrX8W99r2eMD/builds/9M4cJt2MVaGy0usnW/openapi.json