The First NoCode Platform: Spreadsheet Software

NoCode is not a new concept: the premise of designing tools for nonprogrammers to build and maintain
their own applications without coding has been around for a long time. NoCode is a new name for an
old concept. Some of its older names include Visual Programming and Rapid Application Development –
sound familiar?

At a minimum, a NoCode platform should be able to incorporate building a user interface, data
management, and handling business logic without coding. Based on this definition, the very first
platform that checks all these boxes are spreadsheet software.

Wikipedia defines spreadsheets as “a computer application for organization, analysis and storage of data
in tabular form”. VisiCalc, release in 1979, was the first spreadsheet software available on
microcomputers. Subsequently, Lotus 1-2-3 was released by IBM in 1982. Microsoft released the first
version of Excel 1.0 in 1985 for Mac, and then two years later, Excel 2.0 was released for Windows.

Today, Microsoft Excel is by far the most widely used spreadsheet software in the world. It also includes
the widest array of features, often setting the standard for spreadsheet software across the industry.

User Interface

The ability to create user interfaces is one of the primary requirements of any NoCode platform. Excel’s
grid-based interface provides a wonderful resource towards this end: in its simplest form, you can utilize
cells to represent textbox and dropdown controls for user input, or labels for displaying information or
calculated output. By simply resizing row and column dimensions or merging cells, you can create
complex user interfaces tailored for your users.

Excel’s built-in validation feature allows you to implement rules to limit user entry for specific data
types, such as integer, decimal, date, time and text. You can also validate numeric data values by
enabling minimum and maximum values, or limit text entry through minimum and maximum character
counts. You can configure Excel to display custom warning/error messages when the user submits
invalid data entries, or enforce data selection through the list feature to turn cells into dropdown
controls.

Excel form controls further enhance the user interface capabilities, allowing users to build radio buttons,
check boxes, list boxes, and sliders. Form controls float on top of Excel’s grid and allow you to bind form
control selections with cells to enable integration with worksheet formulas.

By pairing these controls with features like hidden worksheets, rows and columns, locking formulas
cells, hiding formulas, and disabling the top menu, you can make a spreadsheet file appear very similar
to a conventional application interface.

Microsoft introduced Visual Basic for Applications (VBA) in 1993 with Excel 5.0. It was a revolutionary
feature to enhance the capabilities of Excel, empowering users to implement rules that they could never
develop with the built-in features. One of those capabilities is creating more advanced user interfaces by
binding controls (ActiveX) to VBA code. However, VBA is a scripting language which requires some level
of programming expertise.
Business Logic

Implementing business logic is the most powerful aspect of Excel from a NoCode perspective. Excel
supports over 450 worksheet formulas in various categories, including statistics, database, and finance.
This allows Excel users to implement extremely complex business logic solely worksheet formulas.

Microsoft also further enhanced Excel’s calculation capabilities by introducing Goal Seek and the Solver
toolbox, which allow users to implement iterations against worksheet formulas without requiring any
coding. Functionally, they act as loops to solve various optimization problems.

Running simulations is another common use case for business users, which entails looping through the
core calculations of the model repeatedly, typically consisting of thousands of iterations. Microsoft and
its partners developed Excel add-ins for Monte Carlo simulations to help users achieve this functionality
without any programming.

User Defined Functions (UDF) are another way to extend the business logic capabilities of Excel by
writing custom formulas in VBA. While UDFs are often developed by people with VBA expertise, regular
users can consume them in their files by simply adding those functions.

Microsoft also created an ecosystem around Excel by allowing developers to build add-ins for Excel to
enhance its capabilities, including custom formulas that target specific business segments. For example,
you can find add-ins that are developed for specialty engineering calculations or optimization problems.

Using all of these tools, Excel users have been able to implement the necessary business logic within
their user interfaces to develop fairly complex applications without any coding. All they need is to
understand Excel’s formula syntax and the arguments of the specific formulas. No other NoCode
platform comes anywhere close to Excel in implementing complex business logic.

Data Handling

Handling data in Excel is a bit tricky when comparing it against databases in traditional applications. In
its simplest form, a database is a structured set of data. It is often represented in a table-like format,
with named columns representing individual pieces of data and rows representing distinct records.

In most applications, databases consist of multiple tables that are joined to optimize and simplify data
models. You can flatten most multi-table databases into a single table but end up repeating a significant
amount of data.

There are two primary uses for data within an application. The first one is reference data that is queried
and consumed by the application. For example, if you need to calculate shipping costs in an invoice
application, you can query data from a database table of shipping costs by zip code to dynamically
identify the cost of shipping a parcel based on a zip code that is entered in a user interface. This type of
data management is easily handled in Excel by embedding the entire data set in a worksheet and
retrieving matched data with formulas like VLOOKUP.

The second scenario is a bit more complex: data collection. This is where user-entered data is captured
and inserted into a persistent store as a new record. This type of usage is more difficult to mimic in Excel
without using Forms or VBA to tie the persistent store to the user interface.
In most cases that resemble the scenario above, users store and track data in simple tables by entering
data directly into the grid. Each new row constitutes a new record in the data set.

You can also enable the built-in Forms feature to add new data or edit existing saved data. You can
manage and delete data through a popup form. This provides a simpler interface and prevents users
from manipulating data directly in the grid, which can often lead to mistakes (e.g. overwriting formulas
fields, entering data into incorrect columns).

Distribution and Collaboration of Excel Applications

Excel users have been building NoCode applications since its infancy, but one of the biggest challenges
remains the distribution of those applications. Before the Internet, those applications were typically
distributed on physical media (e.g. floppy disks) to the respective end users. Later, this distribution
widely moved to online means, such as emails, network drives, or – eventually – cloud based file storage
providers.

Naturally, these applications require Microsoft Excel installed on the local computer. Unless VBA is used,
there is little-to-no compatibility issue running them across various machines and Excel versions.
Microsoft has been extremely effective at ensuring backwards compatibility with their formulas, even
continuing support for widely unused early formulas that have been predominantly replaced with more
powerful alternatives (e.g. LOOKUP vs. VLOOKUP/XLOOKUP). As a result, you can still load and execute
an Excel file that was built 20 years ago.

These Excel applications are still primarily desktop applications with no connectivity to a centralized
database or repository, unless VBA is used to achieve this integration (i.e. a LowCode implementation).

Security of Excel Applications

Security is one of the biggest problems with Excel applications, since there is no way to entirely secure
an Excel file.

You can encrypt the file with a password to add a layer of protection against unauthorized access.
However, this approach begins to get dicey when you provide end users with access to the application,
since that results in a proliferation of the credentials. Even without exposing the credentials, encrypting
the entire workbook can still be vulnerable to the brute force password hacking, since there is no lock
against failed password attempts.

You may also want to protect your business logic or data from the end user by making only parts of the
application accessible. This article explains various methods to achieve this, but each of these
approaches still includes fairly straightforward workarounds that can leave the workbook exposed.

Data Collection

Today, many businesses still use Excel for data collections purposes, particularly when there are a
significant amount of inputs or calculations involved.

The screenshot below shows an Excel-based form that contains several hundred inputs. Implementing
this form in a web-based NoCode form builder can be fairly time consuming, which is why many
businesses still find it more efficient to utilize Excel for these types of data collection.
Excel is also commonly used for data collection when there are calculations involved. The example
below is a spreadsheet that collects financial data from businesses and combines it with various financial
calculations. Building this type of data collection application using other NoCode platforms would have
been extremely difficult since it would require recoding the complex calculation logic that is built into
these formulas.

Calculators

Consumers and businesses have become well acquainted with the concept of Excel-based calculators.
Often, they provide an incredibly effective means of computing and conveying complex calculations in a
comprehensible way.

For example, there is no shortage of “lease versus finance” Excel templates available that compare the
pros and cons of leasing versus buying a car. Similarly, there are dozens of Excel templates that break
down mortgage rates into payments over time, explain the likelihood of getting a loan based on a series
of financial factors, and highlight the costs associated with acquiring a home.

Almost every business builds similar Excel calculators for their needs, whether that entails sales quoting,
price estimation, cost analysis, or any other computational model.

The ability to create and update data sets (e.g. pricing and cost lists), along with the ease of integrating
that data with worksheet formulas, makes Excel the most efficient platform to build logic-heavy
applications for businesses.

Reporting

The ability to load, manipulate, and present data is one of Excel’s core features. Businesses have been
using Excel for reporting purposes for decades. You can load raw data into Excel, use built-in features to
transform the data into a more understandable format (also known as data wrangling), and represent it
in a simpler, condensed, and interactive view. Businesses often build reporting applications in Excel
where they can periodically update raw data to produce these reports automatically. Managers are
accustomed to seeing these reports in Excel. In fact, most of them prefer these reports in Excel format
so that they can interact with them.

Excel has a vast array of features that deal with data. There are text formulas like FIND, LEFT, RIGHT, and
SUBSTITUTE (and the more advanced Power Query), which allow you to manipulate and transform text
content. Then, the Pivot Table or Power Pivot features can be used to aggregate complex data tables.
Finally, Excel’s rich charting support, combined with filters and slicers, allows you to present the results
in an interactive manner.

Almost every software product that deals with data has an Excel (or CSV) export feature. Why? Because,
even if that software has built-in reporting features, users often want to bring that data into Excel (or
their preferred spreadsheet software) to perform their own analysis and reporting. People’s familiarity
and comfort level with Excel when it comes to dealing with data is unparalleled.

Power of a User Base of over 1 Billion People

Despite the inherent issues with distribution, collaboration, and security, spreadsheets are the first and
most widely used NoCode platform in the world.
Excel is a software that is installed on a vast majority of business and personal computers worldwide.
Free versions of online software products like Google Sheets, Office 365, and Zoho Sheets are available
to anyone with an Internet connection. Over 1 billion people use spreadsheets worldwide.

The unparalleled reach, ease of use, and familiarity make spreadsheets an ideal first choice for a NoCode
development platform, whether or not end users even know what a NoCode application is. These users
have been building applications with Excel for decades and will continue to do so, despite how many
new and powerful NoCode platforms are available on the market.

Handling Business Logic in NoCode

While there are numerous NoCode platforms for designing and building presentation and data
persistence layers, the market is sparse when it comes to developing intricate and complex business
logic layers. This is likely due to the inherent difficulty in building a system sufficiently robust to handle
the intricacies of any given industry while retaining the simplicity and ease-of-use that makes these
systems popular with non-developers. As a result, most businesses develop this layer of their systems
internally, or – in less critical scenarios – opt to substitute an automated solution with a manual one.

Most modern applications are based on a multi-tiered architecture where the presentation, business
logic, and data management layers are decoupled. This approach allows developers to build reusable
components and enables different teams to work on varying parts of the application.

The presentation layer deals with the user interface, while the data layer handles data persistence, such
as database storage, logging, and analytics. The business logic layer consists of modules that facilitate
the flow of data between the presentation and the data layers. It is comprised of the rules, algorithms,
and calculations that correspond to a set of business requirements.
For example, let’s assume you are building a budgeting application where you aim to (1) collect data
from different departments, (2) store the data in a structured format, and (3) aggregate reports around
the stored data. The business logic handles all the rules and calculations related to that specific
business’s budgeting process. It may also handle the process of aggregating the data into feed reports
that are produced for the management teams. In a traditional coding approach, the business layer is
where developers will often communicate with their business users to understand the requisite rules
and logic.

How Do NoCode Platforms Handle Business Logic?

NoCode platforms are often excellent solutions when it comes to handling the presentation and data
layers. Most NoCode platforms enable users to design attractive and user-friendly interfaces and to
construct data tables with intuitive drag-and-drop components. However, they are not as powerful
when it comes to handling business logic.

Logic in the User Interface

Most NoCode platforms provide some level of logic-building that is baked into the presentation layer,
such as data validation, control interdependency, and customizable attributes (e.g. hiding and disabling
contents).

For example, you may have a multipage data collection application where – depending on how a user
answers a question on the first page – you will want to disable or hide some of the questions on the
second page. This type of UI logic can be handled by generating conditional properties on each input
control.

An example of this can be seen in the following sample life insurance quoting application:

https://calc.spreadsheetweb.com/Designer/a/Life%20Quote

If you answer Yes to the question “Have you ever used any tobacco product?” on the second page and
hit the Next button, a page containing tobacco-related questions will appear. If you answer No, the
entire page with tobacco-related questions will be skipped.

Logic in the Data

Similarly, some NoCode tools provide if-then-else logical blocks, as well as the ability to write
mathematical operations into data fields.

For example, you may have an invoicing application where you calculate a sales tax. You can add a new
data field and write a simple formula (e.g. SalesTax = TotalAmount * 0.06, assuming 6% tax rate). Of
course, if you want to handle location-based sales tax, the equation will get more complicated and you
will have to incorporate other variables, such as the State. You may be able to accommodate this with a
bunch of if conditions and corresponding formulas, but any further complications may make it
significantly more difficult and less maintainable in standard NoCode approaches, defeating the purpose
of using a NoCode platform in the first place.
Workflow

There are also workflow-building platforms that can connect NoCode applications to other services. For
example, you can send data from your NoCode application to SalesForce for your sales team, generate a
Word document in Google Docs, and send that document to a list of email recipients through
Mailchimp. These tend to work seamlessly but they are also typically asynchronous operations, where
the workflow can be configured to trigger every so often. In most scenarios, this type of delay does not
pose a problem; however, if your application requires generating and downloading a document in real-
time (e.g. the user presses a button to generate a document), then that integration may still need to be
built separately.

Everything Else

There are other types of logic that cannot be handled in the user interface, database, or workflow
operations. Just a few examples of these:

Financial models that include recursion

Quoting costs for configurable products

Engineering applications and scientific tools

Product configurators for manufacturing companies

ROI tools

Project cost estimators

Unfortunately, most of the logic that resides in business applications fall within this category. This is
where a different type of approach is needed to handle complex logic without coding.

Using spreadsheet software, business users have been building logic-heavy applications for a long time.
However, spreadsheets are not an ideal NoCode platform for designing user interfaces or data
modeling.

We developed SpreadsheetWeb to empower users to build logic-heavy NoCode applications directly

Building an Insurance Quoting Application

Insurance is a logic-heavy industry. Many insurance operations involve complex business logic and rules,
which makes developing insurance applications more challenging from a NoCode perspective. At the
same time, the insurance industry has a strong reliance on spreadsheets: you can find complex
spreadsheet models used everywhere in insurance companies.
Let’s take the example of an insurance quoting application. Below, you’ll find a simplified rendition of a
quoting spreadsheet. The interface includes five inputs (Name, Effective Date, ER Zip, SIC Code, and
Number of Eligibles) and produces a table of results that list calculated premiums for six health
insurance plans.

There are other worksheets in this workbook that handle calculations and store reference data for
lookups, which is where the business logic resides. There are over 2,000 formula cells representing
actuarial calculations in this relatively simple workbook, which should give you a rough idea regarding
the level of logical complexity that insurance companies require when quoting. Spreadsheet models
with hundreds of thousands of formulas are not uncommon in the insurance industry.

his is just one example of an application built to the specifications of a given business operations in a
given industry. There are a huge number of similar operations that require moderate-to-advanced levels
of logic across a variety of other industries, such as financial services, investment, banking, engineering,
education, and manufacturing. The ability to incorporate spreadsheet-based business logic within the
application development process can make NoCode development much more appealing to businesses
and significantly expand the scope of applications that can be produced without coding.

Logical Functions

If | And | Or | Not

Learn how to use Excel's logical functions, such as IF, AND, OR and NOT.

If

The IF function checks whether a condition is met, and returns one value if true and another value if
false.

1. For example, take a look at the IF function in cell C2 below.

Explanation: if the score is greater than or equal to 60, the IF function returns Pass, else it returns Fail.
Visit our page about the IF function for many more examples.
And

The AND Function returns TRUE if all conditions are true and returns FALSE if any of the conditions are
false.

1. For example, take a look at the AND function in cell D2 below.

Explanation: the AND function returns TRUE if the first score is greater than or equal to 60 and the
second score is greater than or equal to 90, else it returns FALSE.

Or

The OR function returns TRUE if any of the conditions are TRUE and returns FALSE if all conditions are
false.

1. For example, take a look at the OR function in cell D2 below.

Explanation: the OR function returns TRUE if at least one score is greater than or equal to 60, else it
returns FALSE. Visit our page about the OR function for many more examples.

Not

The NOT function changes TRUE to FALSE, and FALSE to TRUE.

Explanation: the OR function returns TRUE if at least one score is greater than or equal to 60, else it
returns FALSE. Visit our page about the OR function for many more examples.

Not

The NOT function changes TRUE to FALSE, and FALSE to TRUE.

1. For example, take a look at the NOT function in cell D2 below.

THE PMT (PAYMENT) FUNCTION FOR LOANS

1. Understand the fundamentals of loans and leases.

2. Use the PMT function to calculate monthly mortgage payments on a house.

3. Use the PMT function to calculate monthly lease payments for an automobile.

4. Learn how to summarize data in a workbook by using worksheet links to create a summary
worksheet.

If you own a home, your mortgage payments are a major component of your household budget. If you
are planning to buy a home, having a clear understanding of your monthly payments is critical for
maintaining strong financial health. In Excel, mortgage payments are conveniently calculated through
the PMT (payment) function. This function is more complex than the statistical functions covered in
Section 2.2 “Statistical Functions”. With statistical functions, you are required to add only a range of
cells or selected cells within the parentheses of the function, also known as the argument. With the PMT
function, you must accurately define a series of arguments in order for the function to produce a reliable
output. Table 9.1.1 lists the arguments for the PMT function. It is helpful to review the key loan and
lease terms below before reviewing the PMT function arguments.
By default, the result of the PMT function in Excel is shown as a negative number. This is because it
represents an outgoing payment. When making a mortgage or car payment, you are paying money out
of your pocket or bank account. Depending on the type of work that you do, your employer may want
you to leave your payments negative or they may ask you to format them as positive numbers. In the
following assignments, the payments calculated using the PMT function will be made positive to make
them easier to work with. To do this, when defining the PV argument (amount of money borrowed) in
the PMT dialog box, a minus sign must precede the cell location or value.

We will use the PMT function in the Personal Budget workbook to calculate the monthly mortgage
payments for a house. These calculations will be made in the Mortgage Payments worksheet and then
displayed in the Budget Summary worksheet through a cell reference link. So far we have demonstrated
several methods for adding functions to a worksheet. The following steps explain a new method using
the Insert Function command for adding the PMT function:

1. Click the Mortgage Payments worksheet tab.

2. Click cell B5.

3. Click the Formulas tab on the Ribbon.

4. Click the Insert Function button (see Figure 9.1.1). This opens the Insert Function dialog box,
which can be used for searching all functions in Excel.

5. In the “Search for a function:” input box at the top of the Insert Function dialog box,
type mortgage payments (see Figure 9.1.2). Note that the current description in the “Search for
a function:” input box will already be highlighted. You can begin typing and the description will
be replaced with your entry.

6. Click the Go button in the upper right side of the Insert Function dialog box. This adds all the
Excel functions that match your description in the “Select a function:” box in the lower half of
the Insert Function dialog box (see Figure 9.1.3). Click the PMT option in the “Select a function:”
box in the lower half of the Insert Function dialog box.
7. Click the OK button at the lower right side of the Insert Function dialog box. This will open the
Function Arguments dialog box.
9. Click the Collapse Dialog button next to the Rate argument in the Function Arguments dialog box. This
will be the first argument defined for the function.

10. Click cell B3 on the worksheet. This is the rate being charged on the loan.

11. Type a forward slash / for division.

12. Type the number 12. Since our goal is to calculate the monthly payments for the loan, we need to
divide the rate, which is stated in annual terms, by 12. This converts the annual rate to a monthly rate.

13. Press the ENTER key on your keyboard. This returns the Function Arguments dialog box to its
expanded form. You will also see that the Rate argument is now defined.

14. Click the Collapse Dialog button next to the Nper argument in the Function Arguments dialog box.
This is the second argument we define in the function.

15. Click cell B4 on the worksheet. This is the term or the amount of time we have to repay the loan.

16. Type an asterisk * for multiplication.

17. Type the number 12. Since our goal is to calculate the monthly payments for the loan, we need to
multiply the terms of the loan by 12. This converts the terms of the loan from years to months.

18. Press the ENTER key on your keyboard. This returns the Function Arguments dialog box to its
expanded form. You will also see that the Nper argument is now defined.

19. Click the Collapse Dialog button next to the Pv argument in the Function Arguments dialog box. This
is the third argument we will define in the function.

20. Type a minus sign −. When defining the Pv argument of the PMT function, any cell location or value
must be preceded with a minus sign.

21. Click cell B2 on the worksheet. This is the principal of the loan.

22. Press the ENTER key on your keyboard. You will now see the Rate, Nper, and Pv arguments defined
for the function.

23. Click the OK button at the bottom of the Function Arguments dialog box. The function will now be
placed into the worksheet. Since we are not paying any lump sums of money at the end of the loan,
there is no need to define the Fv argument. Also, we will assume that the monthly mortgage payments
will be made at the end of each month. Therefore, there is no need to define the Type argument.

Figure 9.13 shows the completed Function Arguments dialog box for the PMT function. Notice that the
dialog box shows the values for the Rate and Nper arguments. The Rate is divided by 12 to convert the
annual interest rate to a monthly interest rate. The Nper argument is multiplied by 12 to convert the
terms of the loan from years to months. Finally, the dialog box provides you with a definition for each
argument. The definition appears when you click in the input box for the argument.
Integrity Check

Comparable Arguments for PMT Function

When using functions such as PMT, make sure the arguments are defined in comparable terms. For
example, if you are calculating the monthly payments of a loan, make sure both the Rate and Nper
argument are expressed in terms of months. The function will produce an erroneous result if one
argument is expressed in years while the other is expressed in months.

Figure 9.1.4 shows the final appearance of the Mortgage Payments worksheet after the PMT function is
added. The result of the function in cell B5 will be displayed in the Budget Summary worksheet.
CALCULATING DEPRECIATION IN EXCEL

A common year-end activity is calculating depreciation expense. Excel offers several functions to
calculate depreciation expense for various accounting methods. while some depreciation functions
require more informatrion, all of excel’s depreciation functions require these three arguments.

Cost: the initial cost of asset. For example, a piece of machinery might cost P110,000.

Salvage: the value of the asset at the end of the useful life. perhaps you can sell the machinery to a trade
school for P10,000.

Life: how long you expect to use the asset.

STRAIGHT –LINE DEPRECIATION

The straight line method is the simplest depreciation method. suing it, the value of the asset is
depreciated evenly over the asset’s useful life. excel offers the SLN function to calculate straight –line
depreciation. Use =SLN ($B$1, $B$2, $B$3).

Some depreciation systems use a half –yuear convention, you only take 50% of the depreciation in year
1 and then take the other half of the year’s depreciation in year n+1 of the useful life. if you use a half-
year convention, you would add a sixth year to the depreciation table, using
=IF(OR(A6=1,A6>$B$3),0.5,1)*SLN($B$1, $B$2, $B$3) as the formula for each year.

Declining Balance Depreciation

It might be more realistic to write off more of the value in early years and less of the value in later years.
In the declining bvalance method, the beginning of the year book value is mul;tiplied byu fixed rate. For
example, in year 1, 20% of P10,000 is P2,000 of depreciation. In year 2, the same 20% is multyiplied by
the reamaining P8,000 of book value to come up with depreciation of P1,600.

The trick to this method is figuring out the correct percentage to use for each year. The 20% used in the
preceding example is not the correct percentage. This calculation involves fractional exponents and a
little algebra. If you use the DB function in excel, however, you don’t have to worry about any of that.

Excel calculates the artes rounded to three decimal places. This rounding to three decimal places causes
the calculation to be off by few dollars at the end of the useful life.

Use=DB(cost, salvage , life, period #) in figure 1. The formula in C6 is DB($B$1, $B$2, $B$3,A6). Excel
multiplies the initial book value by 38.1% to arrive at 41, 910 of depreciation. Note that rounding issues
cause the DB function to overdepreciate by 3.55 ovewr the life of the asset.

The DB function offers an optional fifth argument to deal with partial years if the asset was placed in
service on JUNE 1, you would add a 7 as the final argument in DB to indicate that the asset was in use for
seven months of year 1:=DB($B$1, $B$2, $B$3,A6,/).

DOUBLE –DECLINING BALANCE DEPRECIATION

IN double –declining balance depreciation, the constant percentage rate is estimated at 200% of the
straight –line rate. For a five-year life, the straight-line rate would be 20% . in the DDB function, excel
uses 2x20%, or 40%, of the initial book value of P110,000 to arrive at the P44,000 of depreciation shown
in cell D6 of Figure 1. Because this percentage doesn’t match the DB percentage, the depreciation for
thje final period will always be incorrect. Excel will basically use a plug figure in the final year of a DDB
table to ensure the asset is depreciated to the salvage value.

Use= DDB(cost,salvage,life,period,factor). If you don’t specify the factor, it’s assumed to be @ for
double –declining balance. The formula in D6 is =DDB($B$1, $B$2, $B$3,A6). Since no factor specified,
excel uses 2. To calculate 150DB, you would specify 1.5 as the Factor.

DDB with switching to straight line method

Many systems allow you to switch to straight-line depreciation in later years of the depreciation
calculation. Excel calls this variable declining balance depreciation. The VDB function includes these
arguments:=VDB(cost, salvage, life start period, end period, factor, no switch).

To calculate depreciation for year 1, specify a start period of ) and an end period of 1. To use the double-
declining balance method, specify a factor of 2. The final argument in the formula (no switch) indicates if
excel should swithc methods . if this arguments is false or omitted, excel will swithch from the declining
balance method to a straight-line method when it becomes more beneficial; to do so.

If you express life in days rather than years, you can use VDB to calculate exact depreciation by month
or quarter. If an item with a useful life of three years is placed in service on January 5, 2009, the DDB for
the 26 days of use in Janaury would be=VDB (110,000,10000,3*265,0,26,2,false).

SUM OF YEARS DIGITS

Excel also supports the sum –of –years digits method. say that you have an asset with a useful life of five
years. Add up 5+4+3+2+1 to get 15. In the first year, excel takes 5/15 of the depreciable amount. In the
second year ,excel takes 4/15, then 3/15,2/15. And finally 1/15. In figure 1, the formula in cell E6 is
=SYD($B$1, $B$2, $B$3,A6).

MACRS AND OTHER TAX DEPRECIATION

Note that excel doesn’t offer built –in functions to replace the MACRS tables published by the IRS. To
calculate depreciation for tax purposes, you will often build functions to replicate the tax table.
VLOOKUP or even Choose can be used. For example,=CHOOSE(A^,0.2,0.32,0.192,0.1152,0.1152,0.0576)
will calculate a depreciation rate to match the MACRS five –year property with half-year convention.