diff --git a/src/apps.js b/src/apps.js
index cdc94593c..6584dc3c6 100644
--- a/src/apps.js
+++ b/src/apps.js
@@ -296,11 +296,9 @@ function hasAccessTo(app, user, callback) {
     if (!app.accessRestriction.groups) return callback(null, false);
 
     async.some(app.accessRestriction.groups, function (groupId, iteratorDone) {
-        groups.isMember(groupId, user.id, function (error, member) {
-            iteratorDone(!error && member); // async.some does not take error argument in callback
-        });
-    }, function (result) {
-        callback(null, result);
+        groups.isMember(groupId, user.id, iteratorDone);
+    }, function (error, result) {
+        callback(null, !error && result);
     });
 }
 
@@ -360,11 +358,9 @@ function getAllByUser(user, callback) {
     getAll(function (error, result) {
         if (error) return callback(error);
 
-        async.filter(result, function (app, callback) {
-            hasAccessTo(app, user, function (error, hasAccess) {
-                callback(hasAccess);
-            });
-        }, callback.bind(null, null));  // never error
+        async.filter(result, function (app, iteratorDone) {
+            hasAccessTo(app, user, iteratorDone);
+        }, callback);
     });
 }
 
diff --git a/src/dns/manual.js b/src/dns/manual.js
index 782229c39..7ed6900d0 100644
--- a/src/dns/manual.js
+++ b/src/dns/manual.js
@@ -60,18 +60,14 @@ function verifyDnsConfig(dnsConfig, domain, ip, callback) {
     dns.resolveNs(domain, function (error, nameservers) {
         if (error || !nameservers) return callback(new SubdomainError(SubdomainError.BAD_FIELD, 'Unable to get nameservers'));
 
-        // async.every only reports bools
-        var stashedError = null;
-
-        async.every(nameservers, function (nameserver, callback) {
+        async.every(nameservers, function (nameserver, everyNsCallback) {
             // ns records cannot have cname
             dns.resolve4(nameserver, function (error, nsIps) {
                 if (error || !nsIps || nsIps.length === 0) {
-                    stashedError = new SubdomainError(SubdomainError.BAD_FIELD, 'Unable to resolve nameservers for this domain');
-                    return callback(false);
+                    return everyNsCallback(new SubdomainError(SubdomainError.BAD_FIELD, 'Unable to resolve nameservers for this domain'));
                 }
 
-                async.every(nsIps, function (nsIp, callback) {
+                async.every(nsIps, function (nsIp, everyIpCallback) {
                     var req = dns.Request({
                         question: dns.Question({ name: adminDomain, type: 'A' }),
                         server: { address: nsIp },
@@ -80,20 +76,20 @@ function verifyDnsConfig(dnsConfig, domain, ip, callback) {
 
                     req.on('timeout', function () {
                         debug('nameserver %s (%s) timed out when trying to resolve %s', nameserver, nsIp, adminDomain);
-                        return callback(true); // should be ok if dns server is down
+                        return everyIpCallback(null, true); // should be ok if dns server is down
                     });
 
                     req.on('message', function (error, message) {
                         if (error) {
                             debug('nameserver %s (%s) returned error trying to resolve %s: %s', nameserver, nsIp, adminDomain, error);
-                            return callback(false);
+                            return everyIpCallback(null, false);
                         }
 
                         var answer = message.answer;
 
                         if (!answer || answer.length === 0) {
                             debug('bad answer from nameserver %s (%s) resolving %s (%s): %j', nameserver, nsIp, adminDomain, 'A', message);
-                            return callback(false);
+                            return everyIpCallback(null, false);
                         }
 
                         debug('verifyDnsConfig: ns: %s (%s), name:%s Actual:%j Expecting:%s', nameserver, nsIp, adminDomain, answer, ip);
@@ -102,16 +98,16 @@ function verifyDnsConfig(dnsConfig, domain, ip, callback) {
                             return a.address === ip;
                         });
 
-                        if (match) return callback(true); // done!
+                        if (match) return everyIpCallback(null, true); // done!
 
-                        callback(false);
+                        everyIpCallback(null, false);
                     });
 
                     req.send();
-                }, callback);
+                }, everyNsCallback);
             });
-        }, function (success) {
-            if (stashedError) return callback(stashedError);
+        }, function (error, success) {
+            if (error) return callback(error);
             if (!success) return callback(new SubdomainError(SubdomainError.BAD_FIELD, 'The domain ' + adminDomain + ' does not resolve to the server\'s IP ' + ip));
 
             callback(null, { provider: dnsConfig.provider, wildcard: !!dnsConfig.wildcard });
diff --git a/src/dns/waitfordns.js b/src/dns/waitfordns.js
index aadee996f..a56a7fe38 100644
--- a/src/dns/waitfordns.js
+++ b/src/dns/waitfordns.js
@@ -10,7 +10,6 @@ var assert = require('assert'),
     tld = require('tldjs'),
     util = require('util');
 
-// the first arg to callback is not an error argument; this is required for async.every
 function isChangeSynced(domain, value, type, nameserver, callback) {
     assert.strictEqual(typeof domain, 'string');
     assert(util.isRegExp(value));
@@ -34,20 +33,20 @@ function isChangeSynced(domain, value, type, nameserver, callback) {
 
             req.on('timeout', function () {
                 debug('nameserver %s (%s) timed out when trying to resolve %s', nameserver, nsIp, domain);
-                return iteratorCallback(true); // should be ok if dns server is down
+                return iteratorCallback(null, true); // should be ok if dns server is down
             });
 
             req.on('message', function (error, message) {
                 if (error) {
                     debug('nameserver %s (%s) returned error trying to resolve %s: %s', nameserver, nsIp, domain, error);
-                    return iteratorCallback(false);
+                    return iteratorCallback(null, false);
                 }
 
                 var answer = message.answer;
 
                 if (!answer || answer.length === 0) {
                     debug('bad answer from nameserver %s (%s) resolving %s (%s): %j', nameserver, nsIp, domain, type, message);
-                    return iteratorCallback(false);
+                    return iteratorCallback(null, false);
                 }
 
                 debug('isChangeSynced: ns: %s (%s), name:%s Actual:%j Expecting:%s', nameserver, nsIp, domain, answer, value);
@@ -58,9 +57,9 @@ function isChangeSynced(domain, value, type, nameserver, callback) {
                             (type === 'TXT' && value.test(a.data.join(''))));
                 });
 
-                if (match) return iteratorCallback(true); // done!
+                if (match) return iteratorCallback(null, true); // done!
 
-                iteratorCallback(false);
+                iteratorCallback(null, false);
             });
 
             req.send();
@@ -90,7 +89,7 @@ function waitForDns(domain, value, type, options, callback) {
         dns.resolveNs(zoneName, function (error, nameservers) {
             if (error || !nameservers) return retryCallback(error || new SubdomainError(SubdomainError.EXTERNAL_ERROR, 'Unable to get nameservers'));
 
-            async.every(nameservers, isChangeSynced.bind(null, domain, value, type), function (synced) {
+            async.every(nameservers, isChangeSynced.bind(null, domain, value, type), function (error, synced) {
                 debug('waitForIp: %s %s ns: %j', domain, synced ? 'done' : 'not done', nameservers);
 
                 retryCallback(synced ? null : new SubdomainError(SubdomainError.EXTERNAL_ERROR, 'ETRYAGAIN'));