Manage and prioritize requests, push them to GitHub, and notify via Slack
Every team faces different challenges when it comes to collecting feedback and incorporating it into the prioritization process. Let’s take a look at one of these challenges from the user's perspective.
User's goal:
🏎️ 💡 I need Ducalis to manage the data requests, prioritize them and create issues in Github for development and write back to Slack to update user requestors.
Getting Started: Automate Your Data Request Workflow with Ducalis
Welcome to Ducalis! 🎉 It sounds like you're facing the common challenge of managing incoming requests from your team—whether it's asking for support, new features, problem-solving, or project updates—and you need a better way to prioritize and track these requests.
You're in the right place! Ducalis is designed precisely for this: helping teams collect, prioritize, and act on requests organizationally. Let's walk through how to set up your automated workflow that will:
✅ Collect all requests and internal issues in one place
✅ Enable transparent prioritization so your team can see and understand what matters most
✅ Two-way sync between Ducalis and GitHub
✅ Send automated status updates to requestors and a complete changelog for stakeholders
We'll break it down into simple steps to show how easy Ducalis makes it!
Why does this workflow work so well
The problem you're probably facing is that requests come from everywhere—Slack DMs, emails, hallway conversations, and urgent meeting requests. You lose track of what's important, spend time on the wrong things, and people get frustrated when their requests disappear into the void.
The Ducalis solution: Instead of chaos, you get a clear pipeline where every request is visible, stakeholders can vote on what matters most, and the highest-priority items automatically flow into your development workflow.
The magic: Ducalis connects directly with GitHub and Slack, so everything happens automatically once you set it up. No more manual tracking, no more "whatever's loudest gets done first."
Step 1: Make It Easy for Stakeholders to Share Requests—Wherever They Are
Setting up your data request board
Navigate to the "Voting Board" section. Turn it on.
Check the privacy level—who can create new requests and what they can see.
Name something obvious, like "[Team Name] Requests," so people know exactly where to go.
Make it welcoming: Upload your team logo, choose color that match your company branding, use your company domain for voting board address, and email notification. Read more here.
Create a simple request template
Help people give you what you need by setting up a request template. Click "Voting" settings > "Idea Template" and create fields like:
What do you need?
Why is this important?
It's also good to tune up the voting scale:
How urgent is that?
Pro tip: Keep it short! People won't fill out a 10-field form but will happily complete 2-3 quick questions.
Collect Requests Where Your Team Already Works
Let people submit requests wherever it's easiest for them. The idea is to meet your team where they already work, whether Slack, email, or your internal tools, and have everything flow into Ducalis automatically.
Turn conversations into ideas with the Ducalis ↔ Slack integration
Use an email-inbox forwarding requests to the board,
Connect via API to push requests from any internal system,
Embed the board in the internal portal,
Pin the board link in your Slack channel for quick access.
This way, requests flow in naturally, and if someone lands on the board, you can use "Vote on Behalf" to help submit or update their request.
Step 2: Set up the non-biased prioritization flow
Choose your prioritization approach
Keep it simple to start.
Ducalis has kick-off templates: choose between RICE or WSJF, and start with what resonates more with your business needs. Try to prioritize a few items.
Modify the prioritization criteria to reflect your business needs.
For example, for data requests, you might want:
Business Impact: How much will this help the business?
Urgency: How soon do we need this?
Effort: How complex is this request?
Evaluation: solo or teamwork?
When it comes to prioritizing requests, you can do it solo if you already know what matters most or want to quickly set the order yourself, then share the results with your team.
But if you're unsure about a request—for example, whether it is needed for compliance reasons or how much time backend and frontend teams will need to complete it—it's best to invite others to help. Bringing in colleagues from different roles ensures you have the proper context and leads to more brilliant, more balanced prioritization.
For teamwork — Let different people vote on different things: Your business stakeholders are great at judging impact and urgency. You and your technical team know the effort and complexity.
Step 3: Connect to GitHub (2 minutes)
Don't just prioritize incoming requests—bring your internal backlog into the mix. With Ducalis, you can import internal tasks or tech debt and manage them alongside external requests, all in one place.
Once you connect GitHub, syncing is easy: internal issues that match your filters appear automatically, and you can push any Ducalis item straight to GitHub whenever you need. Learn how to connect GitHub.
That will let you get into the 'Evaluation' section, which includes both internal issues and stakeholders' requests.
Step 4: Sync up with Slack (5 minutes)
Connecting Slack is useful in multiple ways: it's a convenient source for capturing new requests right from conversations, it keeps you personally updated on new ideas and comments, and it can automatically share team-wide notifications with stakeholders—so everyone stays in the loop without extra effort.
Choose your channels: Set up team notifications for different audiences:
#data-team: All new requests and status updates,
#leadership: Only high-priority items that hit your GitHub threshold,
#general: Weekly summaries of what's been completed.
Configure notification types: Ducalis ↔ Slack integration can send updates when requests are submitted, when the request status is changed, and when work is completed.
Learn how to connect Slack for requests notifications and for team prioritization.
Step 5: Automate routine
Nobody likes working in a black box: Even with the best prioritization, people want to know their request was received and what's happening with it.
Status automation for voting boards
We recommend keeping the standard statuses when creating a new voting board:
Inbox — new requests land here. By default, weekly notifications about new requests are set up so you don't miss the review process
From Inbox, you need to move the idea somewhere: add it to the backlog for prioritization, postpone it, or merge it with an existing one
After accumulating enough priority points (total score), the idea automatically moves to the Prioritized or Top Priority column.
When you take a task to work (status issues — In Progress), the request card moves automatically.
And when the idea is ready, it moves to the Done column.
Push requests to GitHub
At any time from Ducalis, you can send ideas or Ducalis tasks to the connected task tracker. Simply click "New" → "In GitHub".
Make notifications useful
There are two types of notifications:
My Notifications — so you don't miss fresh requests and comments. Control status changes.
Useful notifications from this section:
Daily Digest for displaying general summary of work with requests
Comments new comments on voting board requests, if stakeholders want to clarify something about request statuses
Voting Ideas — fresh requests
Voting Inbox reminder — weekly reminder about unprocessed requests; it's important to keep the inbox empty
Evaluation Reminder — to receive messages about how many tasks remain to be evaluated
Questions — if you're evaluating tasks with the team and someone doesn't understand, you'll immediately know about the question
Team Notifications — settings for sharing priority work results with your team.
Useful notifications from this section:
Digest of ideas, what exactly is happening on the voting board.
Release Notes — detailed information about completed tasks.
In the release notes section, specify how often to make digests, configure which blocks to show "Done," "In progress," and others, and choose the period for automatic notifications.
Learn more "How to work with Release Notes".
Step 6: Launch and iterate
Start with your team
Begin with a soft launch: Use it for your own team first. Submit a few real requests, go through the voting process, decide what GitHub issues to create. Work out any kinks before rolling it out widely.
Train your early adopters: Pick a few people frequently making data requests and walk them through the process. They'll become your champions who help spread adoption.
Gather feedback and adjust
The beauty of Ducalis: Everything is configurable. If your priority thresholds are wrong, adjust them. If people aren't voting, simplify your criteria. If notifications are too noisy, fine-tune them.
If you need any specific automation tunings — submit a feature request to the Ducalis team.
This changes everything: Instead of you manually deciding what to work on, the team's collective wisdom automatically surfaces the most critical work.
Common questions from new users
"Will people actually use this instead of just messaging me?"
Yes, but it takes time. Start by directing people to the board when they make requests: "That's a great idea! Can you add it to our data requests board so we can prioritize it properly?" After a few weeks, it becomes habit.
"What if something is truly urgent?"
Keep a fast lane! You can always handle genuine emergencies directly, but you'll be amazed how few things are actually urgent when people have to think about priority in context of other work. You can create a special urgency criterion that will have high weight, for example, 100 points. But it's better to always describe the criterion more precisely, for example, regulatory requirement, or direct CEO request. It's important that colleagues understand what exactly got to the top priorities and at the expense of what.
"How do I handle requests that need clarification?"
Use Ducalis comments! When someone submits a vague request, comment with questions. This keeps the conversation attached to the request and helps everyone learn to be more specific.
"What about private or sensitive requests?"
Ducalis supports private boards and restricted voting. You can have public boards for general requests and private ones for sensitive work. Read about privacy settings here.
What success looks like
After a few weeks, you'll notice:
Fewer interruptions during your focused work time
Clearer understanding of what your stakeholders actually need
Better alignment between your work and business priorities
Automatic paper trail for all requests and decisions
Team members taking ownership of prioritization instead of everything being urgent
After a few months, you'll have:
Historical data showing your team's impact and productivity
Stakeholders who understand resource constraints and trade-offs
A backlog that actually reflects business priorities
Time to focus on high-value analysis instead of constant context switching
Getting help
Our Ducalis support is fantastic: If you get stuck, reach out to hello@ducalis.io or use the in-app chat.
Book a demo: calendly.com/ducalis_io/30min
Ducalis Feature Requests Board: https://feedback.ducalis.io/ducalis-roadmap
Get personalized setup help: The Ducalis team reviews user workflows and provides customized guidance. To get help setting up your specific workflow, register an account and in the final question "Briefly describe your goals and needs, and we'll send you tips on how to set up Ducalis:" describe your use case.
Ready to transform your data request chaos into an organized, strategic workflow? Your future self will thank you! 🚀
