My Travel Planning Algorithm

As a full-time software engineer for almost 10 years, I’m used to solving problems using algorithms. After many years of traveling, I’ve streamlined my trip planning process by creating a framework to help me minimize risk and maximize reward. Here are the step-by-step instructions I follow to plan all my trips, with examples from my upcoming Kenya + Turkey trip and pseudocode for my fellow programmers:

1. Define Constraints

Every trip starts with constraints — they’re the input to the trip planning algorithm. For me, constraints usually fall into three buckets:

• Time: How much PTO do I have left? Are there long weekends or holidays I can extend?
• Budget: How much am I willing to spend? What other resources (like credit card points) are available to me?
• Preference: Chill or adventurous? Couple trip, friends trip, or family trip?

For example, for my Kenya + Turkey trip this year, the constraints from my husband and me were a 1-2 week trip in September (leveraging Labor Day) to somewhere adventurous that we haven’t been before.

inputs = {
    "time": "1-2 weeks in September",
    "budget": "cash + Chase points",
    "preferences": "adventure with husband to new country"
}

2. Generate Candidate Destinations

Once the input is decided, it’s time to generate some candidate destinations. I keep a running list of destinations I want to go next, so I simply iterate through them and filter based on the constraints.

Filter Criteria:

• Time: Is it the right season or safe to go? Is it realistic within the available time?
• Budget: Do I have enough resources to spend?
• Preference: Does it match what I’m looking for?

For example, September is hurricane season in certain areas of the Caribbean, monsoon season in parts of Southeast Asia, and scorching hot in some Middle Eastern countries. This already filters out a big portion of possible destinations. The focus on adventure narrowed the countries down further to Kenya, Tanzania, Jordan, Turkey, and Uzbekistan.

candidates = []
filters = [good_time, within_budget, matches_preference]
for destination in bucket_list:
    passes_filter = True
    for f in filters:
        if not f(destination, inputs):
	    passes_filter = False
            break
    if passes_filter:
        candidates.append(destination)

3. Score, Rank and Choose Destination

Once I have several candidate destinations, I dive deeper into each and pick one based on how they score in the categories I care about. Categories that are more important get higher weights.

Ranking Criteria:

• How interesting are the attractions?
• What are the logistics like?
• How much would it cost?
• What are the risks?

For example, of my September trip candidates, Turkey was the easiest to get to. It’s also a popular layover option for the other destinations, so we decided to pair Turkey with another country. Seeing animals seemed more fun than looking at historical sights, narrowing it down to Tanzania vs. Kenya. Ultimately, we selected Kenya because it scored better on cost and safety, even though Tanzania might have scored slightly higher on the safari experience itself.

scores = {}
weights = {
    "attractions": 0.4,
    "logistics": 0.2,
    "cost": 0.2,
    "risk": 0.2
}

for candidate in candidates:
    scores[candidate] = 0
    for feature, weight in weights.items():
        scores[candidate] += evaluate_feature(candidate, feature) * weight
          
destination = max(scores, key=scores.get)

4. Create and Optimize Itinerary

With a destination picked, it’s time to create and optimize the itinerary based on reward functions.

Reward Function Inputs:

• Do I care more about comfort or cost?
• Do I want to take it slow or see as much as possible?
• Do I want to explore myself or go with a guide?

For example, I value time and comfort over money, so we paid extra for business flights to Kenya given the long, red-eye flights. For hotels, I optimized based on the best deal, location, and ratings. I used my Chase Sapphire Reserve Card to book a Hyatt using point transfer and another hotel directly with points on the Travel Portal. As for the attractions, I pick the best rated ones on Tripadvisor that seem most interesting to me. Of those, I will see if there are any good tours on Viator since I like having a local guide.

flight = optimize(flights, prioritize=["comfort", "time"])
hotel = optimize(hotels, prioritize=["value", "location", "ratings"])

itinerary_attractions = top_k(attractions, rank_by=["ratings", "interest"])
booked_tours = top_k(tours_for_attractions, rank_by=["ratings", "cost"])

5. Add Fault Tolerance

In distributed systems, things fail. Travel is no different, so to minimize the risk and impact of a failure, you have to build in fault tolerance.

Resiliency Strategies:

• Add buffer time to account for delays
• Book popular attractions in advance in case they sell out
• Avoid the last flight of the day in case of cancellation

For example, given the long flight times and layover involved to get to Kenya, we added a buffer day before the Masai Mara safari in case something goes wrong with the flights, and to adjust to the time difference. We also booked the safari well in advance because spots can sell out a year ahead of time.

if flight.duration_hours > 10 and flight.layovers >= 1:
    itinerary.add_buffer_days(1)

for attraction in itinerary_attractions:
    if attraction.is_popular:
        attraction.book_in_advance()

6. Execute and Return

With a fault-tolerant itinerary in place, I can simply follow the plan, enjoy the trip, and return home with unforgettable memories.

execute(itinerary)
return unforgettable_memories