Workflow recipe

Send Google Forms job applications to Slack

Each application lands in the hiring channel for that role, engineering, design, sales, marketing. Recruiter mention, portfolio link inline, delivery log. The setup hiring teams use to compete in fast-moving markets.

Start free →

Per-role channel routing
Recruiter or subteam mention per channel
Portfolio links surfaced for one-tap review

TL;DR

The short answer

Capture role, location, years of experience, and portfolio link. Route by Role using contains so partial matches work — Role contains "Engineer" → #hiring-eng, Role contains "Design" → #hiring-design, etc. Each channel has its recruiter or hiring subteam mentioned in the template. Portfolio link in the message is clickable; reviewers open it in one tap.

The six fields a careers form needs

Minimal but routing-ready

Name: required. Identifies the candidate.
Email: required. Recruiter contact path.
Role applied for (dropdown of open roles), required. The primary routing signal. Keep role names consistent so contains-matching is reliable.
Location (Remote / specific cities), required. Useful for distributed teams routing to regional hiring channels.
Years of experience (number), required. Filters senior vs entry-level tracks if your team segments.
Portfolio / resume link (URL), required. Reviewers open this in one tap from the Slack message. Make the field type URL so Google Forms validates format.

Setup

Five steps to per-role dispatch

1
Build the application form with the six fields
Mark all six required. Set the confirmation message to acknowledge — 'We review every application within 5 business days' is a fair commitment for most hiring flows.
2
Create Slack webhooks per hiring channel
One per hiring team: #hiring-eng, #hiring-design, #hiring-sales, #hiring-marketing, plus a default #hiringfor roles that don't match a specific team.
3
Find each team's recruiter mention
For per-channel recruiter mentions, get either the user ID (<@U0123>) or the subteam ID (<!subteam^S0123|recruiters>). Subteam is the safer pattern, handles recruiter absences without missed applications.
4
Wire the form into RouteForms
Sign up, add the form, paste the default webhook, install the Apps Script.
5
Add the routing rules with contains-matching
Order matters. Role contains "Engineer" → #hiring-eng, Role contains "Design" → #hiring-design, Role contains "Sales" → #hiring-sales, Role contains "Marketing" → #hiring-marketing. Fallthrough goes to #hiring. The contains operator handles “Senior Engineer”, “Engineering Manager”, etc. without needing one rule per title.

What lands in the channel

The message shape recruiters can act on in seconds

:briefcase: *New application*
<!subteam^S0123|recruiters>
*Name:* Rahul Verma
*Role:* Senior Backend Engineer
*Location:* Remote (India)
*Years of experience:* 7
*Portfolio:* https://rahul.dev

Channel: #hiring-eng · Open candidate profile

The briefcase icon flags the message as hiring-related. The subteam mention handles recruiter absences. Portfolio surfaces as a URL the reviewer can open in one tap. The footer link points to a candidate profile in whatever ATS the team uses (Greenhouse, Lever, etc.), or a Notion page if hiring is still spreadsheet- driven.

The hiring pipeline

Where this fits next to your ATS

RouteForms: the alert layer. Application form → routing rule → hiring channel within seconds.
Slack: the triage layer. Recruiter scans the channel, opens the portfolio, shortlists or rejects.
ATS (Greenhouse / Lever / etc.): the system of record. Recruiter creates the candidate record from Slack and moves them through stages there.

For teams without a real ATS, the same Google Forms responses can sync to a Sheet for tracking. Google Forms' native integration. The Slack alert is the time-sensitive part; the Sheet/ATS becomes the long-term record.

FAQ

Frequently asked questions

What fields should a job application form capture?▾

Six core fields: Name, Email, Role applied for (dropdown of open roles), Location (Remote / specific cities), Years of experience (number), and Portfolio / resume link. For senior roles, add Current company and Notice period. Role is the primary routing signal, different hiring teams own different channels. Portfolio link should be clickable in the Slack message so reviewers can open it in one tap.

How do I route applications by role?▾

Rules on the Role field, using contains so partial matches work. 'IF Role contains "Engineer" → #hiring-eng' covers Senior Backend Engineer, Software Engineer, Engineering Manager. 'IF Role contains "Design" → #hiring-design' covers Product Designer, UX Designer. The contains operator is more forgiving than equals, small variations in role naming don't break routing.

Should I mention the recruiter or hiring manager?▾

Mention the recruiter for the role. The cleanest pattern: each role's hiring channel has a dedicated recruiter, mentioned via <@USER_ID> or <!subteam^GROUP_ID|alias>. For roles where applications need to be reviewed by a specific hiring manager (executive search, niche specialists), include the hiring manager's mention instead of (or alongside) the recruiter. Avoid @here in hiring channels, applications aren't urgent in the page-everyone sense.

How fast does the application reach the channel?▾

Within a couple of seconds. For high-volume roles (engineering at scale), the recruiter sees the application before the candidate finishes typing their thank-you note. That's the response-time advantage that matters in competitive hiring markets, candidates compare offers fast.

Can I auto-filter low-quality applications?▾

Partially. RouteForms's routing rules can pattern-match obvious cases: 'IF Years of experience = "0" AND Role contains "Senior" → #low-priority-applications' catches mismatched applicants. For real screening (resume parsing, skill assessment), you need a separate ATS layer or LLM-driven service. RouteForms is the routing layer, not the qualification engine.

Should the candidate see anything different based on where they're routed?▾

No, routing is invisible to the candidate. They see Google Forms's standard confirmation. Whether their application went to #hiring-eng or #hiring-design or #hiring-archive happens server-side. If you want differentiated candidate experiences (different confirmation messages per role), Google Forms doesn't natively support it, you'd need a separate landing page per role or a custom thank-you Apps Script.

How do I prevent applications from being missed if the recruiter is out?▾

Use a subteam mention rather than a single user mention. <!subteam^S0123|recruiters> pings the whole recruiting team; whoever's available picks up. For roles where one recruiter owns the relationship end-to-end, include both the subteam fallback and the primary recruiter, primary handles when present, subteam picks up the rest.

What happens with applications when the role closes?▾

RouteForms keeps posting until you change the routing, applications for a closed role land in the same channel. The cleanest pattern: update the routing rule to redirect closed-role applications to a #closed-roles archive channel with a context note. Or close the form itself; Google Forms supports response-collection toggle so you stop accepting new applications without breaking the URL for existing links.