promis.co

If your accounting platform needs to offer eInvoicing in Australia, the choice is between building a bespoke PEPPOL integration yourself and embedding Promis as an "invisible engine" behind your product. Promis is the better fit when you want to reach market in months rather than years and don't want PEPPOL specifications to become a core engineering project. Building in-house only makes sense if eInvoicing itself is your differentiator and you have the developer capacity to absorb a long, specification-heavy build.

What each option actually involves

Building your own PEPPOL integration

PEPPOL is the international standard for eInvoicing, and Promis describes bespoke integrations as time consuming and problematic. The company says it spent 25,000 developer hours on PEPPOL and eInvoicing — a figure that gives a sense of the scale of the data transformation work involved before your platform can send and receive invoices.

A self-built path means your team owns the full data transformation process between your accounting system and the PEPPOL network, and keeps owning it as specifications and network requirements evolve.

Using Promis

Promis positions itself as the engine that lets accounting system providers and their users send and receive eInvoicing over PEPPOL without investing in that development work. The stated benefits for platforms and their users:

• Save time and money — Promis claims you save thousands of dollars and months of software development.
• Skip the specifications — you don't have to work directly with PEPPOL specifications.
• Demonstrate industry leadership — offer eInvoicing to your users and enable their suppliers.

Compare on the dimensions that matter

Why the Australian context pushes toward the faster option

eInvoicing has arrived in Australia, and Promis notes it is rapidly changing the AP/AR landscape. Businesses of all sizes can now send and receive electronic invoices, cut down on data entry errors and wage costs, rely less on paper and PDF invoices, and get paid faster.

There is also a government incentive: the Australian Government says it is working with the software industry to use PEPPOL, and eInvoicing issued to the Government will be paid within 5 days, with interest if they are late. The New Zealand Government will pay eInvoicing in 10 days from 1 July 2020. Promis frames this as an opportunity for platforms to demonstrate industry leadership.

If your users' suppliers are being pushed toward eInvoicing by these payment terms, the cost of arriving late is measured in lost customers, not just development spend.

How to decide

Choose Promis if:

• eInvoicing is a feature your users expect, not the product itself.
• You want to offer it without hiring for or diverting developers into PEPPOL specification work.
• You are targeting Australian (and potentially New Zealand) businesses that want faster payment terms.

Build in-house if:

• eInvoicing is central to your product's differentiation.
• You have developer capacity that would otherwise be underused, and you are comfortable owning the data transformation process permanently.
• You need control over the integration beyond what a third party provides.

Next step

Promis offers a "Schedule Your eInvoicing Success Session" and a contact route to get started, and publishes pricing at promis.co/pricing. Check the pricing page for current terms before committing, since the source material does not state figures.

A free hosted REST API like ReqRes gives you a real HTTP endpoint you can call immediately—no signup, no local server, no database setup. You get predictable JSON responses for users, resources, login, and registration, which makes it useful for front-end demos, integration tests, learning HTTP clients, and prototyping. What it is not is a production backend for your app: the data is shared, resets periodically, and you don't control the schema. If you need persistent, private data with auth and logs, that's where an account-based backend or a commercial licence comes in.

What "free REST API for testing and prototyping" actually means

The phrase sounds vague, so it helps to separate two things people often conflate:

• A mock/sample API — a public, hosted service with fixed or semi-fixed endpoints that return realistic-looking JSON. You don't own the data. It exists so you can point code at a URL and get a response.
• A real backend you configure — a service where you define collections, schemas, authentication, and logging, and where your data persists and belongs to you.

ReqRes's landing page describes both: a free REST API for testing and prototyping with real responses and no signup, plus an option to build your own backend with collections, auth, and logs at app.reqres.in. Those are different products with different trade-offs. The free public endpoints are the "point and go" part; the account-based backend is the "own your data" part.

What you can do with the no-signup public endpoints

1. Front-end demos without a backend

If you're building a UI and need data to render, you can fetch from a public endpoint instead of hardcoding arrays. This keeps your demo code closer to real fetch logic:

async function loadUsers(page = 1) {
  const res = await fetch(`https://reqres.in/api/users?page=${page}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data, total, page: current } = await res.json();
  return { users: data, total, page: current };
}

You get pagination fields, a data array, and support metadata—enough to build list views, loading states, and empty states.

2. Integration and contract tests

You can assert that your HTTP layer handles status codes, headers, and JSON shapes correctly. Typical checks:

• GET /api/users/2 returns 200 with a data object.
• GET /api/users/23 returns 404 (a non-existent user).
• POST /api/login with valid credentials returns a token; with missing fields returns 400.

This is useful for testing your client wrapper, retry logic, error handling, and serialization—without spinning up your own server.

3. Learning HTTP clients and tooling

If you're new to fetch, Axios, curl, Postman, or HTTPie, a hosted API is a low-friction target. You can practice:

• Sending query parameters (?page=2, ?delay=3).
• Setting headers and reading response headers.
• Handling POST, PUT, PATCH, DELETE.
• Observing status codes for success and failure.

4. Deliberate failure and latency testing

Endpoints that return 404 on purpose, or that accept a delay parameter, let you test how your app behaves when things go wrong or slow down. That's hard to do reliably against a happy-path local mock.

What the public endpoints are not good for

The key limitation: you don't own the data, and other people are hitting the same endpoints. Treat responses as illustrative, not authoritative.

When you'd move to an account-based backend

Consider app.reqres.in (collections, auth, logs) when any of these are true:

• You need your own collections and fields, not the fixed demo schema.
• You need data to persist between sessions and belong only to you.
• You need real authentication flows you can rely on in a demo or internal tool.
• You need request logs to debug what your client actually sent.
• You're working with a team and need shared, stable endpoints.

The trade-off is setup and, eventually, cost. The public endpoints require none; the backend requires an account and configuration.

Where pricing and licensing become relevant

The site signals a commercial licence and an upgrade path (with Stripe as the payment platform), but specific prices, plan tiers, and limits aren't stated here—so don't assume numbers. What you can reason about:

• Prototyping and learning → free public endpoints are usually enough.
• Internal tools, demos for clients, or anything you don't want reset → an account-based backend is the natural next step.
• Production or commercial use → check the licence terms and any paid plan, because "free for testing" and "free for commercial production" are not the same thing.

Before committing, read the current terms on the site rather than relying on secondhand summaries, since pricing and licence scope change.

A quick decision checklist

1. Do you need data that persists and is private? If yes → account-based backend.
2. Do you need a custom schema? If yes → account-based backend.
3. Are you only testing HTTP behavior, UI rendering, or learning a client? If yes → free public endpoints.
4. Will this touch real users or revenue? If yes → review the licence and any paid plan first.
5. Do you need logs and team access? If yes → account-based backend.

If you answer "no" to 1, 2, 4, and 5, the free hosted API is likely all you need. If you answer "yes" to any of them, plan for the account-based path.

The Australian Government pays eInvoices within 5 days, and pays interest if it is late. That applies to invoices issued to the Government through the PEPPOL eInvoicing standard. The practical effect for a business is a much shorter gap between sending an invoice and seeing the cash, which is the main reason the policy matters beyond the headline number.

The payment terms at a glance

Both governments have backed the Pan-European Public Procurement On-Line (PEPPOL) standard as the basis for eInvoicing. The Australian Government has said it is working with the software industry to use PEPPOL, which is internationally established.

Why a 5-day payment window matters

Traditional invoicing creates a long cash-conversion cycle. An invoice is created manually, sent as a paper or PDF document, keyed into the buyer's system, approved, and eventually paid. Each of those steps adds delay and the chance of a data entry error that pushes payment back further.

eInvoicing removes most of that. It is an automated, direct exchange of invoices between accounting software systems, with no manual invoice creation and no paper or PDF documents in the flow. When the buyer's system receives structured invoice data directly, there is less to re-key, fewer disputes over mismatched details, and a shorter path to approval.

A 5-day government payment term therefore does two things:

• It shortens the cash gap on government work, which matters most for small suppliers who feel late payment acutely.
• It sets an expectation that eInvoiced work gets paid faster than paper-based work, which is a reason to move suppliers onto eInvoicing even outside government contracts.

The interest-if-late clause also changes the incentive. Late payment is no longer cost-free for the payer.

What this means if you run an accounting platform

The payment policy is a demand signal, not just a compliance detail. If your users sell to government, or to larger buyers who are adopting PEPPOL, they will increasingly expect their accounting software to send and receive eInvoices.

Promis positions itself as the "invisible engine" that lets accounting platforms offer eInvoicing without building to the PEPPOL specification themselves. The site states the team spent 25,000 development hours on PEPPOL and eInvoicing, and frames the value as saving thousands of dollars and months of software development.

The benefits Promis lists for business leaders and for developers and tech leads follow from that: offer eInvoicing to your users, enable their suppliers, and demonstrate industry leadership without owning the PEPPOL data transformation work in-house.

The catch to plan for

The 5-day term only applies to invoices that actually travel as eInvoices over PEPPOL. A PDF emailed to a government contact is still a PDF. So the payment speed depends on both sides being connected: the supplier's accounting system able to send, and the buyer's system able to receive.

That is the real decision point. If your users are asking for eInvoicing because of the government payment terms, the question is whether you build the PEPPOL integration yourself or route it through a provider like Promis. The payment policy explains the urgency; it does not decide the build-versus-buy question for you.

Promis (promis.co) is an eInvoicing engine that lets accounting platform providers offer PEPPOL-based eInvoicing to their users without building the integration themselves. The benefits split into three groups: platforms gain a sellable eInvoicing feature, developers skip the PEPPOL data transformation work, and business leaders get faster payments with less manual invoicing. The trade-off is that you are adopting a third-party engine rather than owning the integration — worth it if speed to market matters more than full control.

For accounting platforms: a new feature without the build

Promis positions itself as the "invisible engine" behind your eInvoicing offering. Instead of developing PEPPOL capability in-house, your platform connects to Promis and passes eInvoicing on to your users.

The practical benefits:

• Offer eInvoicing to your users — and by extension, enable their suppliers to send and receive eInvoices through your system.
• Demonstrate industry leadership — you can be among the platforms offering eInvoicing while the Australian market is still adopting it.
• Avoid the specification work — Promis states it spent 25,000 development hours on PEPPOL and eInvoicing so its customers don't have to.

This matters most if you are an accounting software provider whose users are asking for eInvoicing and you don't want to fund a multi-month PEPPOL project to answer them.

For developers and tech leads: no bespoke PEPPOL integration

PEPPOL is the international standard for eInvoicing. Promis describes the without-Promis path as a "complex data transformation process" — bespoke integrations that are time consuming and problematic. Developers building directly against PEPPOL must handle that transformation themselves.

With Promis, the value proposition for the technical team is subtraction:

• No need to interpret and implement PEPPOL specifications directly.
• No bespoke data transformation layer to build and maintain.
• The 25,000 dev hours Promis already invested are effectively amortised across its customers.

The condition to check before choosing this route: confirm how Promis maps your platform's existing invoice data model into PEPPOL, and what you still own (authentication, user experience, error handling) versus what Promis handles. The source material states the engine removes the PEPPOL specification burden; it does not detail the integration surface, so treat that as a question for a scoping call.

For business leaders: faster payment and less manual work

The business case rests on what eInvoicing changes for the end user. According to Promis, businesses of all sizes can now:

• Send and receive electronic invoices (eInvoicing) instead of paper and PDF invoices.
• Spend less time on traditional invoicing problems such as data entry errors and high wage costs.
• Rely less on paper and PDF invoices.
• Get paid faster.

The payment-speed claim has a concrete anchor. Promis states the Australian Government will pay eInvoices within 5 days, and pay interest if late. It also notes the New Zealand Government will pay eInvoices within 10 days from 1 July 2020. For a business leader, government payment terms of that length are the clearest reason to care about eInvoicing adoption — but note this applies to eInvoices issued to government, not to every customer.

Who benefits most, and the condition to weigh

If your goal is to offer eInvoicing quickly while the Australian market is still forming, Promis's pitch — buy the engine, skip the 25,000 hours — fits. If your goal is to own and differentiate the eInvoicing experience end to end, the same pitch is the reason to build instead. Pricing is listed on the site's Pricing page; check it there rather than assuming a cost model.

Promis is an eInvoicing engine built for accounting platform providers. It lets those platforms offer eInvoicing to their users without building the underlying PEPPOL infrastructure themselves. If you run or develop an accounting system and want to add send-and-receive eInvoicing, Promis is positioned as the layer that handles the complex parts for you.

What Promis actually does

Promis enables accounting system providers and their users to send and receive eInvoices using PEPPOL. The site describes it as the "invisible engine" that lets you offer eInvoicing services without dealing with complicated PEPPOL specifications.

In practical terms, that means:

• Your platform can offer eInvoicing to your users.
• Those users can then exchange invoices with their suppliers electronically.
• Promis manages the PEPPOL-side data transformation and specification work.

Who it's for

The site names two main audiences:

The value proposition for both is the same: skip the development investment and still ship eInvoicing.

The problem it solves

PEPPOL is the international standard for eInvoicing, and the site describes it as containing a complex data transformation process. Building bespoke integrations against it is described as time consuming and problematic.

Promis states it spent 25,000 dev hours on PEPPOL and eInvoicing so that customers don't have to. The pitch is straightforward: save thousands of dollars and months of software development by using an existing engine rather than building your own.

Why eInvoicing matters in Australia

The site frames eInvoicing as already arrived in Australia and rapidly changing the AP/AR landscape. Businesses can:

• Send and receive electronic invoices.
• Reduce data entry errors and wage costs tied to traditional invoicing.
• Rely less on paper and PDF invoices.
• Get paid faster.

A specific incentive the site highlights: the Australian Government says eInvoices issued to it will be paid within 5 days, with interest if late. The New Zealand Government is also on board, paying eInvoices in 10 days from 1 July 2020. The site presents this as a reason to move early and demonstrate industry leadership.

What to check before deciding

The site's own framing tells you where to look next:

• Pricing — there's a dedicated pricing page, so check it for current commercial terms rather than assuming anything.
• Fit with your stack — Promis is aimed at accounting platforms, not necessarily end businesses invoicing directly. Confirm which side you're on.
• PEPPOL scope — the core claim is that Promis absorbs PEPPOL complexity. Verify what's covered versus what your team still needs to handle.

If you're an accounting platform evaluating whether to build or buy eInvoicing capability, Promis is a buy option specifically designed to remove the PEPPOL development burden. The next step is the pricing page and a conversation about your platform's requirements.