database and to make a model from it in our project is to
M. Herceg, S. Kovai, E. uli and M. Redipai
Database First vs. Code-First Approach in Software Design Workflows
Abstract A number of issues that present both of the
common approaches in software design workflows are being
described in this paper, as well as the preferences of choosing
either of those for software development circle. Entity
framework is a common-used technology that saves developers
time for writing data-access code, avoids contacting the
database directly, and it usually uses four different approaches
depending on whether you use an existing or a new database
for your project. This paper is being focused on advantages and
disadvantages of the two approaches and give the key points
for making preferences when staring a new project of moving a
legacy project to a new database. This paper tries give new
developers aspects to choose which approach to use for their
future software development, as well as to give insight why and
when to use any of the approaches mentioned above. It will also
give a short insight of a new Entity Framework version 7 and
future vision for entity framework development.
I. INTRODUCTION
This paper gives an overview and critical points
developer is thinking of while choosing the way he/she
would approach to the development of a software product. In
the first part database first approach will be explained as well
as the pros and cons of using it when developing a software
product. In the following chapter code first approach is
explained and compared to the database first approach. User
is directed which approach to use based on his/her
preferences in developing a product as well as his/her
preferences about product release. Last part explains other
approaches, more precisely - design first approach which
focuses on owner(s) of the product and their preferences as
they take an important part in the development cycle of the
product. This paper hopes to help the decision-making
process developer has to go through when starting the
development cycle of his/her software product.
II. DATABASE FIRST APPROACH
As most of the technologies are first invented to save
developer's time by sparing them extra coding, the entity
framework is invented for the exact same reason. Entity
framework is Microsofts ORM (Object Relational Mapper)
which automatically generates model code to be used in the
application. Database first approach allows us to reverse-
engineer a model from an existing database, meaning
building a conceptual model from a database already made in
SQL. This model is generated as an .edmx file and the
classes that we need in our application are automatically
generated from this .edmx file. The way to use the existing
M. Herceg, Faculty of Information Technologies, "Demal Bijedi"
University of Mostaru, University Campus bb, 88104 Mostar, Bosnia and
Herzegovina (phone 381-36-281040, e-mail: marija@fit.ba).S. Kovai,
University Information Centre, "Demal Bijedi" University of Mostaru,
University Campus bb, 88104 Mostar, Bosnia and Herzegovina (phone: 381-
36-281040; e-mail: salko@unmo.ba).
E. uli, Faculty of Information Technologies, "Demal Bijedi" University
of Mostaru, University Campus bb, 88104 Mostar, Bosnia and Herzegovina
(phone 381-36-281040, e-mail: eminao@fit.ba).
M. Redipai, Faculty of Information Technologies, "Demal Bijedi"
University of Mostaru, University Campus bb, 88104 Mostar, Bosnia and
Herzegovina (phone 381-36-281040, e-mail: muharem@fit.ba).
simply add an ADO.NET Entity Data Model to it as an item.
Then the technology maps the database objects to entities
and represent them on the connected diagram that can be
updated with the changes needed in the database.
The conclusion of the Griffin's comparative research on
Entity Framework vs. other traditional approaches can be
summarized as follows:
It greatly reduces the time spent writing code for the
applications data access layer, makes managing database
relationships and data objects easier, provides a level of
abstraction to isolate the database from the developers
application, and translates queries at runtime allowing
minimal code impact with regards to database storage
changes. (Griffin, 2013)
Some authors call this approach Model first, even though
the model (.edmx) is generated from the database. Database
first approach with entity framework is easy to use and quite
logical when you have an existing database, but Oliveira
suggest five possible scenarios when you'd prefer using this
approach over other approaches for application development.
These, according to Oliveira would be when you have:
1. Long lasting databases with stable schemas
2. Changes to database and model are incremental
3. You want to be able to see your model in one diagram
and update from there
4. You can divide your model to non-overlapping
diagrams
5. You have a database designed by DBAs, developed
separately or if you have existing database (Oliveira,
2016)
Despite its advantages as using an existing database,
stored procedures and avoiding data loss new Entity
Framework 7 does not support .edmx approach or database
first-approach, but it rather introduces solely code-first or by
some authors called code-based approach (since it can also be
applied to existing databases so it'd be somewhat confusing
and unfair to call it code-first). In the database first approach
all entity classes inherit the EntityObject class and as such,
will always be tightly coupled to the Entity Framework.
More on Entity Framework 7 is being introduced in chapter
2.
III. CODE FIRST
Possible scenarios for using code- first design would be
when:
one prefers pure coding over design.
full control over database design without knowing too
much SQL is preferred.
new database is to be created and theres no existing
one.
developer wants to cope with all modern application
projects.
 Code first approach is best suitable and used if you have
already created domain classes, as with this approach you
don't have to worry about auto-generated code. In this
approach your code defines and creates the database. A
typical entity class is given below which maps to the database
objects is shown below:
public class Student
{ coding skills.
public int StudentId { get; set; }
public string StudentName { get; set; }
public DateTime StudentBirthDate { get; set; }
} traditionally way. This approach offers better opportunity to
Two other steps to successfully generate a database is to
create a custom context extending the DbContext class and to
make a connection string in the configuration file. In this
approach EF does not use any kind of configuration file to
store the database schema, because the mapping API uses
these conventions to generate the database schema
dynamically at runtime. The Code First Conventions are used
to discover how the conceptual model should be built and
mapped and how to create a database storage model. These
Conventions include Primary Key, Relationship and Complex
Type Conventions and Type Discovery.
Code first does not have a diagram showing the
connected entities, nor some other visualization tool, which
is the sources of many complaints on Entity Framework 7.
Code first is usually preferred when developers have no aim
in dealing with the database, and when the database can be
changed often, when the database is short-lived and when
scalable applications are being used.
Mombrea claims three exact and most important reasons
for using code first approach (with creating a new or using
the existing database) instead of other approaches in
application development when using entity framework.
Those according to Mombrea would be:
1. less cruft, less bloat sometimes for an extra
functionality when using DB-first approach you need
to extend the model class, and eventually you end up
extending everything. Additional files are burden
too.
2. Greater control - you only have what you created.
You can control both your code models and your
database design. Your responsibility is much higher,
but its the price of more control.
3. Database version control - by version controlling
your source code you're helping to version your
database. (Mombrea, 2014)
IV. OTHER APPROACHES
Of other approaches used in software development
authors often refer to a design first approach as a new
perspective in creating APIs.
First thing that we think about when we mention design-
first approach is that we are working something backward.
Design-first approach starts with a design thinking approach
to creating an application, then proceed to a prototype,
multiple iterations based on real feedback, and finally a top-
down approach to solving the coding problems.
Building application in a traditional way by coding first
can make a lot of people with good idea to give up before
they even try to learn things prior to design.
Starting with design first can motivate people with good
idea to start some project and learn something more about
programming later. If someone doesn't have skill to set code
alone, then he will be able to team up with someone who has
If someone with good idea and poor knowledge about
programming starts with design-first approach it is more
likely that he will build application at the end in comparison
with someone who starts to build an application on
design really good solutions for real-world problems
(Douglas Kiang, 2015)
Someone who is end-user with good idea can start with
design-first approach and build design which other end-users
will also be familiar with. Sometimes we have good software
solution when we consider from IT side, but when we
consider it from end-user side, it can be hard to use. This
approach can avoid problems like that.
The design-first approach focuses on the human, without
influence from the data or the user requirements until a
visual concept is developed. This approach offers a fresh
perspective that can enhance or be an alternative to
traditional visualization approaches, particularly for difficult
visualization problems.
We know that traditional visualization process begins
with the data. There are many definitions of data, but in this
context, we refer to raw bits, bytes, text, and images typically
used in analytics rather than higher-level representations
The relationships provided by the analytics are matched
to visualization techniques suited to show those types of
relationships. The final visualization is a combination of
visualization techniques, analytics, and data that support
human tasks. This data-first approach is the most common
and accepted practice for visualization.
Visualizing particularly large and complex datasets for
analysis is one of several current research challenges in the
visualization community (Theresa-Marie Rhyne, 2015)
Visualization and teaming up with different software
development skillsets helps build more useful products and
helps solve problems easier.
The benefit of the design-first approach is that it can
lead to new visualization innovations that are not
constrained by data. Provocative visualization concepts that
are not yet possible may drive future technology
requirements. This approach is opportunity for innovation in
that new data and analytic technology requirements that
solve user needs may be derived directly from the design. We
believe there are classes of problems for which the design-
first approach will yield better results than traditional
approaches. The design-first approach is especially
promising for new problems that do not yet have strong
visualization solutions and it is also a great way to re-
examine visualization problems that have been investigated
for years without a suitable solution or significant
improvement. (Theresa-Marie Rhyne, 2015)
 For example, in most government organizations non-IT
people use client-server information systems which are very
hard and complicated for them to use. Design-first approach
maybe can help to re-examine visualization problems and
offer suitable solution and significant improvement.
If we make comparison to other approaches we can
conclude that database-first approach is fastest way to build
application and code-first approach is for larger long term
projects because provides a better control for making
efficient program. Design-first approach may be slow
solution because we may not be able to implement every
feature that we like in that design, and we can get stuck in
code doing that. (Mombrea, 2014)
When time is not important with design-first approach
we can implement some new ideas, and explore new
technologies easier. As we have said it is good approach for
re-designing some useful applications with poor design, and
good approach to use in educational purposes because it can
easily stimulate students to get involved, build teams and
learn new things.
When talking about collaborative design first approach
using simple markup authors often suggest a platform called
Swagger. According to a wide usage over last years and their
official page Swagger is an open source framework backed by
tools that help to design, build, document and consume APIs.
1
A tool called Swagger Editor, for example is one of the core
tools behind that offers instant visualization of the code
behind as showed in the following photo:
more abstraction. Also, if you want minimal code impact
with regards to database storage changes its natural to
choose database first approach.
Using code first approach is more preferable if you want
more control over your code and your databases as well as
more control over database versioning and more coding over
design, in the end.
Using design first approach helps to motivate children to
learn more about programming as well as to help people
without necessary coding skillset to team up with ones that
do to solve problems together and build meaningful apps
and software products.
REFERENCES
[1] Griffin, C (May 17th, 2013) A Comparative Look at Entity Framework
Code First, La Salle University Digital Commons, La Sale University,
p.8. Retrieved on Sep 10th, 2016. from
http://digitalcommons.lasalle.edu/cgi/viewcontent.cgi?
article=1010&context=mathcompcapstones
[2] Oliveira J. (Sep 2nd, 2016) Database or Code First Approach -
Developer's Vision, retrieved on Sep 10th, 2016 from
https://www.linkedin.com/pulse/database-code-first-approach-developers-
vision-jader-oliveira?trk=eml-b2_content_ecosystem_digest-
recommended_articles-111-
null&midToken=AQGJ6egiz_k4GA&fromEmail=fromEmail&ut=0iYu
mb-pqSHDo1
[3] Mombrea M. (Feb 14, 2014) 3 reasons to use code first design with
Entity Framework, Retrieved on Sep 28th, 2016 from
http://www.itworld.com/article/2700195/development/3-reasons-to-use-
code-first-design-with-entity-framework.html
[4] Theresa-Marie Rhyne (Feb, 2015) A "Design First" Approach to
Visualization Innovation, Retrieved on Sep 28th, 2016 from
https://www.researchgate.net/publication/270758644_A_Design_First_A
pproach_to_Visualization_Innovation
[5] Douglas Kiang (Nov 6, 2015), Coding by Design: A Design-First
Approach Retrieved on Sep 28th, 2016 from
http://www.edutopia.org/blog/coding-by-design-first-approach-douglas-
kiang

Figure 1 Swagger editor with instant visualization

APIs are often designed and documented after theyve been

development, Swagger is one of the tools that help to turn
the process around, to start first by designing the APIs using
simple markup.

V. CONCLUSION
In order to help developers first steps in creating a
successful software product while maintaining control over
database(s) and/or code this paper gave an insight to various
approaches that are available to the developers. Even
though, this paper mostly focused on traditional
approaches database first and code first approaches, new
approach is also introduced here called design first
approach.
Using database first approach is tightly coupled with
Entity Framework, and is often chosen when you have
existing databases created by DBAs with stable schemas and
1 http://www.swagger.io/