Planning a Community Garden

Overview

The community garden will convert an underused corner lot into a welcoming shared growing space for neighbors, families, and local volunteers. The plan focuses on a first season that is simple enough to maintain, visible enough to attract help, and flexible enough to improve after the first harvest.

The garden will start with eight raised beds, a small herb and pollinator strip, a compost station, a rain barrel, and a central path wide enough for wheelbarrows and strollers. The first season should prioritize reliable crops, clear routines, and neighbor participation over maximum yield.

Key planning assumptions:

• The growing season runs from April through October.
• Volunteers can cover two short watering shifts per day during hot months.
• The lot receives at least 6 hours of sun in the main bed area.
• The first year favors durable, low-maintenance crops such as lettuce, beans, tomatoes, peppers, herbs, and marigolds.
• Shared harvest rules will be posted on site and repeated in volunteer onboarding.

Goals & Success Criteria

The main goal is to create a safe, productive, and welcoming garden that people enjoy visiting. The garden should grow food, but it should also build neighborhood habits: checking in, watering, harvesting, composting, and sharing practical knowledge.

Success criteria for the first season:

• Install all raised beds, paths, signs, compost bins, and water storage by the end of April.
• Recruit at least 20 volunteers, with 8 regular weekly helpers.
• Hold 3 open community days: spring setup, midsummer maintenance, and fall cleanup.
• Harvest at least 250 pounds of produce for volunteers and neighbors.
• Keep all paths clear, tools stored safely, and beds free of standing water.
• Record planting, watering, harvest, and issue notes in a shared log.

The project should also leave behind reusable assets for the second season: a labeled bed map, a crop rotation note, a seed inventory, a lessons-learned list, and a volunteer contact list.

Site Selection

The preferred site is a flat, visible lot near the community center. Visibility matters because casual foot traffic helps volunteers notice problems early and encourages neighbors to stop by. The site should have enough sunlight for fruiting crops, but also a shaded rest corner for volunteers during summer workdays.

Site checks before committing:

• Confirm permission from the landowner or neighborhood association in writing.
• Check for water access within 30 meters, or confirm rain barrel refilling logistics.
• Walk the lot after heavy rain to identify puddling and runoff patterns.
• Confirm there is no recent use that could have contaminated soil.
• Choose bed locations that keep the main path clear and avoid blocking sight lines.
• Leave a small staging area for mulch, compost, and tool delivery.

If soil quality is uncertain, the first year should use raised beds with imported garden soil and a weed barrier below the paths. Native soil can be tested before any in-ground planting is considered.

Garden Layout

The layout uses a simple grid so new volunteers can understand it without training. Eight raised beds sit in two rows with a central path between them. The herb and pollinator strip sits along the front edge where visitors can see flowers, bees, and signage without walking through production beds.

Layout choices:

• Raised beds are 1.2 m by 2.4 m so most adults can reach the center from either side.
• The central path is 1.2 m wide for wheelbarrows and accessible passing space.
• Compost sits downwind from the seating corner and away from the entry sign.
• The rain barrel sits near the water access point to reduce hose length.
• Bed labels use large numbers and crop names for quick orientation.
• The layout sketch should be rendered from garden-layout.svg.

Bed allocation for the first season

How the garden fits together

The beds share one entrance, a single water spigot, and a lockable tool box, and everything feeds the compost and storage corner at the end of the season. The diagram groups the space into zones so reviewers can comment on the flow between them.

flowchart TB
    subgraph Shared[Entrance and shared area]
      Gate([Main gate])
      Board[Notice board and sign-out sheet]
      Box[Lockable tool box]
      Tap((Water spigot))
    end
    subgraph Cool[Cool-season beds]
      B1[Bed 1: greens]
      B2[Bed 2: peas then beans]
      B5[Bed 5: carrots and beets]
      B7[Bed 7: kale and chard]
    end
    subgraph Warm[Warm-season beds]
      B3[Bed 3: tomatoes]
      B4[Bed 4: peppers]
      B6[Bed 6: zucchini]
      B8[Bed 8: community choice]
    end
    subgraph Recycle[Compost and storage]
      C1[Three-bin compost]
      C2[Mulch and soil pile]
    end
    Gate --> Board
    Board --> Box
    Box --> Cool
    Box --> Warm
    Tap --> Cool
    Tap --> Warm
    Cool --> Recycle
    Warm --> Recycle

Planting Schedule

The planting schedule staggers work so volunteers are not asked to plant everything on one weekend. Cool-season crops start first, warm-season crops wait until frost risk has passed, and fall crops begin while summer plants are still producing.

Weather should guide final planting dates. The KQL query below gives an example of checking historical severe-weather timing for a selected state before setting the public planting calendar.

let gardenState = "ILLINOIS";
StormEvents
| where State == gardenState
| where EventType in ("Frost/Freeze", "Hail", "Thunderstorm Wind", "Heavy Rain", "Flood")
| summarize Events = count(), PropertyDamageUsd = sum(DamageProperty)
    by Month = startofmonth(StartTime), EventType
| order by Month asc, Events desc

This query summarizes historical frost, hail, wind, heavy rain, and flood events by month for Illinois so the garden team can choose safer planting and volunteer work windows.

A small helper the volunteers use to size each week of watering:

# Estimate weekly watering liters for one raised bed.
def weekly_liters(bed_area_m2, weekly_rain_mm):
    target_mm = 25  # soil moisture goal per week
    deficit = max(target_mm - weekly_rain_mm, 0)
    return round(bed_area_m2 * deficit, 1)  # 1 mm over 1 m2 == 1 liter

The same logic in C#, also highlighted at author time:

// Assign volunteers to garden beds fairly, newest members first.
public IReadOnlyList<Assignment> AssignBeds(IEnumerable<Volunteer> volunteers, int bedCount)
{
    var ordered = volunteers.OrderByDescending(v => v.JoinedOn).ToList();
    var result = new List<Assignment>();
    for (int i = 0; i < ordered.Count; i++)
    {
        int bed = (i % bedCount) + 1;   // round-robin across beds
        result.Add(new Assignment(ordered[i].Name, bed));
    }
    return result;
}

The volunteer handbook page the team edits each season, quoted as Markdown so headings, emphasis, links, task items, and the table read at a glance:

# Watering week (volunteer handbook)

Post this to the shed door every **Monday**; see the [rainfall log](https://example.org/rain).

1. Read the rain gauge and write the total in `mm`.
2. Run the helper above; round *up* to the nearest liter.
- [x] Beds 1-6 - morning shift
- [ ] Beds 7-12 - evening shift

> Skip a bed entirely when the gauge shows 12 mm or more.

| Bed | Crop | Liters |
| --- | --- | ---: |
| 1 | Tomatoes | 42 |
| 7 | ~~Squash~~ Beans | 31 |

<!-- Reviewers: is the evening shift still realistic in August? -->

Budget

The first-year budget keeps permanent infrastructure modest and spends where durability matters: raised bed lumber, quality soil, clear signage, and safe tool storage. Seeds and seedlings are intentionally varied so the garden can test what grows well before buying larger quantities next year.

Possible funding sources include small neighborhood grants, local hardware store donations, seed library contributions, and a spring plant sale. The project should avoid taking on donated materials that are unsafe, rotten, pressure-treated with unknown chemicals, or too irregular for volunteers to install safely.

Timeline & Milestones

The timeline starts with permission and volunteer recruitment, then moves through build-out, planting, harvest, and winter closeout. Each milestone should have one named coordinator and a backup so the garden does not stall if one person is unavailable.

The Mermaid gantt diagram mirrors these dates and makes the schedule easier to review visually.

gantt
    title Community Garden 2026 Timeline
    dateFormat  YYYY-MM-DD
    axisFormat  %b %d
    section Preparation
    Confirm site permission      :done, perm, 2026-02-01, 14d
    Recruit core volunteers      :active, vols, 2026-02-15, 14d
    Order materials              :order, 2026-03-01, 10d
    section Build
    Build beds and paths         :beds, 2026-04-01, 7d
    Install signs and water      :signs, 2026-04-08, 5d
    section Growing Season
    Plant cool-season crops      :cool, 2026-04-13, 10d
    Plant warm-season crops      :warm, 2026-05-18, 10d
    Midsummer workday            :milestone, mid, 2026-07-11, 1d
    Start fall planting          :fall, 2026-08-08, 10d
    section Closeout
    Fall cleanup and review      :close, 2026-10-24, 7d

Risks & Mitigations

The biggest risks are predictable: weather swings, inconsistent watering, unclear ownership, pests, and volunteer fatigue. The plan reduces those risks with simple routines rather than complicated policies.

The garden should also maintain a friendly escalation path. If a problem affects safety, water access, or site permission, volunteers should contact the garden committee before improvising a fix.

Planting decision flow

flowchart TD
    Start([Check garden conditions]) --> Soil{Soil temperature is at least 10 C?}
    Soil -- No --> WaitSoil[Wait and recheck in 3 days]
    Soil -- Yes --> Frost{Frost forecast in next 72 hours?}
    Frost -- Yes --> Protect[Delay planting or prepare row cover]
    Frost -- No --> Rain{Heavy rain forecast today?}
    Rain -- Yes --> WaitRain[Wait to avoid compacting wet soil]
    Rain -- No --> Calendar{Crop matches this planting window?}
    Calendar -- No --> UpdatePlan[Update planting calendar]
    Calendar -- Yes --> Plant[Plant today and record bed notes]
    Protect --> End([Review again tomorrow])
    WaitSoil --> End
    WaitRain --> End
    UpdatePlan --> End
    Plant --> End

Watering script change under review

The following unified diff shows a small change that adjusts watering estimates when rain has already reduced the need for manual watering.

--- a/watering_schedule.py
+++ b/watering_schedule.py
@@ -1,7 +1,11 @@
 def liters_per_bed(temp_c, beds):
     base = 8 if temp_c < 24 else 12
     return base * beds
 
-def watering_plan(temp_c, beds):
+def watering_plan(temp_c, beds, rainfall_mm=0):
     liters = liters_per_bed(temp_c, beds)
+    if rainfall_mm >= 8:
+        liters = 0
+    elif rainfall_mm > 0:
+        liters = max(0, liters - rainfall_mm * beds * 1.5)
     return round(liters)

Next Steps

The next step is to turn this plan into a one-page volunteer kickoff packet and a build-day checklist. The kickoff packet should explain the garden purpose, expected time commitment, basic safety rules, and how harvest sharing works.

Immediate actions:

1. Confirm permission and water access for the preferred lot.
2. Measure the site and compare it with garden-layout.svg.
3. Get two quotes for soil and mulch delivery.
4. Recruit the first 8 regular volunteers and assign coordinator roles.
5. Publish the first planting date only after reviewing frost and storm risk.
6. Prepare bed signs, harvest rules, and a simple weekly log sheet.
7. Schedule the spring build day and the midsummer maintenance day.

The plan should be reviewed after the first 6 weeks of growing. At that review, the group should compare the schedule, watering chart, volunteer coverage, and actual plant health, then adjust summer work routines before the hottest part of the season.