Recent Updates Toggle Comment Threads | Keyboard Shortcuts

  • Belen 4:41 am on April 29, 2026 Permalink  

    Set limits that enforce themselves 

    You need exactly 50 participants for your research study – 25 in each condition. You’re manually checking your dashboard every few hours to see how close you are.

    Or you’re running a beta test and want only the first 100 sign-ups. You’re hoping you remember to close the form before it hits 150.

    Or you have 20 coaching slots available this month. You’re tracking who booked what in a spreadsheet, trying to avoid double-booking.

    Here’s the thing: you shouldn’t have to manually track any of this.

    Read the full tutorial: Implementing Registration Quotas

    What If Your Program Just Knew When to Stop?

    Imagine setting your limit once – in your code – and never thinking about it again.

    • Your survey closes automatically when you hit 25 responses in each group
    • Your beta signup stops accepting new users at exactly 100
    • Your booking system shows “fully booked” when all 20 slots are taken

    No dashboards to check. No forms to manually close. No spreadsheets to update.

    The program handles it automatically.

    How Automatic Quotas Work

    The concept is straightforward:

    1. Track what’s happening: Save each registration, response, or booking to a database
    2. Count in real-time: Check how many you have whenever someone tries to join
    3. Enforce your limit: If you’ve reached capacity, stop accepting new entries

    Your program becomes self-regulating.

    Why This Changes How You Work

    Accurate capacity: You get exactly the numbers you planned for. Not approximate – exact.

    No manual monitoring: You don’t check dashboards or set reminders to close things.

    Fair allocation: First come, first served is truly enforced. No advantage to late registrations slipping through.

    Professional experience: Your systems work reliably. Participants trust that when they register, they’re confirmed.

    Better data: For research, you get the balanced samples you need without hunting for specific demographics.

    Traditional Vs. Automatic Approach

    Traditional ApproachAutomatic Approach
    Check your dashboard multiple times a daySet your limit once in the code
    Manually close forms when you think you’re closeLet the program enforce it
    Hope nobody registered in the gap between checksFocus on other aspects of your work
    Deal with overflow or under-enrollmentTrust that the numbers will be exactly what you need
    Adjust and re-open if you didn’t get enough

    How to Build This

    We’ve created a complete tutorial that walks you through building a quota system using a workshop registration as an example.

    The same principles apply whether you’re managing:

    • Research study enrollment
    • Event capacity
    • Resource distribution
    • Time slot booking
    • Survey quotas
    • Beta access
    • Membership limits

    You’ll learn:

    • How to set up a database to track registrations
    • How to count entries in real-time
    • How to check quotas before accepting new entries
    • How to secure the system against bypassing

    Read the full tutorial: Implementing Registration Quotas

    The tutorial uses a workshop as the example, but once you understand the pattern, you can apply it to any quota scenario.

    What You’ll Build

    By following the tutorial, you’ll create a system that:

    • Automatically tracks how many people have registered
    • Checks the count before showing your form
    • Closes at exactly your specified limit
    • Prevents bypassing through server-side enforcement

    Then you can adapt it for your specific needs – whether that’s research quotas, booking limits, or resource allocation.

    Real-World Examples

    Research Study Quotas

    You’re running a psychology study that needs exactly 100 participants: 50 men and 50 women.

    Instead of manually tracking gender balance:

    • The program counts how many men and women have completed it
    • When you hit 50 men, it only accepts women
    • When you hit 50 women, it only accepts men
    • At 100 total (50/50), it closes completely

    You set the quotas once. The program enforces them automatically.

    Workshop Registration

    You’re hosting a design workshop. The capacity is 30 people.

    Person #30 registers and gets their confirmation email.

    Person #31 clicks your link a minute later. Instead of the registration form, they see: “Registration is now closed. We’ve reached capacity.”

    No oversubscription. No awkward “sorry, we’re full” emails.

    Limited Resource Allocation

    You have 100 beta access codes to distribute. You want to give them to the first 100 people who complete your interest form.

    The program:

    • Counts how many codes have been distributed
    • Shows the form while codes remain
    • Displays “all codes have been claimed” once you hit 100

    First come, first served – enforced automatically.

    Time Slot Booking

    You offer 20 coaching sessions per month. Each person can book one slot.

    Your program:

    • Tracks available slots
    • Shows remaining openings
    • Marks slots as taken when someone books
    • Shows “fully booked” when all 20 are claimed

    No double-booking possible.

    Survey Response Quotas

    You need responses from 30 teachers, 30 parents, and 30 students for balanced data.

    Your program:

    • Asks their role upfront
    • Counts responses per group
    • Accepts responses from groups that haven’t hit 30 yet
    • Shows “we’ve reached our quota for [role]” when a group is full
    • Closes completely when all three groups are full

    You get perfectly balanced data without manually monitoring.

    Read the full tutorial: Implementing Registration Quotas

     
  • Belen 4:58 pm on November 19, 2025 Permalink  

    Start users exactly where they need to be 

    Suppose you’ve built a comprehensive training program with GuidedTrack. Some people need to start with the basics. Others already know the fundamentals and want to jump straight to advanced topics.

    Most platforms would drop everyone at  the same starting point, forcing advanced users to click through beginner content they don’t need. If you wanted to avoid this, you’d have to build entirely separate programs for different skill levels.

    GuidedTrack has a simpler solution: custom links that start people at different points in the same program.

    How It Works: Labels + URL Parameters

    Add a *label anywhere in your program, then share a link with that label at the end. Users clicking that link will start at that exact spot instead of the beginning.

    Here’s the format:

    https://www.guidedtrack.com/programs/programID/run#your_label_name

    Real Example: Sourdough Bread Baking Program

    Let’s say you’re teaching sourdough bread baking – that centuries-old craft that somehow became the internet’s favorite quarantine hobby and never really went away.

    You’ve built a comprehensive baking program that covers everything from creating your first starter to mastering artisan techniques. Your program looks something like this:

    Welcome to Sourdough Mastery!
    
    Let's start with the fundamentals...
    
    *label: starter_basics
    Creating and maintaining your starter…
    (the rest of your content would go here)
    
    *label: first_loaf  
    Baking your very first sourdough loaf…
    (the rest of your content would go here)
    
    *label: troubleshooting
    Why is my bread dense? Common problems solved…
    (the rest of your content would go here)
    
    *label: advanced_techniques
    Now let's get into the artisan stuff!
    (the rest of your content would go here)
    
    Professional scoring patterns...
    Multi-day cold fermentation...
    Advanced shaping techniques...
    Experimenting with ancient grains...

    The Problem You Need to Solve

    You know that some of your users already have a thriving starter bubbling away on their counter. They’ve baked dozens of loaves. They don’t need lessons on “what is a starter” or “your first basic loaf.” Making them click through all the beginner content is frustrating and wastes their time.

    But you also don’t want to maintain two separate programs – one for beginners and one for experienced bakers. Every time you update a recipe or technique, you’d have to update it in both places.

    The Solution: Different Links for Different Users

    You add the *label: advanced_techniques right before your artisan content begins.

    Now you can share two different links:

    For beginners (standard link), they start at the very beginning and learn everything from scratch:

    https://www.guidedtrack.com/programs/sourdough101/run

    For experienced bakers (link with label), they skip all the basics and land directly at the advanced techniques section:

    https://www.guidedtrack.com/programs/sourdough101/run#advanced_techniques

    What This Looks Like in Practice

    You’re running an online baking workshop. When people register, they indicate their experience level:

    • Never baked bread before: Send them the standard link. They need to create a starter, understand fermentation basics, and bake their first simple loaf.
    • Been baking for a year: Send them the #advanced_techniques link. They already know how to maintain a starter and bake a basic loaf. They want to learn professional scoring and cold fermentation.
    • Just struggling with dense loaves: Send them the #troubleshooting link. They can focus on solving that specific problem.

    One program. Multiple entry points. Everyone gets exactly what they need.

    The Marketing Benefit

    This also works great for targeted campaigns:

    • Facebook ad to cooking beginners: “Start your sourdough journey” → standard link
    • Email to past workshop attendees: “Master artisan techniques” → #advanced_techniques link
    • Partnership with baking supply stores: “Take your loaves to the next level” → #advanced_techniques link

    Each audience sees messaging that speaks to them and lands in the right place.

    Why This Matters

    • Better user experience: Advanced users don’t waste time on content they already know. Everyone starts where they should.
    • One program to maintain: Update your content once, and all entry points automatically stay current. No syncing multiple versions.
    • Flexible marketing: Send different links to different audience segments. Same program, customized entry points.

    Important Note: Labels Must Be in Your Main Program

    This only works for labels in your starting program. If you’ve linked to other programs using *program, labels inside those linked programs won’t work with this URL trick.

    The label needs to be in the main program that people are entering.

    How to Use This Feature

    1. Add *label: descriptive_name where you want an entry point
    2. Share programID/run#descriptive_name with that audience

    That’s it: They land exactly at that label.

    Bonus tip: Use clear, descriptive label names. #advanced_techniques is much better than #section4 when you’re managing multiple entry points.

    When to Use This

    This feature works great for:

    • Training programs with beginner and advanced paths
    • Educational courses where some users have prerequisites
    • Product demos tailored to different user roles
    • Research studies with different experimental conditions
    • Any program where different audiences need different starting points
     
  • Belen 8:12 am on November 4, 2025 Permalink  

    Schedule things for “next Friday” automatically 

    Imagine you’ve got a new user who just signed up on a Tuesday. You want to check in with them on Friday to see how their first week went.

    In most systems, there would be no way to do this, or, if there were, you’d have to calculate: “Today is the 15th, so Friday would be the 18th, which is 3 days from now…”

    And if they sign up on Saturday? Now you need different logic. What if it’s already Friday afternoon?

    There’s a simpler way: just tell GuidedTrack “schedule this for Friday” and let it figure out the dates.

    Schedule based on weekdays, not dates

    GuidedTrack lets you create dates based on specific weekdays:

    >> fridayThisWeek = calendar::date({"weekday" -> "Friday"})

    This finds the Friday of the current week. Simple enough. You can now use this like any other date, like for example feeding it into an email’s *when keyword to schedule an email to be delivered on Friday.

    When to use weekday-based scheduling

    This approach works great for:

    • Onboarding sequences where you want check-ins on specific days of the week
    • Weekly programs that should always start on Mondays (or any day)
    • Habit trackers that align with people’s weekly routines
    • Study schedules with sessions on specific weekdays
    • Team coordination where everyone gets reminders on the same days

    The catch: “Friday this week” might be in the past

    If someone signs up on Saturday, “Friday this week” already happened. You need to make sure you’re scheduling for an upcoming Friday:

    >> fridayThisWeek = calendar::date({"weekday" -> "Friday"})
    
    *if: fridayThisWeek < calendar::date
    	>> upcomingFriday = fridayThisWeek + 7.days
    *if: fridayThisWeek >= calendar::date
    	>> upcomingFriday = fridayThisWeek

    Now upcomingFriday is always a date in the future, no matter what day someone signs up.

    One important quirk: weeks start on Sunday

    Computer weeks start on Sunday, not Monday. This means:

    • “Sunday this week” is either today (if it’s Sunday) or already passed
    • If you want “the upcoming Sunday,” you almost always need to add 7 days when running the check on Sunday itself

    This is just how date systems work. It’s a bit quirky, but once you know it, you can plan around it.

    Getting started

    Here is the basic pattern:

    >> targetDay = calendar::date({"weekday" -> "DayName"})
    
    *if: targetDay < calendar::date
    	>> upcomingDate = targetDay + 7.days
    *if: targetDay >= calendar::date
    	>> upcomingDate = targetDay
    

    Replace "DayName" with Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, or Sunday.

    The code is simpler. The logic is clearer. And it just works.

     
c
compose new post
j
next post/next comment
k
previous post/previous comment
r
reply
e
edit
o
show/hide comments
t
go to top
l
go to login
h
show/hide help
shift + esc
cancel