Skip to Main Content

// Service · Software Development

Software
Development

Systems that work. Code that lasts. A team that gives a damn.

Software development isn't about writing code. It's about understanding what you're building, what problem you're solving, and for whom. Then turning that into a real product — with an architecture designed for the load defined in your requirements, and load tests against the agreed targets when they are part of the scope.

Show me how we work

// 01 · The method

There are no shortcuts to good software —
there's a method, and there are production systems you can check.

From early-stage MVPs to core systems that businesses run their daily work through. Every project taught us something about cutting through the noise, avoiding traps, and shipping at the highest level. The projects themselves appear further down this page — with what we built in each.

// Build or adapt

When to build custom software — and when to adapt an off-the-shelf product

Custom development isn't always the answer. The decision comes down to a few questions you can answer before anyone talks about technology.

QuestionPoints to off-the-shelfPoints to custom development
Does your process differ from what the existing product assumes?No — the process is standard and can be changed to fit the productYes — the process is your advantage and changing it hurts the business
How many other systems need to talk to it?Few, and the product has ready integrations for themMany, or internal systems with no standard interface
Who owns the data and the code?It's enough that the data can be exportedOwning the code and data is a requirement — regulatory or commercial
How many external users will touch it?Mostly a small internal teamCustomers, suppliers or partners — and their experience is part of the product
What happens if the product changes its pricing or shuts down?You can move to another product in reasonable timeThe system is the core of the business and single-vendor dependence is unacceptable
  • Does your process differ from what the existing product assumes?

    Points to off-the-shelf: No — the process is standard and can be changed to fit the product

    Points to custom development: Yes — the process is your advantage and changing it hurts the business

  • How many other systems need to talk to it?

    Points to off-the-shelf: Few, and the product has ready integrations for them

    Points to custom development: Many, or internal systems with no standard interface

  • Who owns the data and the code?

    Points to off-the-shelf: It's enough that the data can be exported

    Points to custom development: Owning the code and data is a requirement — regulatory or commercial

  • How many external users will touch it?

    Points to off-the-shelf: Mostly a small internal team

    Points to custom development: Customers, suppliers or partners — and their experience is part of the product

  • What happens if the product changes its pricing or shuts down?

    Points to off-the-shelf: You can move to another product in reasonable time

    Points to custom development: The system is the core of the business and single-vendor dependence is unacceptable

Often the right answer is a mix: off-the-shelf for the standard parts (invoicing, email, CRM) and custom development only for the part that differentiates you. If that's the conclusion, we say so in the first conversation.

// 02 · What we build

What we build

End-to-end engineering — web systems, mobile apps, custom internal tools, integrations, cloud infrastructure, and automation.

  • 01

    Web & SaaS platforms

    Complex web apps, SaaS platforms built from scratch, internal portals, B2B and B2C products.

  • 02

    Mobile apps

    iOS and Android. Native (Swift, Kotlin) or cross-platform (React Native, Flutter) — whichever fits the product.

  • 03

    Custom management systems

    CRM, ERP, BI dashboards. Instead of bending your business to fit the software, the software bends to fit you.

  • 04

    Integrations & APIs

    Connecting existing systems, building public APIs, real-time data sync.

  • 05

    Backend & cloud infrastructure

    Servers, databases, architecture. The part you don't see — and the part that decides whether your system holds.

  • 06

    Automation & workflows

    Connecting systems, eliminating manual work, automating complex business processes.

// Scope boundaries

What software development covers here — and what belongs on another page

For a quote to be clear, it has to be clear who is responsible for what. This is how we split the work:

  • Business systems

    CRM, ERP, portals and management systems built around your process: specification, roles and permissions, an admin interface, reports. This is the core of this service.

    What a system is made of

  • Integrations and APIs

    Connecting the systems you already run, building APIs, syncing data. Our responsibility: the design, the code and the tests. Yours: access to, and documentation of, the systems being connected — without them no estimate holds.

    What to prepare before a quote

  • Backend for an app or an existing product

    Server, database, API and cloud infrastructure — including when the product itself is a mobile app. The app itself, the platform choice and the store launch are described on the mobile page.

    Mobile app development for iOS and Android

  • Taking over an existing system

    A product built by a previous team: mapping assets and access, moving ownership into your name before any fixes, and a defined handover period — and only then maintenance, gradual modernisation or a rebuild, as the diagnosis shows.

    Legacy upgrades

  • Staged delivery or an ongoing team

    A defined scope is delivered in stages with acceptance criteria for each. A product that keeps evolving gets a team at a set capacity that changes with the need — a tech lead, full-stack engineers, UI/UX, DevOps and QA.

    An ongoing development team

  • Process automation

    Repetitive manual work that a system can run end to end, wired into the CRM and ERP you already use — delivered as our separate business-automation service.

    Business automation

// What the system includes

What a custom system actually includes

"A system" means several layers, each of which is work in its own right. This is what appears in almost every project — and what has to be defined before starting.

LayerWhat gets definedQuestion that must be answered before development
Entities and dataWhat the system manages: customers, orders, documents, devices — and the relationships between themWhat is the source of truth for each entity — the new system or an existing one?
Roles and permissionsWho sees what, who can change what, who approves. Admin, employee, customer, supplier, partnerIs there an action that needs two people, and what happens when a role changes hands?
Processes and statesThe lifecycle of each entity: draft → pending → approved → closed, and who moves it between statesWhat happens in exceptions — cancellation, rollback, change after approval?
User interfacesAdmin panel, employee interface, customer or supplier portal, app — each audience gets its own interfaceWhich of them are required in the first version and which can wait?
IntegrationsPayments, accounting, email and SMS, government systems, an existing ERP, mapsWho has access to each external system, and what happens when it's unavailable?
Reporting and operationsManagement reports, audit logs, backups, monitoring, alertsWhich questions must management be able to answer from the system without asking a developer?
  • Entities and data

    What gets defined: What the system manages: customers, orders, documents, devices — and the relationships between them

    Question that must be answered before development: What is the source of truth for each entity — the new system or an existing one?

  • Roles and permissions

    What gets defined: Who sees what, who can change what, who approves. Admin, employee, customer, supplier, partner

    Question that must be answered before development: Is there an action that needs two people, and what happens when a role changes hands?

  • Processes and states

    What gets defined: The lifecycle of each entity: draft → pending → approved → closed, and who moves it between states

    Question that must be answered before development: What happens in exceptions — cancellation, rollback, change after approval?

  • User interfaces

    What gets defined: Admin panel, employee interface, customer or supplier portal, app — each audience gets its own interface

    Question that must be answered before development: Which of them are required in the first version and which can wait?

  • Integrations

    What gets defined: Payments, accounting, email and SMS, government systems, an existing ERP, maps

    Question that must be answered before development: Who has access to each external system, and what happens when it's unavailable?

  • Reporting and operations

    What gets defined: Management reports, audit logs, backups, monitoring, alerts

    Question that must be answered before development: Which questions must management be able to answer from the system without asking a developer?

An entities–roles–permissions table is usually the first document we write together with you. It's short, and it saves most of the arguments later.

// Systems we built

Systems we built — running in production

Software development is measured in products that work, not in decks. Six systems running in production, with what we built in each: on what infrastructure, and where the real difficulty was.

All case studies — products we built end-to-end

// 03 · Technology

We don't fall in love with technology — we pick the right tool for the job.

Our CTO follows the industry obsessively. Every new framework, every approach, every tool — he knows it, tests it, and decides what's actually worth using. More importantly, we know when to use what, and when to walk away.

  • Frontend
    • React
    • Next.js
    • Remix
    • Vue
    • TypeScript
    • Tailwind
  • Backend
    • Node.js
    • Python
    • Go
    • .NET
    • GraphQL
    • REST
  • Mobile
    • React Native
    • Flutter
    • Swift
    • Kotlin
  • Databases
    • PostgreSQL
    • MongoDB
    • Redis
    • Elasticsearch
  • Cloud
    • AWS
    • GCP
    • Azure
  • DevOps
    • Docker
    • Kubernetes
    • CI/CD
    • Terraform

// 04 · How we work

How we work

  1. 01STEP 1

    Discovery meeting

    You explain. We ask questions until we fully understand. Then we ask more. Because if we don't understand the problem, we can't actually solve it.

  2. 02STEP 2

    Architecture & planning

    A detailed plan — what we build, in what order, on what stack, how long. Realistic. No fantasy timelines.

  3. 03STEP 3

    Design & UX

    Before a single line of code, we design the experience. Changing a screen in Figma is cheap. Changing it after it's coded is expensive.

  4. 04STEP 4

    Iterative development

    Two-week sprints. End of every sprint there's something live to see. You don't wait three months to find out where things stand.

  5. 05STEP 5

    QA, launch & beyond

    Testing, deployment, ongoing support. A bug after launch isn't the end — someone handles it, within the scope and hours set in the maintenance agreement.

// Define and deliver

How scope is defined — and what is delivered at the end

A custom system is delivered as your asset: code, data, documentation and access. This is what it looks like from definition to handover.

  1. 1

    Scope document

    Entities, roles, processes, interfaces and integrations — what is in the first version and what is not. This is the document the proposal is based on, and you approve it before we start.

  2. 2

    Working versions, not slide decks

    Each stage ends with a system you can log into and test with real data. Feedback is collected on something that works — not on a description.

  3. 3

    Data migration and onboarding

    If a system already exists — a migration plan is defined up front: what moves, what stays, how it's verified. Training for the people who will use the system is part of the handover.

  4. 4

    Handover: code, access, documentation

    The repository in your name, cloud accounts and domain in your ownership, operating and configuration documentation, and a list of what was built against the scope document. Maintenance after that — under a separate agreement with an agreed scope.

What this looks like in a real project

Michrazit is an example of a two-sided system: a workspace for project owners and a separate environment for suppliers, each with its own onboarding, dashboard and tools on the same backbone; a uniform-spec tender with a live status per bid (pending, received, withdrawn); and whatever locks in the tender flows straight into the contract. The case study describes what was built and how.

The Michrazit case study — a tender platform for private construction

// What drives scope

What drives project scope and budget

No figures here — every system is different. But these are the factors that move scope the most, and most of them can be influenced at the definition stage.

  • 01

    Number of interfaces and audiences

    One admin interface is one project. Admin + customer portal + a field-staff app are three products sharing a backend.

  • 02

    Integrations and the quality of their APIs

    Connecting to a service with a documented API is a completely different matter from connecting to a legacy system with no interface, or one that requires third-party approval.

  • 03

    Migrating data from an existing system

    Historical data, duplicates, fields nobody remembers the purpose of. The messier the existing data, the bigger the job.

  • 04

    Regulation, security and audit

    Privacy requirements, audit logs, dual approvals or data residency add layers that must be built right from the start.

  • 05

    Exceptions in the process

    The happy path is usually the easy part. Cancellations, refunds, changes after approval and edge cases are what fill the scope document.

  • 06

    What can wait for the next version

    The only factor that shrinks scope. A first version that does one thing end-to-end teaches more than one that tries to cover everything.

// When the system serves several customers

When the system serves several customers — what changes

A system built for one customer and a system serving several separate customers (a service model, SaaS) can look identical in the screens. The difference is in the layer underneath, and most of it has to be decided before development — not after.

LayerIn a single-customer systemWith several customers
Data separationAll data belongs to one organisationEvery record, file, search and report is filtered by customer; an architectural decision that is not changed after launch
Roles and permissionsOne set of roles for the organisationRoles inside each customer, plus your own roles (support, admin) with a log of every access to customer data
Plans and entitlementsNone — everyone gets everythingWhat each plan allows (users, volume, features) is enforced in code, not in a document
Billing and subscription statesOne contract, outside the systemTrial, active, plan change, payment failure, suspension, cancellation — a defined behaviour for each state
OperationsBackup and updates coordinated with one customerRestore for a single customer, releases that drop no one, support with clear access boundaries
  • Data separation

    In a single-customer system: All data belongs to one organisation

    With several customers: Every record, file, search and report is filtered by customer; an architectural decision that is not changed after launch

  • Roles and permissions

    In a single-customer system: One set of roles for the organisation

    With several customers: Roles inside each customer, plus your own roles (support, admin) with a log of every access to customer data

  • Plans and entitlements

    In a single-customer system: None — everyone gets everything

    With several customers: What each plan allows (users, volume, features) is enforced in code, not in a document

  • Billing and subscription states

    In a single-customer system: One contract, outside the system

    With several customers: Trial, active, plan change, payment failure, suspension, cancellation — a defined behaviour for each state

  • Operations

    In a single-customer system: Backup and updates coordinated with one customer

    With several customers: Restore for a single customer, releases that drop no one, support with clear access boundaries

At the definition stage we map these five layers with you, and separate what must be built right from the start, what can be manual in a first version and what is deferred. Whether the product is multi-customer at all is decided before any quote.

The full guide: what to define in a SaaS system before development starts

// 05 · Who it's for

Who this is for

  • 01

    Startups

    Need a serious dev team without hiring five engineers. We are your team.

  • 02

    Scale-ups

    Have an internal team that needs reinforcement or specific expertise for a project.

  • 03

    Enterprises

    Need a project taken end-to-end — discovery, build, integration — without chasing four different vendors.

// 06 · Why us

Why us

  • 01

    Experience you can check

    The projects we built appear on this page by name, with what was built in each and a link to the full story. Each one taught us something — you get the result without having to make the mistakes.

  • 02

    Responsibility after launch

    A critical bug doesn't wait for Monday. Support scope, response times and on-call coverage are set in your maintenance agreement — in writing, according to what your system actually needs.

  • 03

    Partnership, not vendor

    We're not an external vendor. We're part of the team. Every decision gets made like our own money is on the table.

  • 04

    Full transparency

    You always know what's happening, when, and why. No surprises. No bullshit.

// 07 · FAQ

Frequently asked questions

  • 01.How long does it take to build a software system?

    It depends on the agreed scope. The orders of magnitude we plan around — not a commitment: a focused MVP — 6 to 12 weeks; a full SaaS platform — 3 to 6 months; an enterprise system with many roles and integrations — 6 to 12 months. The binding schedule is set after discovery and also depends on availability on your side and on your existing systems.

  • 02.How much does software development cost?

    It depends on scope, complexity and how many specialists are involved — not on "hours of code". A precise quote comes after we understand the project in depth. So you arrive with realistic expectations, we published a full cost breakdown by product type (MVP, SaaS, AI + realtime systems) including backend, DevOps and maintenance.

    The full cost breakdown: what software and app development costs in Israel in 2026

  • 03.Do you work fixed-price or hourly?

    Both. Projects with a clear scope — fixed price. Projects that evolve along the way — hourly with a cap. We recommend based on what's right for the project.

  • 04.What happens after launch?

    Maintenance, new features, bug fixes, scaling — within the scope and service hours set in the maintenance agreement. We don't disappear: with OneAI, for example, we worked for five years as the technology partner, through to the acquisition (see the case study).

    OneAI — five years together, through to the acquisition by monday.com

  • 05.Do you work with existing code or only from scratch?

    Both. We can take existing code, audit it, fix it, and continue. Or start clean — depending on what makes sense.

  • 06.Who owns the code?

    You do. No "buts." Your code, your repository, everything is yours.

  • 07.Do you also build mobile apps?

    Yes. Both native and cross-platform. We'll recommend what's right for you once we understand the product.

    Mobile app development for iOS and Android — the full service

  • 08.How do you choose a software development company?

    Check three things: does the team ask about the business problem before it talks technology; are there products it built that you can open and test in production; and who stays accountable after launch. We wrote a full guide, including the questions to ask in the first meeting.

    The guide: how to choose a software house for your next project

  • 09.Do you work remotely or on-site?

    Both models are possible. Most of our projects involve deep integration with your team — over Zoom, Slack, or in person when needed.

Last reviewed:

// 08 · Let's talk

Got a project in mind?

A 30-minute intro call. No strings attached. We'll figure out together if we're a fit.

Straight. To the point. On time.