diff --git a/rowers/forms.py b/rowers/forms.py
index 744c47a3..bad60f81 100644
--- a/rowers/forms.py
+++ b/rowers/forms.py
@@ -49,8 +49,9 @@ class StrokeDataForm(forms.Form):
 # The form used for uploading files    
 class DocumentsForm(forms.Form):
     title = forms.CharField(required=False)
-    file = forms.FileField(required=True,
+    file = forms.FileField(required=False,
 			   validators=[validate_file_extension])
+
     workouttype = forms.ChoiceField(required=True,
 				    choices=Workout.workouttypes)
 #				    initial='rower')
diff --git a/rowers/templates/document_form.html b/rowers/templates/document_form.html
index 3c02acee..7818fe52 100644
--- a/rowers/templates/document_form.html
+++ b/rowers/templates/document_form.html
@@ -48,7 +48,8 @@
     </script>
 {% endblock %}
 
-{% block content %}
+    {% block content %}
+    <div id="id_drop-files" class="grid_12 drop-files">
     <form id="file_form" enctype="multipart/form-data" action="{{ formloc }}" method="post">
 <div id="left" class="grid_6 alpha">
   <h1>Upload Workout File</h1>
@@ -90,5 +91,77 @@
 
 
 
-</form>
+    </form>
+    </div>
 {% endblock %}
+
+    {% block scripts %}
+
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
+<script>   
+  $(document).ready(function() {
+  console.log("Loading dropper");
+  jQuery.event.props.push('dataTransfer');
+
+  
+  var frm = $("#file_form");
+  var data = new FormData(frm[0]);
+
+  $('input').each(function( i ) {
+  console.log($(this).attr('name'),$(this).val());
+  $(this).change(function() {
+  data.set($(this).attr('name'),$(this).val());
+  if ($(this).attr('id') == 'id_file') {
+  data.set("file",this.files[0]);
+  };
+  console.log($(this).attr('name'),$(this).val());
+  });
+  });
+  
+  $('select').each(function( i ) {
+  console.log($(this).attr('name'),$(this).val());
+  $(this).change(function() {
+  data.set($(this).attr('name'),$(this).val());
+  console.log($(this).attr('id'),$(this).attr('name'),$(this).val());
+  });
+  });
+  
+  frm.submit(function() {
+  console.log("Form submission");
+  console.log(data);
+  $.ajax({
+  data: data,
+  type: $(this).attr('method'),
+  url: '/rowers/workout/upload_ajax/',
+  contentType: false,
+  processData: false,
+  success: function(result) {
+  console.log('got something back');
+  console.log(result);
+  if (result.result == 1) {
+  window.location.href = result.url;
+  }
+  }
+  });
+  return false;
+  });
+
+  $('#id_drop-files').bind({
+  drop: function(e) {
+  e.preventDefault();
+  console.log("you dropped something");
+  var files = e.dataTransfer.files;
+  console.log(files[0]);
+  data.append("file",files[0]);
+  $("#id_file").replaceWith('<div id="id_file">'+files[0].name+'</div>');
+  },
+  mouseenter:function(){$("#id_drop-files").css("background-color","#E9E9E4");},
+  mouseleave:function(){$("#id_drop-files").css("background-color","#FFFFFF");},
+  dragover:function(e){
+  e.preventDefault();
+  $("#id_drop-files").css("background-color","#E9E9E4");},
+  dragleave:function(e){ e.preventDefault();},
+  });
+  })
+</script>
+    {% endblock %}
diff --git a/rowers/urls.py b/rowers/urls.py
index 9179e415..3a8c367d 100644
--- a/rowers/urls.py
+++ b/rowers/urls.py
@@ -195,6 +195,7 @@ urlpatterns = [
     url(r'^workout/(?P<id>\d+)/get-testscript$',views.get_testscript),
     url(r'^workout/upload/team/$',views.team_workout_upload_view),
     url(r'^workout/upload/$',views.workout_upload_view,name='workout_upload_view'),
+    url(r'^workout/upload_ajax/$',views.workout_upload_ajax),
     url(r'^workout/(?P<id>\d+)/histo$',views.workout_histo_view),
     url(r'^workout/(?P<id>\d+)/task$',views.workout_test_task_view),
     url(r'^workout/(?P<id>\d+)/forcecurve$',views.workout_forcecurve_view),
diff --git a/rowers/views.py b/rowers/views.py
index 11cbea23..308255b7 100644
--- a/rowers/views.py
+++ b/rowers/views.py
@@ -8401,7 +8401,287 @@ def workout_getc2workout_view(request,c2id):
 	    return HttpResponseRedirect(url)
 
 # This is the main view for processing uploaded files
+@csrf_exempt
 @login_required()
+def workout_upload_ajax(request,
+                        uploadoptions={
+                            'makeprivate':False,
+                            'make_plot':False,
+                            'upload_to_C2':False,
+                            'plottype':'timeplot',
+                            'landingpage':'workout_edit_view',
+                        },
+                        docformoptions={
+                            'workouttype':'rower',
+                        }):
+
+    r = getrower(request.user)
+
+    if 'uploadoptions' in request.session:
+        uploadoptions = request.session['uploadoptions']
+        try:
+            defaultlandingpage = uploadoptions['landingpage']
+        except KeyError:
+            uploadoptions['landingpage'] = r.defaultlandingpage
+            defaultlandingpage = r.defaultlandingpage
+    else:
+        request.session['uploadoptions'] = uploadoptions
+
+    if 'docformoptions' in request.session:
+        docformoptions = request.session['docformoptions']
+    else:
+        request.session['docformoptions'] = docformoptions
+
+    try:
+        makeprivate = uploadoptions['makeprivate']
+    except KeyError:
+        makeprivate = False
+    try:
+        make_plot = uploadoptions['make_plot']
+    except KeyError:
+        make_plot = False
+
+    try:
+        workouttype = docformoptions['workouttype']
+    except KeyError:
+        workouttype = 'rower'
+
+    try:
+        plottype = uploadoptions['plottype']
+    except KeyError:
+        plottype = 'timeplot'
+
+    try:
+        landingpage = uploadoptions['landingpage']
+    except KeyError:
+        landingpage = r.defaultlandingpage
+        uploadoptions['landingpage'] = landingpage
+
+    try:
+        upload_to_c2 = uploadoptions['upload_to_C2']
+    except KeyError:
+        upload_to_c2 = False
+
+    try:
+        upload_to_strava = uploadoptions['upload_to_Strava']
+    except KeyError:
+        upload_to_strava = False
+
+    try:
+        upload_to_st = uploadoptions['upload_to_SportTracks']
+    except KeyError:
+        upload_to_st = False
+
+    try:
+        upload_to_rk = uploadoptions['upload_to_RunKeeper']
+    except KeyError:
+        upload_to_rk = False
+
+    try:
+        upload_to_ua = uploadoptions['upload_to_MapMyFitness']
+    except KeyError:
+        upload_to_ua = False
+
+    try:
+        upload_to_tp = uploadoptions['upload_to_TrainingPeaks']
+    except KeyError:
+        upload_to_tp = False
+
+    if request.method == 'POST':
+	form = DocumentsForm(request.POST,request.FILES)
+	optionsform = UploadOptionsForm(request.POST)
+
+	if form.is_valid():
+            try:
+	        f = request.FILES['file']
+            except:
+                f = request.FILES['file2']
+	    res = handle_uploaded_file(f)
+	    t = form.cleaned_data['title']
+	    workouttype = form.cleaned_data['workouttype']
+            request.session['docformoptions'] = {
+                'workouttype':workouttype,
+                }
+            
+	    notes = form.cleaned_data['notes']
+            offline = form.cleaned_data['offline']
+
+            if optionsform.is_valid():
+	        make_plot = optionsform.cleaned_data['make_plot']
+	        plottype = optionsform.cleaned_data['plottype']
+	        upload_to_c2 = optionsform.cleaned_data['upload_to_C2']
+	        upload_to_strava = optionsform.cleaned_data['upload_to_Strava']
+	        upload_to_st = optionsform.cleaned_data['upload_to_SportTracks']
+	        upload_to_rk = optionsform.cleaned_data['upload_to_RunKeeper']
+	        upload_to_ua = optionsform.cleaned_data['upload_to_MapMyFitness']
+	        upload_to_tp = optionsform.cleaned_data['upload_to_TrainingPeaks']
+                makeprivate = optionsform.cleaned_data['makeprivate']
+                landingpage = optionsform.cleaned_data['landingpage']
+                uploadoptions = {
+                    'makeprivate':makeprivate,
+                    'make_plot':make_plot,
+                    'plottype':plottype,
+                    'upload_to_C2':upload_to_c2,
+                    'upload_to_Strava':upload_to_strava,
+                    'upload_to_SportTracks':upload_to_st,
+                    'upload_to_RunKeeper':upload_to_rk,
+                    'upload_to_MapMyFitness':upload_to_ua,
+                    'upload_to_TrainingPeaks':upload_to_tp,
+                    'landingpage':landingpage,
+                }
+
+
+            request.session['uploadoptions'] = uploadoptions
+
+	    f1 = res[0] # file name
+	    f2 = res[1] # file name incl media directory
+
+            if not offline:
+                id,message,f2 = dataprep.new_workout_from_file(
+                    r,f2,
+                    workouttype=workouttype,
+                    makeprivate=makeprivate,
+                    title = t,
+                    notes=''
+                )
+            else:
+                job = myqueue(
+                    queuehigh,
+                    handle_zip_file,
+                    r.user.email,
+                    t,
+                    f2)
+                    
+                messages.info(
+                    request,
+                    "The file was too large to process in real time. It will be processed in a background process. You will receive an email when it is ready")
+                url = reverse(workout_upload_view)
+                return JSONResponse({'result':1,'url':url})
+                
+            if not id:
+                messages.error(request,message)
+                return JSONResponse({'result':0})
+            elif id == -1:
+                message = 'The zip archive will be processed in the background. The files in the archive will only be uploaded without the extra actions. You will receive email when the workouts are ready.'
+                messages.info(request,message)
+                return JSONResponse({'result':1})
+            else:
+                if message:
+                    messages.error(request,message)
+
+                
+                url = reverse(workout_edit_view,
+                              kwargs = {
+                                  'id':int(id),
+                              })    
+                response = {'result': 1,'url':url}
+                w = Workout.objects.get(id=id)
+
+            r = getrower(request.user)
+	    if (make_plot):
+                id = uploads.make_plot(r,w,f1,f2,plottype,t)
+
+	    # upload to C2
+	    if (upload_to_c2):
+                try:
+                    message,id = c2stuff.workout_c2_upload(request.user,w)
+                except C2NoTokenError:
+                    id = 0
+                    message = "Something went wrong with the Concept2 sync"
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+                    
+            if (upload_to_strava):
+                try:
+                    message,id = stravastuff.workout_strava_upload(
+                        request.user,w
+                    )
+                except StravaNoTokenError:
+                    id = 0
+                    message = "Please connect to Strava first"
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+                    
+            if (upload_to_st):
+                try:
+                    message,id = sporttracksstuff.workout_sporttracks_upload(
+                        request.user,w
+                    )
+                except SportTracksNoTokenError:
+                    message = "Please connect to SportTracks first"
+                    id = 0
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+                    
+            if (upload_to_rk):
+                try:
+                    message,id = runkeeperstuff.workout_runkeeper_upload(
+                        request.user,w
+                        )
+                except RunKeeperNoTokenError:
+                    message = "Please connect to Runkeeper first"
+                    id = 0
+
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+
+
+            if (upload_to_ua):
+                try:
+                    message,id = underarmourstuff.workout_ua_upload(
+                        request.user,w
+                    )
+                except UnderArmourNoTokenError:
+                    message = "Please connect to MapMyFitness first"
+                    id = 0
+
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+
+
+            if (upload_to_tp):
+                try:
+                    message,id = tpstuff.workout_tp_upload(
+                        request.user,w
+                        )
+                except TPNoTokenError:
+                    message = "Please connect to TrainingPeaks first"
+                    id = 0
+
+                if id>1:
+                    messages.info(request,message)
+                else:
+                    messages.error(request,message)
+
+            if landingpage != 'workout_upload_view':
+                url = reverse(landingpage,
+                              kwargs = {
+                                  'id':w.id,
+                              })
+                response = {'result':1, 'url':url}
+            else:
+                url = reverse(landingpage)
+                response = {'result':1, 'url':url}
+                
+            return JSONResponse(response)
+	else:
+            response = {'result':0}
+
+	return JSONResponse(response)
+    else:
+        response = {'result':0}
+        return JSONResponse(response)
+        
 def workout_upload_view(request,
                         uploadoptions={
                             'makeprivate':False,
@@ -8489,8 +8769,12 @@ def workout_upload_view(request,
     if request.method == 'POST':
 	form = DocumentsForm(request.POST,request.FILES)
 	optionsform = UploadOptionsForm(request.POST)
+
 	if form.is_valid():
-	    f = request.FILES['file']
+            try:
+	        f = request.FILES['file']
+            except:
+                f = request.FILES['file2']
 	    res = handle_uploaded_file(f)
 	    t = form.cleaned_data['title']
 	    workouttype = form.cleaned_data['workouttype']
@@ -8691,6 +8975,7 @@ def workout_upload_view(request,
 		       'optionsform': optionsform,
                       })
 
+    
 # This is the main view for processing uploaded files
 @user_passes_test(iscoachmember,login_url="/",redirect_field_name=None)
 def team_workout_upload_view(request,message="",
diff --git a/static/css/rowsandall.css b/static/css/rowsandall.css
index f13c422f..fe739c64 100644
--- a/static/css/rowsandall.css
+++ b/static/css/rowsandall.css
@@ -791,6 +791,8 @@ a.wh:hover {
   -webkit-margin-after: 0em;
 }
 
-#drop-files {
+.drop-files {
+  border: 1px solid #000;
+  color: #000;
 
 }