Int implementation using linked lists
Here are some observations and suggestions that may help you improve your code.

Use objects

The program is written much more in the procedural style of C rather than in the object-oriented style of C++.  The list itself could be an object (as could the individual nodes), with most of the procedures as functions of that object.  This would reduce coupling and make the program easier to understand.  Not least, instead of requiring the user to explicitly call deallocateList(), the object's destructor could automatically be called.

Make sure all paths return a value

Both the printNode() and deallocateList() functions claim to return an int but neither of them actually do.  Either return a meaningful int value or change the function signature to void.

Match new and delete

As mentioned in comments to this question, new should be matched with delete and not delete[] which is a different operation.  

Use better naming

The function named printNode is not well named.  A better name might be printList since it actually prints the entire list and not just a single node.

Avoid using raw pointers

In modern C++, we don't tend to use raw pointers as much as in C.  Instead, we either use smart pointers or objects.  In this case, I'd say that if you created objects, it would be better to return an object from sumLists() and intToList() rather than a pointer to a node.

Use const where practical

In almost all of your functions, one parameter is a reference to a pointer to an intNode which is the beginning node of a list.  In all cases, that list is unmodified by the function and so can (and should) be declared as const.

Understand references and pointers

Almost all of your functions take an intNode *&amp; as an argument.  I would highly recommend that you use either pointers or references but not references to pointers.  

Use nullptr rather than NULL

Modern C++ uses nullptr rather than NULL.  See this answer for why and how it's useful.  

Minimize duplication of code

The current append looks like this: 

void append(intNode *&amp;s, int n) {
    if (s == NULL) {
        s = new intNode;
        s-&gt;num = n;
        s-&gt;next = NULL;
    }
    else {
        intNode *nNode = new intNode;
        nNode-&gt;num = n;
        nNode-&gt;next = s;
        s = nNode;
    }
}


However, most of the code is functionally identical whether s is NULL or not.  I'd rewrite it like this:

void append(intNode *&amp;s, int n) {
    s = new intNode{n, s};
}


Avoid pointless numeric conversions

In the intConversionHelper() routine, we inexplicably have a conversion to float which is then converted back to an int when the value is returned.  Just use int and avoid the conversions.

Rethink your interface

Right now, only numbers that fit in an int are representable within this code, severely restricting the use of the list and functions such as sumLists.  Instead, consider adding digit at a time without converting each list to an int first.