Contents

Note: Modern Treasury empowers teams to make payment operations simple, scalable, and secure. The “Guides” series walks through representative businesses or payment processes and explains step by step how best to go about building them from scratch. ‍

Introduction

Since the passage of the 1965 Higher Education Act, which mandated the Federal government to guarantee student loans made by banks, student debt in the US has grown significantly. It recently passed $1.5 trillion, an average of $34,000 per person. 

As a response to this crisis, entrepreneurs are starting to rethink tuition funding. One novel and, for some, more attractive way to finance education is through Income Sharing Agreements. Some prominent companies, such as Lambda School, are building a whole new educational experience and focusing on specific areas, such as computer science. Others, such as Avenify or Vemo Education, are focused on the financing aspect only and pay for tuition at established institutions. As the market grows, new models will emerge to suit different candidates, credentials, and educational paths. 

Regardless of specifics, however, the Income Sharing Agreement (ISA) structure is relatively consistent. To define it more explicitly, an Income Sharing Agreement funds a student’s tuition upfront in exchange for receiving a percentage of the student’s future earnings (hence “income-sharing”) based on a pre-defined formula. In this way, the funder can be thought of less as a debt investor and more as an equity investor, receiving “dividends” from the students future earnings. 

This post is a guide to the operational, money movement aspects of building an Income Sharing Agreement product. While the specifics of who is getting funded and the formula for repayment might vary, we hope that this guide is useful in simplifying and demystifying how a company can build to the Income Sharing Agreement model. 


The user experience

Let’s start with defining the user experience for a new Income Sharing Agreement company, which we will name Fundme. Let’s say our sample ISA company funds community college tuition in exchange for 10% of a student’s future earnings for five years. We will use 10% and five years as a sample deal for Fundme. 

The user experience might involve the following steps:

  1. A prospective student, Lee Learner, applies.
  2. Fundme approves Lee’s tuition and pays out the funds promised, allowing Lee to attend school. 
  3. Once Lee finishes school and gets a job, Fundme calculates a monthly payment based on Lee’s paycheck and withdraws 10% of each paycheck on a monthly basis. 
  4. On an aggregate basis, Fundme sends the funds to its investors. 

In reality, the formula for calculating the monthly payment is oftentimes more complex. For example, students might get a grace period of a few months immediately after graduation or if they experience hardship. There might also be a pre-negotiated maximum total payment that the student owes. Again, for simplicity’s sake, we will use only the case outlined above and develop a payment ops architecture based on that.


Payment ops architecture

Before writing any code, Fundme must develop a banking relationship and open accounts at its chosen bank. The bank can help with regulatory and financing issues and will be a close partner in managing Fundme’s operations smoothly. Similar to a lender, Fundme might set up two separate bank accounts: a Funding account that holds funds and distributes them to newly approved students, and a Collections account that collects monthly payments and transfers those back to investors. 

Let’s assume you build for the following setup: 

Step 1: Fundme sends money to Lee Learner’s account.


Step 2: Collections account sends regular ACH debits to Lee Learner’s account. Monthly payment amounts may change over time, as Lee Learner earns more.

Fundme’s payment operations team will oversee the regular disbursement and collection of funds, and make sure that everything is tracked and reconciled accordingly. 


API calls and timings

With this payment ops architecture in hand, we’re ready to build our app. 


Step 1: Collect bank account details

Fundme first needs to collect Lee’s bank account details. To do so, you first create a counterparty in Modern Treasury, and populate it with the bank account and routing numbers you have received (more here on common methods of authenticating accounts, such as Plaid):


curl --request POST \
  -u ORGANIZATION_ID:API_KEY \
  --url https://app.moderntreasury.com/api/counterparties \
  -H 'Content-Type: application/json' \
  -d '{
  "name": "Lee Learner",
  "accounts": [
    {
      "account_type": "checking",
      "routing_details": [
        {
          "routing_number_type": "aba",
          "routing_number": "121141822"
        }
      ],
      "account_details": [
        {
          "account_number": "123456789"
        }
      ]
    }
  ]}’


In addition to the account and routing number, you might want to hold additional information about the counterparty held in metadata. This information might include a unique student ID, the way in which they signed up, and other information.


Step 2: Fund Lee Learner’s tuition

A counterparty creation response will notify you that everything has been successfully set up. Now that a counterparty exists, you can fund Lee’s tuition. Let’s say Lee Learner is getting $10,000 from Fundme for this semester. Given the amount, you might choose to send that amount via ACH. Note that the amount is in cents, not dollars, so it shows up as 1000000:


curl --request POST \
  -u ORGANIZATION_ID:API_KEY \
  --url https://app.moderntreasury.com/api/payment_orders \
  -H 'Content-Type: application/json' \
  -d '{
  "type": "ach",
  "amount": 1000000,
  "direction": "credit",
  "currency": "USD",
  "originating_account": "Funding account ID",
  "receiving_account_id": "Lee Learner’s bank account ID",
  "counterparty_id": "Lee Learner’s counterparty ID"
}'


Once the payment goes through, the Funding account will be $10,000 poorer but Lee Learner will have funds for school. Note that based on a company’s model, you might need to fund the school directly (perhaps to prevent Lee Learner from using the funds for unintended purposes). In that case, you might create a new counterparty for the community college, and fund the payment via paper check using an API call to print and send a paper check. Or, in an effort to delight the customer, you might use Real Time Payments (RTP) to send the money instantly. 

Finally, you want to add metadata to the payment for future reference. In addition to metadata tags (eg. key value pairs such as Student: Lee Learner or CollegeType: Community) you might also choose to hold line items to distinguish between school tuition, books, etc. This will be useful for customer service and finance teams that might have to answer questions about this payment in the future, or book entries differently for each line item in Fundme’s accounting software.


Step 3: Collect monthly payments

Now, based on the terms of the Income Sharing Agreement, Fundme is entitled to a monthly payment. Let’s suppose Lee Learner graduated and got a job. Lee has set up automatic debits and does not need to be involved in the process. That means that you have to initiate an ACH debit from Lee Learner’s account for an amount equal to 10% of Lee’s paycheck, which for a given month might be $400. Note that instead of using the Funding account, Fundme is now using the Collections account: 


curl --request POST \
  -u ORGANIZATION_ID:API_KEY \
  --url https://app.moderntreasury.com/api/payment_orders \
  -H 'Content-Type: application/json' \
  -d '{
  "type": "ach",
  "amount": 40000,
  "direction": "debit",
  "currency": "USD",
  "originating_account": "Collections account ID",
  "receiving_account_id": "Lee Learner’s bank account ID",
  "counterparty_id": "Lee Learner’s counterparty ID"
}'


Fundme might get rights to receive paystubs to calculate that amount each month. Over time, as Lee gets promoted and sees raises, the $400 monthly payment might grow to $500, then $600, and so on. With a flexible API call, you can include that variable amount and change it each month. 


Step 4: Disburse collected payments back to investors

Finally, Fundme’s investors would like to receive the funds they had disbursed back. Suppose Fundme’s model is to take a fee and send the balance back to its investors on a quarterly basis. Since the funds collected across many students might grow to be fairly large sums, Fundme’s investors prefer that the payment ops team wire the funds out once a quarter. To do that, Fundme does a call for a wire for $1,000,000, again denominated in cents, sent to a new counterparty created for each investor:


curl --request POST \
  -u ORGANIZATION_ID:API_KEY \
  --url https://app.moderntreasury.com/api/payment_orders \
  -H 'Content-Type: application/json' \
  -d '{
  "type": "wire",
  "amount": 100000000,
  "direction": "credit",
  "currency": "USD",
  "originating_account": "Collections account ID",
  "receiving_account_id": "Investor bank account ID",
  "counterparty_id": "Investor counterparty ID"
}'


That’s it. With these four API calls you can set up the payment ops architecture for an Income Sharing Agreement company and focus on finding the right students, marketing your offer to them, and working to improve your model to make sure your company is on a sustainable footing.


What can go wrong?

Payment operations software such as Modern Treasury can manage not only the happy path as described above but also edge cases when things go wrong. A common issue could be handling an ACH return associated with a specific return code

Another might be a customer service issue if the formula used to calculate failed to account for a grace period granted for some extenuating circumstances. In that case, Lee Learner might contact Fundme and ask the payment ops team for adjusting a payment or receiving a refund. Ops teams can process this easily while maintaining the integrity of the data, since all payments sent or received from a counterparty are easily captured and displayed. In the future, accountants and auditors won’t be left wondering about a refund, since the information explaining it can be captured directly tied to the cash transfer on Fundme’s bank statement. 


Looking for more?

This post laid out a simple architecture for payment ops at an Income Sharing Agreement company, but it lays a strong foundation from which to build. For any specific questions, or to see how Modern Treasury can help make you company’s payment ops simple, scalable, and secure, request a demo of Modern Treasury today.

References

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.