Sync Basecamp to GitHub for Dev Teams: Two-Way Integration Guide (Issues & PR Updates)

Syncing Basecamp to GitHub means you connect project conversations and task ownership in Basecamp with developer execution signals in GitHub—so Issues, pull request (PR) updates, and status changes stay aligned without constant manual copy-pasting.

Next, you’ll learn how to choose the right integration approach—two-way sync versus one-way automation versus simple linking—so your team matches the setup to your workflow, risk tolerance, and the level of stakeholder visibility you need.

Then, you’ll follow a practical, tool-agnostic setup process to map Basecamp to-dos to GitHub Issues, route PR updates to the right place, and avoid common pitfalls like duplicate tasks, noisy notifications, and sync loops.

Introduce a new idea: once your integration is running, the real win comes from operational rules—source of truth, conflict handling, and troubleshooting habits—that keep Basecamp and GitHub synchronized even as the team scales.

What does “sync Basecamp to GitHub” mean for dev teams (and what gets synced)?

Syncing Basecamp to GitHub is a two-way integration approach that connects Basecamp work items and discussions with GitHub development artifacts—especially Issues and PR updates—so teams can track progress with fewer manual updates and fewer context switches.

Next, to better understand what “sync” really delivers, you need to clarify the objects involved and the difference between a “two-way sync” and a basic one-way automation.

A dev team typically uses Basecamp as the collaboration layer—where non-dev stakeholders ask questions, confirm scope, and approve changes—while GitHub is the execution layer—where developers open Issues, make commits, and move PRs through review and merge. The integration becomes valuable when it reduces the “status translation” work: the endless re-explaining of what’s happening in GitHub to people who live in Basecamp.

In practical terms, “sync” answers four core needs:

• Visibility: Non-dev stakeholders can see meaningful development updates inside Basecamp without learning GitHub navigation.
• Accountability: Tasks and ownership align—so a Basecamp to-do isn’t “done” while the GitHub Issue remains open.
• Continuity: Conversation stays attached to the work item—reducing lost context in chats, emails, or scattered comments.
• Speed: Less switching between tabs and tools lowers the cognitive cost of interruptions; research linked to UC Irvine’s work shows it can take over 20 minutes to fully resume focus after interruptions. (ics.uci.edu)

What are the most common Basecamp ↔ GitHub objects to connect (to-dos, issues, PR updates)?

There are 3 main types of objects to connect between Basecamp and GitHub: Basecamp to-dos, GitHub Issues, and GitHub PR updates, based on how directly they represent “work” versus “work progress.”

Then, once you see these types clearly, you can decide what to sync first so you get value quickly without overbuilding.

1) Basecamp to-dos (Basecamp) → Work commitments

Basecamp to-dos are the planning-side promise: “We will do this.” They work well for cross-functional accountability because they are easy to assign, easy to discuss, and easy to tie to milestones.

Common Basecamp to-do fields you’ll care about in an integration:

• Title / short summary
• Notes / description
• Assignee(s)
• Due date
• Status (done / not done)
• Tags or categories (if used)
• Comments (context and decisions)

2) GitHub Issues (GitHub) → Work execution units

GitHub Issues are the development-side unit: “This is the dev task.” Issues often carry technical detail that stakeholders don’t need, but they also carry decisive signals that stakeholders do need: open/closed status, labels, milestones, and who owns the next move.

Common GitHub Issue fields that matter for syncing:

• Title and body
• Assignee(s)
• Labels (bug, enhancement, priority)
• Milestone
• Status (open/closed)
• Comments and references (links to commits/PRs)

3) PR updates (GitHub) → Progress signals

PR updates are often the most valuable visibility layer because they tell you whether work is real progress: opened, reviewed, checks passing, approved, merged. Stakeholders do not need every event—but they do need the right signals.

High-signal PR updates include:

• PR opened (work is in review)
• Review requested / approved (work is close to merge)
• Checks failing (work is blocked)
• PR merged (work is delivered)

A practical rule: treat PR updates as status indicators, not “tasks.” This keeps Basecamp from becoming a noisy stream of GitHub events.

Is two-way sync always necessary, or is one-way automation enough?

No, two-way sync is not always necessary for Basecamp to GitHub; one-way automation is often enough when you want predictable reporting, lower risk of sync loops, and simple routing of updates.

However, when both Basecamp and GitHub are “sources of truth” for different parts of the workflow, two-way sync becomes the safest way to keep status aligned without constant manual reconciliation.

Here are 3 reasons one-way automation is enough for many teams:

• Clear ownership lives in one system. If dev ownership lives in GitHub (Issues/PRs), and Basecamp is just for stakeholder visibility, then GitHub → Basecamp updates are sufficient.
• You want to reduce risk and complexity. Two-way sync introduces conflict rules and duplication risk. One-way automation is simpler to reason about and easier to debug.
• Your workflow is event-driven. If the key need is “when X happens in GitHub, tell Basecamp,” a one-way event pipeline solves it without status mapping back.

And here are 3 reasons two-way sync is worth it:

• Your team assigns and manages tasks in Basecamp. If PMs create and assign to-dos in Basecamp and expect them to become dev Issues automatically, you need Basecamp → GitHub mapping.
• Status must match on both sides. If stakeholders rely on Basecamp “done” status for release decisions, you want it to reflect GitHub issue/PR reality.
• You need shared accountability across roles. When devs and non-devs both update the same work item, two-way sync helps avoid “split-brain” tracking.

A good middle ground is common: two-way sync for task objects (to-dos ↔ issues) and one-way for progress signals (PR updates → Basecamp).

Which integration approach should you choose: two-way sync tool vs automation recipes vs simple linking?

Choosing an approach works best when you compare three options—two-way sync tools, automation recipes, and simple linking—because each wins under different criteria like reliability, governance, and stakeholder visibility.

Next, to make this decision quickly, you should evaluate your workflow using a small set of criteria rather than tool brand names.

Before you decide, define your “integration goal” in one sentence:

• “We need Basecamp tasks to become GitHub Issues and stay in sync.”
• “We only need GitHub updates to show up in Basecamp.”
• “We just need links so people can jump between systems.”

This table contains a practical comparison of the three approaches and helps you choose a direction based on common implementation criteria.

Approach	Best for	Main strengths	Main risks
Two-way sync tool	Shared ownership + status alignment	Bi-directional mapping, conflict rules, structured logging	Complexity, misconfiguration, permission scope
Automation recipes (one-way)	Event-driven updates + simple routing	Fast setup, predictable flows, low loop risk	Partial context, brittle multi-step logic
Simple linking/notifications	Low-change teams, strict governance	Minimal setup, minimal risk, clear boundaries	Manual status upkeep, weaker accountability

What are the pros/cons of two-way sync tools for Basecamp ↔ GitHub?

Two-way sync tools are best when you need Basecamp and GitHub to share the same “task truth,” because they support bi-directional updates, structured field mapping, and conflict handling that one-way automations cannot reliably cover.

However, because two-way sync touches both systems, it requires stricter decisions about ownership, permissions, and conflict rules.

Pros (why teams choose two-way sync):

• True bi-directional status alignment: Closing an Issue can mark a Basecamp to-do done, and vice versa (if configured).
• Stable mapping across many items: Once rules are set, the integration scales across projects or repos.
• Structured logs and traceability: You can see what changed, when, and why—critical for debugging.

Cons (what can go wrong):

• Conflict complexity: Two people update the same item in different systems at the same time.
• Loop risk: A change triggers an update which triggers another update, creating “ping-pong” events.
• Permission sprawl: Broad repository permissions can exceed least-privilege needs if not configured carefully.

A practical success rule: keep two-way sync limited to one object pair first (Basecamp to-dos ↔ GitHub Issues), then expand after stability.

When do automation recipes (trigger/action) work better than two-way sync?

Automation recipes work better than two-way sync when you want a narrow, predictable pipeline—like “new GitHub Issue creates a Basecamp to-do”—because one-way flows reduce conflict risk while still delivering visibility and faster coordination.

Then, once you get value from these simple recipes, you can decide if you truly need bi-directional edits.

Strong cases for one-way automation include:

• Bug intake: Issues labeled “bug” automatically create Basecamp to-dos in a “Bugs” list.
• Release updates: Merged PR posts a single Basecamp message in a release thread.
• Executive visibility: Critical alerts (e.g., failed checks) route to a small Basecamp group.

This is where the concept of Automation Integrations becomes useful: you treat integration as a set of small “if this, then that” automations rather than a single giant sync. You get faster adoption because each automation has a clear purpose and fewer surprises.

Can you connect Basecamp and GitHub without syncing (links/notifications only)?

Yes, you can connect Basecamp and GitHub without syncing by using links and controlled notifications, and this approach is often best when you prioritize governance, minimize data duplication, and maintain strict boundaries between planning and code execution.

However, because linking does not enforce status alignment, you must accept that someone still owns manual updating of task status.

This approach works when:

• Your team has a stable process and low volume of changes.
• You want Basecamp to stay “clean” and not mirror every dev artifact.
• You use Basecamp for decisions and GitHub for execution, and the bridge is “jump links.”

A simple linking pattern:

• Basecamp to-do includes a GitHub Issue link.
• GitHub Issue includes a Basecamp discussion link.
• PR description references the Issue and/or Basecamp thread.

The benefit is clarity: Basecamp remains the stakeholder narrative, GitHub remains the dev record, and the links connect them without trying to merge them.

How do you set up a reliable Basecamp ↔ GitHub sync (step-by-step)?

A reliable Basecamp ↔ GitHub sync is built by following 6 steps—define the use case, pick the sync direction, connect accounts securely, map objects and fields, apply filters, and test with a pilot—so the integration delivers accurate updates without noise or duplication.

Next, you’ll reduce risk by making the most important decisions before you click “enable,” because the “rules” you choose matter more than the platform you choose.

What should you decide before connecting (use case, direction, ownership, “source of truth”)?

Before connecting Basecamp to GitHub, you should decide your use case, sync direction, ownership rules, and source of truth because those decisions prevent conflict, clarify responsibility, and keep the integration stable as more people participate.

Then, once these decisions are explicit, every mapping choice becomes easier and more consistent.

• Use case statement: “We want Basecamp to-dos to sync to GitHub Issues and show PR progress in Basecamp.”
• Direction per object type: To-dos ↔ Issues (two-way or one-way); PR updates → Basecamp (one-way).
• Ownership rules: Who creates the canonical task and who closes it—PM in Basecamp or dev lead in GitHub?
• Source of truth decisions: Status truth, due date truth, and priority truth—define which system owns each field.

A practical pattern for dev teams:

• GitHub is the source of truth for dev status (open/closed, merged).
• Basecamp is the source of truth for stakeholder commitments (deadline promises, acceptance notes).

How do you map Basecamp to-dos to GitHub issues (fields, status, assignees, labels)?

Mapping Basecamp to-dos to GitHub Issues works best when you map 7 core fields—title, description, assignee, status, due date, tags/labels, and comments—because those fields define the task identity, ownership, and life cycle in both systems.

Specifically, once these mappings are consistent, you avoid duplicate work and minimize confusion about “what changed where.”

1) Title → Title

Keep titles short and action-based (verb + object). A good title survives in both systems.

2) Notes/Description → Issue body

Put stakeholder context in Basecamp notes; add technical acceptance criteria in Issue body. If you sync both, use a simple structure: problem statement, expected behavior, constraints/dependencies, and acceptance criteria.

3) Assignee → Assignee (with fallback)

Identity mapping is often imperfect because not every Basecamp user is a GitHub user. If no matching user exists, assign to a triage owner in GitHub and keep a clear owner in Basecamp for follow-up.

4) Status mapping (critical)

Pick one truth. A safer choice is GitHub status controls Basecamp “done”: Issue closed marks the Basecamp to-do done, and Issue reopened reopens it if your tooling supports that.

5) Due date ↔ Milestone (optional)

Basecamp due dates represent stakeholder commitments, while GitHub milestones represent release grouping or sprint windows. Align them only if your team already uses milestones consistently.

6) Tags ↔ Labels

Convert a small set of tags into labels (e.g., “bug” → bug, “urgent” → P1, “backend” → backend) to prevent label sprawl.

7) Comments / updates

Decide whether to sync comments. Many teams sync only decision-grade notes and keep technical debugging inside GitHub to protect Basecamp from noise.

A useful tactic: place a short linking stanza inside both systems—Basecamp to-do includes a GitHub Issue link, and the GitHub Issue includes a Basecamp discussion link—so humans can always jump to the right context.

How do you bring PR updates into Basecamp without overwhelming the team?

You bring PR updates into Basecamp without overwhelming the team by filtering to high-signal events, summarizing them into one update per meaningful milestone, and routing them only to the Basecamp project or thread that owns the stakeholder communication.

Next, you can keep Basecamp calm by treating PR events like “progress headlines,” not a live event feed.

• Filter by repository: Only the repos relevant to that Basecamp project.
• Filter by label or milestone: Only PRs tied to tracked work.
• Filter by event type: Keep only selected events (opened if needed, checks failing when blocking, merged as the main signal).

Use a summary format such as “PR merged: <title> (link)” or “PR blocked: checks failing (link),” and route updates into a single Basecamp thread per feature/release rather than broadcasting every PR event across general discussions.

GitHub’s reporting on PR activity at scale highlights why filtering is essential: raw event volume can be high, so teams need careful noise controls to protect attention. (github.blog)

What workflows should you automate first for the best ROI?

There are 4 high-ROI workflows to automate first for Basecamp ↔ GitHub: issue-to-to-do creation, status syncing, PR milestone updates, and exception alerts, based on the criterion of “reduces meetings and manual status translation the most.”

Then, after you automate these, you can expand into advanced routing and reporting without creating noise.

A simple ROI rule: automate workflows that eliminate repeated questions like “Is this done?” “What’s blocked?” “Is it merged yet?” These questions are not bad—they’re just expensive if asked dozens of times per week.

Which GitHub → Basecamp workflows are most useful (issues/PRs to to-dos/updates)?

There are 3 main types of GitHub → Basecamp workflows: intake workflows, progress workflows, and alert workflows, based on whether the event creates work, updates work, or escalates risk.

Next, you can pick one from each type so Basecamp gets the right information at the right time.

1) Intake workflows (create Basecamp items)

• New Issue with label “client-bug” → Create Basecamp to-do in “Client Bugs.”
• New Issue in repo “mobile-app” → Create Basecamp to-do in “Mobile Backlog.”
• New Issue assigned to “Team A” → Post update in Team A Basecamp project.

2) Progress workflows (update Basecamp items)

• Issue closed → Mark Basecamp to-do done.
• PR merged referencing Issue → Comment on Basecamp to-do: “Merged, ready for QA.”
• PR opened for Issue → Comment: “In review.”

3) Alert workflows (notify exceptions)

• PR checks failing on “release” milestone → Notify Basecamp “Release” thread.
• Issue labeled “blocked” → Create a Basecamp ping to the owner group.

A best practice: keep Basecamp updates human-readable and short, with links for detail, so Basecamp remains the narrative layer while GitHub remains the execution record.

Which Basecamp → GitHub workflows are most useful (to-dos to issues, comments to context)?

There are 3 main types of Basecamp → GitHub workflows: task creation workflows, escalation workflows, and clarification workflows, based on whether Basecamp creates new dev work, changes priority, or adds stakeholder context.

Then, by limiting Basecamp → GitHub flows to these types, you avoid flooding GitHub with tasks that aren’t truly engineering work.

1) Task creation workflows

• New Basecamp to-do tagged “dev” → Create GitHub Issue in the correct repo.
• New Basecamp to-do in list “Sprint” → Create Issue + add milestone “Sprint X.”
• New Basecamp to-do assigned to “Dev Lead” → Create Issue assigned to a triage owner.

2) Escalation workflows

• Basecamp comment contains “BLOCKER” → Add label “blocked” or “P0” to the Issue.
• Basecamp due date moved earlier → Add label “urgent” to the Issue.

3) Clarification workflows (context injection)

• Basecamp decision comment → Append to Issue body under “Stakeholder notes.”
• Basecamp file link (spec) → Add as an Issue reference link.

Be disciplined: GitHub works best when Issues represent real engineering actions, not every stakeholder thought. Keep Basecamp as the place for discussion and decision-making, and sync only the parts that help developers execute.

To illustrate why this focus matters, research reported by Stanford found heavy multitaskers struggle to filter irrelevant information, which mirrors what happens when low-value updates flood a workflow. (news.stanford.edu)

How do you prevent duplicate tasks, sync loops, and conflicting edits?

Preventing duplicates, sync loops, and conflicts requires 3 rules—use a single source-of-truth per field, apply strict filters, and implement loop protection markers—because most integration failures come from ambiguous ownership and unrestricted syncing.

Next, you’ll see how to write simple rules that keep Basecamp and GitHub aligned without turning every update into an event storm.

What rules prevent “ping-pong” updates between Basecamp and GitHub?

Three rules prevent ping-pong updates: field ownership rules, scoped syncing rules, and change-origin rules, because a sync loop usually happens when both systems try to “correct” each other repeatedly.

Then, once these rules exist, your integration behaves predictably even when many people edit tasks.

Rule 1: Field ownership (source-of-truth by field)

• Status: GitHub controls open/closed and “done.”
• Due date: Basecamp controls stakeholder deadlines.
• Priority: GitHub labels control technical urgency.
• Description: GitHub body holds technical details, Basecamp holds stakeholder context.

Rule 2: Scoped syncing (filtering what syncs)

Only sync tasks that match clear criteria such as a Basecamp tag “dev,” a GitHub label set, and a specific repo list per project. This single rule eliminates most accidental duplication.

Rule 3: Change origin markers (loop protection)

When the integration creates or updates an item, it adds a marker (a label or tag like “synced-from-basecamp” or “synced-from-github”), and automations ignore changes that came from the integration itself.

A helpful operational habit: write a short “Integration Policy” note in your Basecamp project—one paragraph that explains what syncs and what doesn’t.

How do you handle conflicts (two people update the same item in different apps)?

Basecamp-to-GitHub conflict handling works best when GitHub wins for execution status, Basecamp wins for stakeholder commitment fields, and the integration uses a consistent conflict rule (like “last-write-wins” only for non-critical fields) to avoid silent corruption of task meaning.

However, if your team frequently edits the same fields in both places, the real fix is behavioral: stop dual-editing the same field.

Tier 1: Avoid conflicts by design

• Lock ownership: “Only the dev lead closes Issues,” “Only the PM sets due dates.”
• Limit fields that sync in both directions.

Tier 2: Choose explicit conflict rules

• Status conflicts: GitHub overrides Basecamp (or the reverse—choose one).
• Text conflicts: prefer append-only updates rather than overwriting.
• Assignee conflicts: prefer GitHub assignment as authoritative for dev work.

Tier 3: Resolve with a human-in-the-loop

• For high-impact tasks, route conflicts to a triage owner who confirms the correct status.

This matters because conflict resolution is not just technical—it protects the shared mental model of “what is true,” and teams that lose shared truth compensate with more meetings and more interruptions. (hr.berkeley.edu)

How do you troubleshoot Basecamp ↔ GitHub integration issues quickly?

You troubleshoot Basecamp ↔ GitHub issues fastest by checking 3 layers—permissions, event delivery, and rule filters—because nearly all failures come from missing access, missing triggers (like webhooks), or rules that silently exclude the item you expected to sync.

Next, you’ll learn a repeatable symptom → cause → fix method so you don’t guess.

What are the most common setup failures (permissions, scopes, wrong repo/project, filters)?

There are 5 common setup failures: incorrect permissions, wrong scope, wrong repo/project pairing, overly strict filters, and identity mismatches, based on which layer blocks the integration from reading or writing updates.

Then, if you diagnose these in order, you usually fix the problem in minutes instead of hours.

• Incorrect permissions: Integration can’t see repos or create Issues; fix by granting least-privilege repo access.
• Wrong scope selection: Integration can read but cannot write comments/status; fix by reconnecting with required scopes.
• Wrong repo/project mapping: Updates go to the wrong Basecamp project; fix by re-mapping with a single pilot repo.
• Filters that exclude everything: Nothing happens; fix by removing filters temporarily to confirm event flow.
• Identity mismatches: Assignments fail; fix by setting a triage owner and documenting fallback behavior.

A key point: never debug three variables at once. Temporarily simplify rules so you can confirm the pipeline works end-to-end, then rebuild the final logic.

How do you diagnose missing updates (webhooks, rate limits, skipped rules)?

You diagnose missing updates by verifying webhook/event delivery, reviewing integration run logs, and checking rate limit behavior, because an integration can be “connected” yet still miss events when webhooks fail, filters skip, or APIs throttle requests.

Next, you’ll use a clean checklist that distinguishes “no events arriving” from “events arriving but ignored.”

• Confirm events are arriving: Verify Issue/PR events are emitted and webhook deliveries are successful.
• Confirm events are not being filtered out: Review label/tag/milestone rules, repo and project mapping, and conditional logic.
• Confirm the integration can write updates: Run a controlled test Issue/PR and verify Basecamp outputs.
• Consider rate limits or burst patterns: Reduce event scope and summarize updates when many PR events happen at once.

GitHub’s reporting on PR activity at massive scale helps explain why event volume management is a real design concern in integrations, not a theoretical one. (github.blog)

Now that you can choose an approach and set up a dependable Basecamp ↔ GitHub sync for Issues and PR updates, the next section expands into advanced edge cases—governance, security, and performance—so your integration remains stable as your team scales.

What advanced governance, security, and scaling considerations matter for Basecamp ↔ GitHub sync?

Advanced governance, security, and scaling matter because Basecamp ↔ GitHub sync becomes part of your operational infrastructure, and infrastructure needs least-privilege access, audit clarity, resilience to renames/migrations, and noise controls that keep people focused on what matters.

Next, you’ll see how to make your integration safer and calmer by applying “manual vs automated” and “noise vs signal” thinking in a deliberate way.

How do you apply least-privilege permissions and audit-friendly access for the integration?

You apply least-privilege and audit-friendly access by limiting repo scope, assigning a single integration owner, documenting permissions, and keeping change logs accessible, because the biggest security risk is broad, unmanaged access that nobody reviews.

Then, when you need to investigate an incident or unexpected change, you can trace what happened without panic.

• Restrict integration access to only required repos and Basecamp projects.
• Use a dedicated integration account rather than a personal account.
• Maintain an “Integration Ownership” note in Basecamp: owner, scope, log location, and safe disable steps.
• Review access quarterly or when team members change roles.

This is also where you decide what is read-only versus read-write. A safer pattern is GitHub → Basecamp for visibility and Basecamp → GitHub limited to Issue creation unless explicitly approved for closing or status changes.

What happens when repos are renamed or Basecamp projects change—will the sync break?

Repo renames and Basecamp project changes can break sync if your mapping depends on identifiers that change, so the best protection is to use stable identifiers where possible and keep a migration checklist that includes relinking, test events, and validation of source-of-truth rules.

Then, when your organization reorganizes repos or Basecamp teams, you don’t lose continuity.

• Break scenarios: Repo renamed/moved, Basecamp project duplicated/archived, rules reference old IDs, labels/milestones renamed.
• Migration checklist: Update mapping, run a test event, confirm linked items resolve, re-validate ownership rules.
• Documentation: Store an “Integration Map” note in Basecamp with repo list, label rules, and routing destinations.

How do GitHub rate limits and webhook failures affect sync reliability ?

Rate limits and webhook failures reduce sync reliability by causing delayed or missing updates, so mitigation depends on narrowing event scope, adding retries/backoff, and monitoring event delivery health rather than assuming “connected means working.”

Next, you’ll stabilize the system by designing for burst traffic instead of optimizing only for the average day.

• Filter to fewer events (e.g., merged PR only).
• Use labels/milestones to reduce watched items.
• Batch updates into summaries rather than posting every event.
• Monitor webhook delivery failures and address recurring errors.
• Maintain a manual re-sync procedure for critical incidents (e.g., re-run last 24 hours).

What is the best “noise vs signal” configuration for PR updates to keep stakeholders informed without spam?

The best “noise vs signal” configuration is to send stakeholders only milestone PR events (opened if needed, checks failing only when blocking, merged always), summarize them in a single Basecamp thread per feature/release, and keep deep technical discussion inside GitHub.

In addition, you can tune the integration based on who the audience is, because “signal” depends on the reader’s role.

• PM/stakeholders: merged + blocking failures + “ready for QA” notes.
• Dev team: detailed PR events stay in GitHub; Basecamp gets summary.
• Leadership: digest-style updates rather than event streams.

A simple configuration that works for most teams is: post to Basecamp only when a PR is merged (always) or checks are failing on a tracked milestone (only if it blocks a release), and include the PR title, linked Issue, one-line impact summary, and the PR link.

According to a study by the University of California, Irvine from the Department of Informatics, in 2008, people compensated for interruptions by working faster but reported higher stress and time pressure, showing why reducing unnecessary tool switching and noisy updates matters in knowledge work. (ics.uci.edu)

airtable to onedrive

google docs to microsoft onenote