<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-post-page plugin-blog plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">The CloudStack Conference CFP Deadline is Approaching! Submit Talks by Sunday | Apache CloudStack</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="The CloudStack Conference CFP Deadline is Approaching! Submit Talks by Sunday | Apache CloudStack"><meta data-rh="true" name="description" content="Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second CloudStack Collaboration Conference this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at http://www.cloudstackcollab.com/CfP/."><meta data-rh="true" property="og:description" content="Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second CloudStack Collaboration Conference this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at http://www.cloudstackcollab.com/CfP/."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-05-09T00:00:00.000Z"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline" hreflang="x-default"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache CloudStack RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache CloudStack Atom Feed">






<script src="scripts/bootstrap.bundle.min.js" async></script><link rel="stylesheet" href="/assets/css/styles.e12efb83.css">
<link rel="preload" href="/assets/js/runtime~main.60ecdf28.js" as="script">
<link rel="preload" href="/assets/js/main.2d60fa8d.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">About</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/about">About</a></li><li><a class="dropdown__link" href="/history">History</a></li><li><a class="dropdown__link" href="/features">Features</a></li><li><a class="dropdown__link" href="/who">Who We Are</a></li><li><a class="dropdown__link" href="/bylaws">Community Bylaws</a></li><li><a class="dropdown__link" href="/trademark-guidelines">Trademark Guidelines</a></li><li><a class="dropdown__link" href="/security">Security</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/contribute">Get Involved</a></li><li><a class="dropdown__link" href="/developers">Developer Resources</a></li><li><a class="dropdown__link" href="/mailing-lists">Join Mailing Lists</a></li><li><a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issues Tracker<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-1u8qwbivp-u16HRI~LWioLmF1G2D3Iyg" target="_blank" rel="noopener noreferrer" class="dropdown__link">Community Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/events">Events and Meetups</a></li><li><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Collab Conference<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Use Cases</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/cloud-builders">Cloud Builders</a></li><li><a class="dropdown__link" href="/kubernetes">Kubernetes</a></li><li><a class="dropdown__link" href="/integrations">Integrations</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Users</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/users">Known Users</a></li><li><a class="dropdown__link" href="/blog/blog/tags/case-studies">Case Studies</a></li><li><a href="https://docs.google.com/forms/d/e/1FAIpQLScPHIRetdt-pxPT62IesXMoQUmhQ8ATGKcYZa507mB9uwzn-Q/viewform" target="_blank" rel="noopener noreferrer" class="dropdown__link">Take Survey<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a href="https://docs.cloudstack.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Documentation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Home" target="_blank" rel="noopener noreferrer" class="dropdown__link">Project Wiki<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Books<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/api/">API Documentation</a></li></ul></div><a class="navbar__item navbar__link" href="/downloads">Download</a><a class="navbar__item navbar__link" href="/blog">Blog</a><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_Pkmr"><kbd class="searchHint_iIMx">ctrl</kbd><kbd class="searchHint_iIMx">K</kbd></div></div></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><div class="container margin-vert--lg blog-container"><div class="row"><aside class="col col--3"><nav class="sidebar thin-scrollbar"><div class="sidebarItemTitle margin-bottom--md">CloudStack Blog</div><ul class="sidebarItemList clean-list"><li class="sidebarItem"><a class="sidebarItemLink" href="/blog">All Posts</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/news">News</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/announcement">Announcements</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/roundup">Past Events</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/case-studies">Case Studies &amp; Integrations</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/community">Meet the Community</a></li></ul></nav></aside><main class="col col--7" itemscope="" itemtype="http://schema.org/Blog"><article itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second CloudStack Collaboration Conference this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at http://www.cloudstackcollab.com/CfP/."><header><h1 class="title_f1Hy" itemprop="headline">The CloudStack Conference CFP Deadline is Approaching! Submit Talks by Sunday</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-05-09T00:00:00.000Z" itemprop="datePublished">May 9, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" class="img_ev3q"></a>Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second <a href="http://www.cloudstackcollab.com/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration Conference</a> this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at <a href="http://www.cloudstackcollab.com/CfP/" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.com/CfP/</a>.</p><p>The Collaboration Conference will feature tracks for users, developers, and integrators of Apache CloudStack. We’re looking for presentations that provide insight into best practices in deploying and developing Apache CloudStack. This includes supporting technologies like configuration management tools, monitoring solutions, and more. </p><p>This will be an outstanding opportunity for developers to collaborate, exchange ideas, and get work done face-to-face with other Apache CloudStack contributors to improve Apache CloudStack.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="proposals">Proposals<a href="#proposals" class="hash-link" aria-label="Direct link to Proposals" title="Direct link to Proposals">​</a></h2><p>The program committee will be looking for presentations and workshops related to working with and developing Apache CloudStack. This includes everything from running CloudStack at scale, best practices for working with IaaS clouds, discussions about CloudStack’s architecture, proposals for feature development, and more. We’re also open to talks that go hand-in-hand with managing Apache CloudStack, like configuration management and monitoring tools. </p><p>In short, if it’s relevant to Apache CloudStack development, deployment, and integration, we’re interested in what you might have to say. For an example of what we’re looking for, check out some of the <a href="http://is.gd/CCC12vids" target="_blank" rel="noopener noreferrer">videos from last year’s event</a>.</p><p>To submit your talk, just go to <a href="http://www.cloudstackcollab.com/CfP/" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.com/CfP/</a> and follow the steps there. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="timelineanddeadlines">Timeline and Deadlines<a href="#timelineanddeadlines" class="hash-link" aria-label="Direct link to Timeline and Deadlines" title="Direct link to Timeline and Deadlines">​</a></h2><p>There’s no time like the present to submit a proposal. We recommend getting your proposal in early, and feel free to ask questions about talk ideas on marketing@cloudstack.apache.org if you want tips for success! You can reach the CfP committee at planning@cloudstackcollab.org.</p><p>Dates for proposals are as follows:</p><ul><li>Call for Proposals is open on April 22nd.</li><li>Call for Proposals closes on May 12th.</li><li>Notifications will go out on May 17th.</li><li>Confirmations will be due by May 22nd.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="travelsponsorships">Travel Sponsorships<a href="#travelsponsorships" class="hash-link" aria-label="Direct link to Travel Sponsorships" title="Direct link to Travel Sponsorships">​</a></h2><p>Not sure if you can afford the airfare and lodging to attend the Collaboration Conference? Please don’t let that stop you from submitting your best proposal. We may be making a number of travel sponsorships available for speakers who have useful information to share with the Apache CloudStack community.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="codeofconduct">Code of Conduct<a href="#codeofconduct" class="hash-link" aria-label="Direct link to Code of Conduct" title="Direct link to Code of Conduct">​</a></h2><p>The Apache CloudStack community is open to everyone. As such, we are committed to providing a friendly, safe, and welcoming environment for all - regardless of gender, sexual orientation, disability, ethnicity, or religion. We respect and encourage diversity at our conference.</p><p>By agreeing to present at the conference, you are agreeing to abide by the code of conduct. We expect all speakers and attendees to have read and understood the code of conduct, and that all presentations will meet this standard.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="questions">Questions?<a href="#questions" class="hash-link" aria-label="Direct link to Questions?" title="Direct link to Questions?">​</a></h2><p>If you have questions or concerns, please don’t hesitate to reach out to the conference planning committee by sending an email to planning@cloudstackcollab.org.</p></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_mRVl"><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2013-05-09-the_cloudstack_conference_cfp_deadline.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/apache_cloudstack_weekly_news_13"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 13 May 2013</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_weekly_news_29"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 29 April 2013</div></a></nav></main></div></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://cloudstack.apache.org/" rel="noopener noreferrer" class="footerLogoLink_BH7S"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
            <div class="social">
                <a href="mailto:dev-subscribe@cloudstack.apache.org">
		  <img src="/img/mail_mini_icon.svg" alt="">
		</a>
                <a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-2aegc22z7-tPCxpptfcebTBtd59qcZSQ">
		  <img src="/img/slack_mini_icon.svg" alt="">
		</a>
                <a href="https://github.com/apache/cloudstack">
		  <img src="/img/git_mini_icon.svg" alt="">
		</a>
                <a href="https://twitter.com/CloudStack">
		  <img src="/img/twitter_X_mini_icon.svg" alt="">
		</a>
                <a href="https://www.youtube.com/@ApacheCloudStack">
		  <img src="/img/youtube_mini_icon.svg" alt="">
		</a>
                <a href="https://www.linkedin.com/company/apachecloudstack/posts/">
		  <img src="/img/linkedin_icon.svg" alt="">
		</a>
            </div>
            <div class="footer-bottom">Copyright © 2023 The Apache
Software Foundation, Licensed under the Apache License, Version 2.0.
“Apache”, “CloudStack”, “Apache CloudStack”, the Apache CloudStack logo,
 the Apache CloudStack Cloud Monkey logo and the Apache feather logos
are registered trademarks or trademarks of The Apache Software
Foundation.
            <p class="footer-blue"><a href="/trademark-guidelines">Apache CloudStack Trademark Usage</a> - <a href="/bylaws">Apache CloudStack Community ByLaws</a> - <a href="https://github.com/apache/cloudstack-www">Website Source Code</a></p></div>
            </div>
          <br>
          </div></div></footer></div>
<script src="/assets/js/runtime~main.60ecdf28.js"></script>
<script src="/assets/js/main.2d60fa8d.js"></script>
</body>
</html>