DeepSeek locally: integrating an open model into SaaS without paying for APIs

When a SaaS product starts embedding features based on language models, the cost line tied to APIs tends to grow quietly and then suddenly become obvious, because every call pays for input and output tokens and the bill scales linearly with the number of active users. DeepSeek, the open model of Chinese origin that has gained attention in recent months for its ratio of quality to size, offers an alternative to this economic model, since its weights are downloadable and its license allows it to run on your own infrastructure. The question every technical team should ask is therefore not whether DeepSeek is as good as the most celebrated proprietary models, but whether running it locally changes the cost structure deeply enough to justify the additional complexity.

From variable cost to fixed cost

The substantial difference between using a remote endpoint and hosting the model on your own machine is the transformation of a variable cost into a fixed one. With APIs every single request has a price, and however low that price may be the monthly total depends entirely on usage volume, a volume that in successful products tends to grow precisely when margins matter most. Hosting DeepSeek in house reverses this logic, because once the hardware is paid for the additional inference has a marginal cost that tends to zero, with the sole exception of electricity. The break even point exists and should be calculated honestly, since a machine capable of running a large model is not cheap, but for a SaaS with constant and predictable loads that point arrives sooner than one might think, and from there on every additional user does not increase the API bill because that bill simply does not exist.

How it really runs locally

Running a model of this size on your own machine requires a few technical choices that directly affect feasibility. The most important concerns quantization, that is the reduction of the precision with which weights are stored, which allows models that would otherwise be too large to fit into memory while accepting a loss of quality that is often negligible. A four bit quantization lets many DeepSeek variants run on systems with memory in the order of tens of gigabytes, while more aggressive configurations open the door even to consumer grade machines with sixty four gigabytes of RAM. A second decisive element is the mixture of experts architecture, because the most recent models activate only a fraction of their parameters for each generated token, which means that a nominally enormous model can behave, in terms of speed, like a much smaller one. It is this sparsity that makes it possible to obtain tens of tokens per second on local hardware, a speed sufficient for a fluid experience even with long contexts and with tool calling active, provided the correct templates are used and the model reasoning budget is managed carefully.

DeepSeek alongside Claude, Gemini and OpenAI

The comparison with the more renowned models should be made while keeping two dimensions separate, pure quality and the distribution model. Claude, Gemini and the OpenAI models remain benchmarks of excellence as generalists, because they have been subjected to fine tuning so careful that they respond in a balanced way on almost any task, from literary translation to complex reasoning, and their reliability as coding agents is the result of an alignment effort that is hard to replicate. Their limit, from the point of view of someone building a SaaS, is that they live behind a paid API and behind terms of use that no one really controls. DeepSeek plays a different game, because it gives up part of that generalist polish in exchange for the ability to be owned, inspected and executed without intermediaries. For many products this compromise is advantageous, because the real task is not translating poetry but classifying tickets, extracting structured data or assisting with writing code, areas in which a well chosen open model holds its own and in exchange removes the dependency on an external provider.

Other local models to evaluate

DeepSeek is not the only option in a landscape that is rapidly populating with open weights worthy of attention. The Qwen family, developed by Alibaba, covers a range of sizes that goes from lightweight models suited to running on a laptop up to very capable versions, and it is today one of the most solid references for those who want to stay local. The GLM models offer an interesting alternative with good performance on reasoning, while Mistral continues to produce compact and efficient European models that lend themselves well to contained production loads. Google’s Gemma line and Meta’s Llama models complete the picture with mature ecosystems and a wide availability of ready made tools and quantizations. The most sensible strategy, for a next generation intelligent SaaS, is not to choose a model once and for all but to build a layer of abstraction that allows the underlying engine to be swapped, so as to be able to adopt the best open model quickly as the landscape evolves.

When independence is worth its price

The choice to bring inference in house is never purely economic, because it carries a value that does not appear on the API bill, namely independence. Running a model locally means that user data never leaves your own infrastructure, a requirement that in many regulated sectors is not an advantage but a necessary condition. It also means not being subject to rate limits, unilateral price changes or the sudden deprecation of a version on which a product was built. The price to pay is operational complexity, because managing an inference infrastructure requires skills that the API hides entirely, from the choice of quantization to the configuration of the execution graph up to the maintenance of the hardware. For a project at its beginning, with uncertain volumes, APIs almost always remain the rational choice, but for a mature product with stable loads and strict privacy requirements, an open model like DeepSeek run locally stops being an experiment and becomes an architectural decision that pays off over time.