← Lillie AcademyCourse contentslillieearthintelligence.com

Module 12: Portfolio, Interviews, and Applications

Phase: IV, Production and the job
Level: Capstone
Estimated time: ~12 hours (about 2 h portfolio polish, 4 h interview prep, 6 h job search)
Prerequisites: Modules 1 to 11 (four portfolio projects, three public write-ups, a deployed service).
Portfolio thread: the finish line. A polished eo-portfolio, a rewritten resume, and a running application campaign.

Why this module

By now you have four portfolio projects, three public write-ups, and a deployed, scheduled service, which is more than most applicants for a remote-sensing ML role bring. The job of this module is to make that work legible: to a recruiter scanning for 90 seconds, and to a hiring manager reading for 10 minutes. Strong work that is hard to find or hard to read loses to weaker work that is presented clearly. This module closes that gap and turns the portfolio into offers.

Learning outcomes

After this module you can:

  1. Assemble a top-level portfolio README that sells the four projects at a glance.
  2. Rewrite a resume that leads with outcomes and the exact stack recruiters search for.
  3. Answer SAR and EO technical interview questions fluently.
  4. Structure an ML system-design answer under pressure.
  5. Handle live-coding with rasterio and xarray.
  6. Run a targeted, tracked application campaign.

Concept lessons and prep (about 6 hours)

Lesson 1: The portfolio README (the 90-second scan)

Your eo-portfolio repository's top-level README is the single most important page. Give it one short paragraph per project, each with a hero figure and links to the write-up and, where relevant, the live demo. Lead each with the outcome, not the method. Pin the four project repositories (or sections) so they are the first thing seen. A reviewer should understand what you can do without scrolling or cloning.

Lesson 2: The resume (outcomes and the grep list)

Rewrite the resume to lead with results and numbers, because quantified outcomes are what get read: for example, "mapped 1.2 million hectares of burned area at 91 percent area-weighted accuracy, 40 square kilometers per minute inference on one GPU," or "cut labeling need tenfold by fine-tuning a geospatial foundation model." Then include the stack recruiters literally search for (Python, rasterio, xarray, GeoPandas, STAC, PyTorch, TorchGeo, Sentinel-1 and 2, GEE, Docker, AWS, Prefect). Keep it to one page and tailor the top third to each role.

Lesson 3: Technical interview bank

Work the question bank threaded through this course out loud until the answers are natural. Record yourself explaining SAR geometry and the dNBR physics in under two minutes each, because fluency on the fundamentals is what interviewers probe first. Cover: surface versus TOA reflectance and the Sentinel-2 offset; why NBR falls after fire; random versus spatial cross-validation and which to report; C-band versus L-band and what NISAR changes; reading a window from a COG on object storage; ascending versus descending orbits; coherence in three sentences; and when a foundation model beats a U-Net.

Lesson 4: ML system design

Expect open prompts like "design a global deforestation alert system" or "design near-real-time burned-area mapping for a utility." Use a repeatable frame: clarify the requirement and latency budget, lay out data sources and their cadence, sketch the pipeline (ingest, detect, analyze, serve), state the model and how you validate it honestly, then address cost, failure modes, and fallbacks (for example Sentinel-1 when optical is cloudy). Your firewatch service is a concrete reference you can draw from live.

Lesson 5: Live coding

Practice the geospatial exercises interviewers actually give: read a 512 by 512 window from a COG without downloading it, reproject a raster, compute zonal statistics over polygons, and build a small xarray pipeline. Add a handful of array and graph problems for the general coding round. Practice narrating your thinking out loud, which is half of what is being assessed.

Lesson 6: The application campaign

Build a target list and work it deliberately: for each company, find two contacts, and apply to specific roles with a tailored note referencing a particular product of theirs and the one portfolio piece most relevant to it. Set a weekly application cadence and track everything (company, role, contact, date, status) in a sheet. Subscribe to the geospatial job boards (the Geospatial Jobs newsletter and the Pangeo jobs board) and keep the cadence for the month after the course.

Guided work (about 6 hours): polish and launch

Step 1: A portfolio-readiness check

Before you apply, verify the portfolio is complete with a small self-check you can rerun:

"""portfolio.py: portfolio readiness check (testable)."""
from __future__ import annotations

REQUIRED = {"projects": 4, "writeups": 3, "deployed": 1}

def portfolio_gaps(manifest):
    """Return the list of missing pieces; empty means ready to apply."""
    gaps = []
    if len(manifest.get("projects", [])) < REQUIRED["projects"]:
        gaps.append("projects")
    if len(manifest.get("writeups", [])) < REQUIRED["writeups"]:
        gaps.append("writeups")
    if not manifest.get("deployed_url"):
        gaps.append("deployed")
    return gaps

def resume_bullet(action, metric, tool):
    """Format an outcome-first resume bullet."""
    return f"{action} ({metric}) using {tool}."

# tests/test_portfolio.py
from eo_portfolio.portfolio import portfolio_gaps, resume_bullet

def test_complete_portfolio_has_no_gaps():
    m = {"projects": [1, 2, 3, 4], "writeups": [1, 2, 3], "deployed_url": "https://demo"}
    assert portfolio_gaps(m) == []

def test_incomplete_portfolio_lists_gaps():
    m = {"projects": [1, 2], "writeups": [1], "deployed_url": ""}
    assert set(portfolio_gaps(m)) == {"projects", "writeups", "deployed"}

def test_resume_bullet_is_outcome_first():
    b = resume_bullet("Mapped 1.2 Mha burned area", "91% area-weighted accuracy", "HLS + U-Net")
    assert b.startswith("Mapped") and "91%" in b

Step 2: Polish

Write the portfolio README (one paragraph and a hero figure per project, links to the three write-ups and the live map), rewrite the resume with outcome-first bullets and the grep list, and update your LinkedIn headline, posting the three write-ups.

Step 3: Prep

Run the interview bank out loud and record the two-minute explainers. Whiteboard the two system-design prompts end to end. Do the live-coding exercises against a real COG and AOI.

Step 4: Apply and commit

Send the first batch of tailored applications, log them in your tracker, and set the weekly cadence. Commit portfolio.py, its tests, and the finished README.

git add src/eo_portfolio/portfolio.py tests/test_portfolio.py README.md
git commit -m "Module 12: portfolio readiness check, polished README, resume"
git push

Capstone reference

The competency bar (what "professional" means here). Explain SAR normalization, speckle, and geometry without notes; go from STAC query to analysis-ready cube in a few lines for any provider; design a spatial cross-validation scheme and report area with confidence intervals; train and honestly compare a U-Net and a foundation model with a cost analysis; fuse lidar with imagery into a height or biomass map with uncertainty; implement a probabilistic SAR change detector; ship a containerized, scheduled pipeline with tests, CI, storage, and a tile server; and write a results note a non-specialist can act on.

Target companies (verify current openings). Wildfire: Overstory, Pano AI, Earth Fire Alliance and Muon Space, Vibrant Planet, Technosylva, and utility wildfire teams. Forestry and carbon: Pachama, Sylvera, Chloris, CTrees, Planet, Kayrros, Space Intelligence. SAR: ICEYE, Capella, Umbra, EarthDaily, NASA JPL (OPERA and NISAR), ASF, DLR. Platforms: Google (Earth Engine and AlphaEarth), Microsoft Planetary Computer, Development Seed, Element 84, Floodbase.

Interview question bank. Why does a burned forest darken in VH but sometimes brighten in VV, and what changes on steep terrain? A dNBR map shows severe burn in a lake: walk through the failure. Random-split accuracy is 94 percent, spatial-block is 81 percent: which do you report and why? When is C-band better than L-band, and what does NISAR change? How do you estimate uncertainty on a biomass map for an audit? Design a near-real-time burned-area service with a latency budget and cloud fallbacks. A foundation-model fine-tune underperforms your U-Net: five likely reasons. How do you read one window from a COG on object storage? How do you handle ascending versus descending orbits in a time series? Explain coherence to a product manager in three sentences.

Core reading shelf. Moreira and colleagues, A Tutorial on SAR. The SERVIR and NASA SAR Handbook. Chuvieco or Richards for optical fundamentals. Rey, Arribas-Bel, and Wolf, Geographic Data Science with Python. Olofsson and colleagues (2014) on accuracy and area. Camps-Valls and colleagues, Deep Learning for the Earth Sciences. The Prithvi, Clay, TerraMind, and TorchGeo papers.

Deliverable

A polished public eo-portfolio (README selling four projects, three linked write-ups, a live demo map), an outcome-first one-page resume, an updated LinkedIn, recorded two-minute technical explainers, two whiteboarded system designs, and at least the first batch of tailored applications sent and tracked, with a weekly cadence set. A tested portfolio.py confirms readiness.

What a hiring manager sees

At this point the work speaks, and this module makes sure it is heard. A portfolio that is scannable in 90 seconds, a resume that leads with quantified outcomes and the right stack, fluent answers on SAR and validation, and a deployed demo together present someone who is already doing the job. That is the candidate who gets the interview and, having practiced the bank and the system designs, converts it.

Currency note

This module is career-focused and not tied to specific datasets or missions, so it needs little version checking. Do, however, verify the target-company list and their open roles at application time, since companies, teams, and hiring change; confirm the job boards are still active; and keep the portfolio's currency notes honest by re-checking any mission or model claims you cite in write-ups before an interview. Pin any code dependencies in your Module 0.1 environment file.

Previous11 MLOps and Cloud Deployment