The short version: your data is always yours.
Every clause below fits in a sentence or two, because an agreement you cannot read is not protecting anybody. This is what you agree to when you start a plan.
- 01
What you're buying
There are two ways to work with us and you can buy either one on its own. You can keep us on retainer, which is our time, on hand, pointed at whatever you need. Or you can have us build software, which runs in stages: a prototype you can try, then a production build we scope and quote when you want to own it, then us running it for you. Plenty of clients end up doing both, and nothing here requires you to.
Every published number is on our website before you ever speak to us, and none of them move because of who is asking.
Professional help starts at $400. A Working Session is $400 one time for two hours, with no retainer and no commitment. Standing retainers come in three published sizes: a Quarterly Retainer at $500 a quarter carrying four hours, a Monthly Retainer at $500 a month carrying four hours, and a Working Retainer at $1,000 a month carrying ten hours. Larger retainers are available on request. The retainer is covered in its own clause below.
The prototype is $500, one time. It buys a working application built from your real data, hosted at an address we provide, live for thirty days from the day we first demonstrate it to you. It carries no term and no monthly bill, and you are not obligated to anything past that one-time price. We keep it to one fixed price on purpose, because its only job is to let you try the idea before you decide whether to own it.
Telling us what you want costs nothing. The online build form is free to fill out and commits neither of us: we read it, tell you what we would build and roughly what it would cost, and you are charged only after you have told us to go ahead. The same is true of the conversation that comes before it. Nobody is billed for describing a problem to us.
Even then, nothing is billed in advance of the work. Once you tell us to go ahead we build the prototype, usually within about a week, and demonstrate it to you before any invoice exists. It is invoiced after that first demo. If we never deliver one, you are never billed. Until that invoice is paid we may keep the prototype behind a login or a payment screen. You will have seen it work; what we hold back is putting it into use before it has been paid for. Your thirty days start the day of that demo and run from there, because the prototype is hosted and costing us money from the day it is built, whether or not it has been paid for.
The production build is what you own: hardened for traffic, monitored, backed up, and yours. We quote it against its size once the prototype has shown us the shape of the job. What moves the number is how much the application does, whether it lives on your own domain with a database dedicated to you and sign-in and email under your name, how much messaging, storage, and traffic it carries, and whether it has to meet healthcare or financial compliance. A single simple flow sits at the low end; a marketplace with multi-party payouts sits at the high end. Your actual number is in your order before any of it starts.
Running it, once it is live, is the infrastructure it actually uses passed through at what it costs us plus a flat 20 percent for managing it. That covers hosting, your database, storage, background jobs, email, monitoring, nightly backups, security patches, maintenance, and bug fixes at no charge. There is no flat platform fee and no monthly minimum: you pay for what your application runs on, itemized.
If the application collects money, that is priced separately as a share of what runs through it, agreed in your order, and it is covered in its own clause below.
Terms differ by what you have bought. A standing retainer carries a six month commitment. A Working Session and the prototype carry no term. Once an application goes live in production it carries a twelve-month term, starting the day it goes live rather than the day you sign this. Everything before go-live on a build is month to month: if you decide mid-build that it is not working, you give thirty days notice and owe nothing beyond the work already done and the deposit terms in the production-build clause below.
The reason a term exists at all is that a live application is something other people depend on, and the term is our commitment to keep it up and stable for them. When a term is up, it renews automatically for another twelve months. Thirty days written notice before the renewal date stops it instead of renewing: no early termination fee, and no window to miss.
- 02
The retainer, and what you can point it at
A retainer buys our time and attention for a period, and you decide what it is spent on. Point us at software, data, a website, a spreadsheet, a vendor, a device, an account nobody can get into, a file nobody can open, or a decision you would rather not make alone. If it is in front of you and it is technical, it is ours. We publish no list of what a retainer excludes, because we do not keep one.
You do not have to arrive knowing what the problem is. Working out what something actually is, and whether it is worth doing at all, is part of the time you are buying, not something billed before it.
Each size carries an amount of time per period: 2 hours one time on a Working Session, 4 hours a quarter on the Quarterly Retainer, 4 hours a month on the Monthly Retainer, and 10 hours a month on the Working Retainer. Hours can be pointed at expanding a production build, adding features, or day-to-day troubleshooting. Unused hours on a retainer roll forward one period, a month on anything billed monthly and a quarter on anything billed quarterly. They do not accumulate past that, and they have no cash value if you cancel. Larger retainers than the published sizes are available on request.
A Working Session is one time, with no commitment. Standing retainers are purchased in six month commitments, billed at the published cadence (quarterly or monthly). When a six month term is up it renews for another six months unless either of us gives thirty days written notice before the renewal date. During a term you can move between published sizes on thirty days notice; moving up takes effect on the next billing date. Ending a retainer early means paying out the periods remaining in the commitment. If you also have a live application with us, changing or cancelling a retainer does not touch that application's twelve-month term, and cancelling a retainer never affects hosting, monitoring, backups, patching, maintenance, or free bug fixes.
If something you want is bigger than the time your retainer carries, we tell you before we start, in writing, and you decide. Sometimes the answer is to move up a size for a month or two, sometimes it is to wait for next period's hours, and sometimes it is a production build with its own quote. Nothing reaches an invoice that you have not already agreed to.
A retainer does not include hosting or infrastructure. If work we do on your retainer results in something that has to run somewhere and cost something every month, we tell you what that costs before we switch it on, and it is billed the same cost-plus-20-percent way as everything else.
- 03
The production build, and how it's paid
The production build has a real up-front cost the prototype never did, so it is paid against milestones rather than after the fact. You can pay the quoted amount one time, or spread it across monthly payments; either way the specifics are written into your order before work starts.
Because the build ties up real time from the day it begins, a deposit of 25 to 30 percent of the quote is due before we start, and it is credited against the total rather than added to it. The exact figure is in your order.
If you cancel a build in progress, or you stop making agreed payments, the balance for work already done and work already scheduled becomes due at that point. We will not invoice you for work we have not started, but a half-finished build we set aside for you is time we cannot get back, and this clause is how that time is covered. We would always rather talk about it first, and in practice the reason a build stalls is usually something we can fix.
None of this applies to the prototype or to a retainer, neither of which carries a deposit or a schedule.
- 04
What each stage buys
Every stage of a build, including the prototype, includes building the application, hosting it, monitoring it, backing it up, patching it, maintaining it, and fixing it when it breaks. We size what it runs on to what the application actually needs, so you are not buying a tier of infrastructure you will not use.
What differs is how far it is built and where it lives. The prototype is fast and unhardened and lives at an address we provide. The production build is hardened for traffic, and it can stay at an address we host or move onto your own domain, under your own name, with a database dedicated to you and sign-in and outbound email coming from you. Which of those you want is part of what we scope and quote, because a move onto your own domain is real one-time work and the running cost follows the infrastructure it needs.
If you do not already have a domain when you want one, we will help you find and register it, and we cover the registration up to $25 a year for as long as your application is live. A domain that costs more than that is still yours to choose; we bill you the difference at cost with nothing added. Either way it is registered in your name, it stays yours, and it leaves with you.
Build time after go-live comes from a retainer, the same ladder described above. You can move up or down on thirty days notice within a commitment, and we will tell you plainly when what you are asking for does not fit the size you are on, including when the size you are on is more than you need.
If a prototype lapses at the end of its thirty days, we take the hosted copy down and hold your data for ninety days. Come back inside that window and we turn it back on where it left off.
- 05
Bugs and maintenance are free, changes are hours
If the software stops doing what it was built to do, that is a bug. We fix it, it is never billed, and it does not come out of your hours. That holds no matter which stage you are at.
Maintenance is free on the same basis: monitoring, nightly backups, dependency updates, and security patches are part of running your application, not something you buy separately or spend retainer hours on.
New behavior is a change: a new screen, a new field, a new report, a new integration, or a different way of doing something we already built. Changes come out of your retainer hours.
If something you want is bigger than the hours you have, we quote it in writing before we start and you agree to it in writing. Often the better answer is moving up a size for a month or two instead, and we will say so when it is. Nothing reaches an invoice that you have not already agreed to.
- 06
The code runs in our environment. Your data is always yours.
The application we build runs inside Data Day's own environment and infrastructure, the same one every client runs in. That is what lets us build a real prototype for $500 instead of pricing every proof like a standalone project, and it holds at every stage.
Your data, the records, files, and content that are yours, is always yours, in a format somebody else can read, on request, whether you are still paying us or not.
A portable copy of the production code, one that runs on infrastructure other than ours, is separate, real engineering work: pulling it out of our environment, replacing what it depends on, and documenting the handoff for whoever picks it up. We are glad to do it. We do not price it into any build in advance; we quote it plainly when you ask for one.
- 07
We keep our own tools
The general-purpose libraries, boilerplate, and know-how we bring to every project stay ours, and we go on reusing them for other clients. That reuse is why a prototype costs $500 instead of a month's budget.
Anything of ours that ends up inside your application comes with a permanent, free license to use, change, and sell it as part of your software. Nothing we hold back will ever lock you out of your own system.
- 08
Leaving, and what we owe you when you do
A Working Session ends when the hours are used. A standing retainer runs for six months and renews for another six unless either of us gives thirty days written notice before the renewal date. Ending a retainer during a commitment means paying out the periods remaining. We would rather talk about it first.
For a live application: before go-live, and before each twelve-month renewal, thirty days written notice at any time. No early termination fee and no window to miss. During a term you can cancel by paying out the months remaining. We would rather talk about it first, and in practice the reason a term goes wrong is usually something we can fix.
During those thirty days we hand over your data in a format somebody else can read, along with the accounts and the domain, and we will spend a reasonable amount of that month helping your next developer get oriented. If you also want a portable export of the production code, ask and we will quote it. Handing over your data is something we owe you. The code export is separate work, and we price it separately.
If you stop paying without notice, we will tell you before anything goes dark, and we hold your data for 90 days after the hosted copy comes down.
- 09
Your material stays yours
The files, data, logos, copy, and records you send us remain entirely yours. Sending them to us gives us no ownership of them, and we use them for exactly one thing: doing the work you have asked us to do.
We will not share your data with anyone outside our team, and we will not use your idea to build a competing product of our own. We would like to show the work in our portfolio someday, but not until you tell us in writing that it is fine.
- 10
How we handle your files
Uploads travel over an encrypted connection, get scanned for malware, and land in private storage that is not publicly reachable. Ask us to delete them and we will, permanently.
As a practical matter, please do not email or upload real records as samples when a stand-in would do the same job: medical records, card numbers, Social Security numbers, student records, or giving records tied to named donors. If your application needs to handle information like that, say so and we will design for it properly rather than you mailing us the real thing.
- 11
If you're bringing us existing code
Some projects start from something you already have: a repository, an export, or an application you started elsewhere. If you send us code, you are telling us you have the right to, and that it is not someone else's paid work you were never licensed to hand over.
We will tell you plainly what we find, including third-party licenses that look like a problem and any passwords or API keys sitting in the code, which you should rotate whether or not you hire us. Reading your code is not a security audit and we cannot promise to catch everything.
- 12
If the application collects money
That is priced as a share of what runs through it, and standard card processing is paid out of that number rather than billed to you on top. We do not publish one rate for it, because a checkout running a hundred small sales a day and one running four large invoices a month are not the same job and should not carry the same number. Your share, and any per-transaction minimum that goes with it, is written into your order before a card is ever taken, and it does not change without both of us agreeing in writing.
We handle the setup: the accounts, the verification, the processor, and the wiring. You are not expected to do any of it yourself.
Fees charged directly by Apple or Google on in-app purchases, chargeback fees, and the extra cost of international cards and currency conversion are not something we can absorb, and they pass through at cost.
This applies where our application is what takes the payment. If your customers pay through a system you run yourself, there is nothing passing through ours to share, and running your application is just the infrastructure cost plus the markup.
The share is written into your order before anything starts. Either of us may end the arrangement at a renewal date on the same thirty days notice that governs everything else here.
- 13
Partnership builds
Occasionally we build something with you rather than for you: a product the two of us own together and sell to other people, where we take a share of what it earns instead of billing you for the work. That is a separate written agreement, not this one, and no work starts before it is signed.
A partnership covers a new product only. It gives us no stake, claim, or interest of any kind in the business you already run, and nothing in this agreement or that one changes who owns your existing company.
There is no published price for this because there is no standard arrangement. What each side contributes, how revenue is divided, who owns the code, what happens if either of us walks away, and what happens if it fails are settled in writing in advance, in plain language, before either of us spends a day on it.
We can only carry a small number of these at a time, so we say no to most of them. Being told no costs you nothing and does not affect anything else you buy from us.
- 14
Platform costs, and how we bill them
Keeping a live application running is the infrastructure it actually uses, passed through at what it costs us plus a flat 20 percent for provisioning, monitoring, and managing it. There is no flat platform fee on top of that and no monthly minimum: you pay for what your application runs on, and the markup is how the human time that watches it gets covered. Some applications run for less than twenty dollars a month. Others are considerably more, and which one yours is depends on what it turns out to do.
We will not know your number before the prototype has been live for its thirty days, and we will not pretend otherwise. You get the number in writing before anything switches on.
Some applications need paid infrastructure beyond the basics: high-volume email or text messaging, heavy storage or bandwidth, a third-party service that bills by use, or a premium platform tier your build specifically requires. When that happens we set it up in accounts that belong to you, we watch what it costs, and it flows through the same cost-plus-20-percent as everything else. Every charge is itemized on your invoice, we tell you before we stand up anything new that has a cost, and you can take the accounts with you whenever you leave.
- 15
What we promise, and what we don't
We promise the software will do what we agreed it would do, and that we will fix it when it does not. We answer quickly because that is the job. We would sooner keep you posted on what is happening; a stopwatch is not the relationship we want. If you need a written service level with remedies spelled out, say so and we will write one into your agreement.
Beyond that the software is provided as-is. Whatever happens, neither side owes the other more than the total you have paid us in the preceding three months, and neither side is liable for lost profits, lost data, or indirect or consequential damages. That cap runs both directions.
- 16
How we build
We use modern tools as part of how we build. A person directs the work, reviews everything before it reaches you, and stands behind what we deliver.
Your files and your data are never used to train anyone's model.
- 17
If we ever disagree
Texas law governs this agreement. Before anyone involves a lawyer, we both agree to get on a call and try to sort it out like adults.
If a clause here turns out to be unenforceable, the rest of it still stands.
Written in plain English on purpose. It’s a real agreement, but it isn’t legal advice, and we’re not your attorneys. If your situation is complicated, have someone who does this for a living read it first. Submitting the form on the start page records your name, the date, and the version above alongside your answers, and it does not charge you anything. Questions about any clause? Ask us and we’ll answer in writing first.