How it works.

Simeonov Systems designs and builds tailored automation systems for business processes. Sometimes that is one focused task; sometimes several connected steps, people and tools. Either way, the work follows the same approach: understand how your process really runs, agree how it should run, then build, test and refine what supports it.

The engagement

Seven stages, from understanding to refinement.

Each engagement is scoped to the problem you start with, whether that is one task or a connected process. The stages describe the approach; how much each one involves depends on the project, and real work steps back where it needs to.

Understanding the process

  1. Map how it runs today

    What happens

    The process is followed from the first request to the final output, as it really runs: who does what, which tools are involved, where information comes from, and the cases that do not fit the usual pattern.

    What it usually needs from you

    Time with the people who do the work, and real examples, including the awkward ones.

    What gets mapped

    What comes in
    Requests, forms, emails, documents, and the details that are missing
    Who is involved
    People, responsibilities, approvals, decisions and hand-offs
    What it runs on
    Spreadsheets, files, databases and the tools you already use
    What has to happen
    Status, reminders, follow-up, and the exceptions
    What comes out
    Records, documents, reports and replies
  2. Find where it gets stuck

    What happens

    Where the work waits, where details are typed twice, where nobody clearly owns the next step, and where exceptions are handled from memory. Not every problem needs automating; some need a clearer rule or a better hand-off.

    What it usually needs from you

    Your view of which problems matter most to the business.

Designing and building

  1. Redesign how it should run

    What happens

    How the process should run is designed with you: which steps a system takes on, which decisions stay with people, and how exceptions are handled. Nothing is built before this is agreed.

    What it usually needs from you

    Decisions on how the work should run, and on who owns each part of it.

  2. Build the system

    What happens

    The system is built around the agreed design. Where it is technically possible and suits the project, it works with the tools you already use, adding only what the process needs.

    What it usually needs from you

    Access to the tools and accounts involved, as agreed for the engagement.

  3. Test it with real cases

    What happens

    It is tried with real examples, including the ones that usually go wrong, before anyone relies on it.

    What it usually needs from you

    Real cases to test with, and people to try it and say what does not fit.

    Testing often sends something back to the design. That’s expected.

Running and improving

  1. Put it into use

    What happens

    It is introduced alongside the people who will use it every day, so that it fits how they actually work.

    What it usually needs from you

    Time for those people to learn it, and to say what is not working.

  2. Refine it

    What happens

    Once real use shows what to change, the system can be adjusted. Whether refinement and support continue after that is agreed for each project.

    What it usually needs from you

    Feedback from real use, including what people have started working around.

    Sometimes real use shows that part of the process should be redesigned. Then the path goes back to stage 3.

Illustrative example: a typical quote-handling process, not a client project.

One quote request, before and after.

A typical request, followed through seven moments: how it often runs today, and how a system designed around it could run it, with what a person still decides.

  1. A request arrives

    Often today: It comes in by email, by phone or through the website, and sits in whichever inbox it reached first.

    • The system: Records every request in one place, with the same details captured each time.
  2. Details are missing

    Often today: Someone notices the gap a few days later and asks for it in a new email thread.

    • The system: Asks for the missing details as soon as the request arrives.
    • A person decides: Whether the job is worth quoting.
  3. Pricing

    Often today: The price is worked out in a spreadsheet that only one person fully understands.

    • The system: Brings together the details needed to price the job.
    • A person decides: The price.
  4. Approval

    Often today: Anything above a certain value waits in one person’s inbox until they are back.

    • The system: Sends it to whoever can approve it, or their cover, with what they need to decide.
    • A person decides: To approve it, change it or turn it down.
  5. The quote document

    Often today: Copied into a template and reformatted by hand, every time.

    • The system: Produces the document from the details already entered.
    • A person decides: Whether it is right to send.
  6. Following up

    Often today: A follow-up happens if someone remembers to put it in their diary.

    • The system: Sets the follow-up when the quote is sent.
    • A person decides: What to say to the customer.
  7. The quote is accepted

    Often today: The people doing the work hear about it from a forwarded email, and ask for the details again.

    • The system: Passes the agreed details to whoever does the work next.
    • A person decides: When and how the work is done.

In this example, the decisions stay with people.

The system takes on the recording, chasing, routing and assembling around them. Which steps a system takes on is agreed with you during design, and in a different process, or for a smaller need, one well-built automation may be all that is needed.

Agreed for each engagement

Ownership, tools and support.

Ownership and access

Ownership, hosting, access and any third-party services a system depends on are agreed according to the specific engagement, including which accounts and tools it runs on and who is responsible for what.

The tools you already use

The starting point is whether the tools you already use can support the right solution. Where they can’t, or they limit it in important ways, an alternative may be recommended.

What it is built with

The technology is chosen to fit the process, and the specific tools are agreed for each project.

Support after it is in use

Ongoing support, maintenance and further improvement can be agreed where they are useful.

Before you get in touch

Common questions.

Can we start with one small automation?
Yes. One well-built automation can be the right place to start. The scope depends on what your business needs.
Do we need to replace the tools we already use?
Not necessarily. The starting point is whether the tools you already use can support the right solution. If they can’t, or they limit it in important ways, an alternative may be recommended.
What if a ready-made tool would do the job?
Then that is often the quicker and simpler route, and it is worth knowing before anything is built.
Who will we work with?
Bojidar Simeonov, who founded Simeonov Systems. The person who reads your process description is the person who designs and builds the system.
Who owns the system afterwards?
That is agreed for each engagement, together with hosting, access and any third-party services the system depends on.
What should we have ready?
Nothing formal. A description of how the process runs today, in your own words, is enough to start. No technical knowledge or specification is needed.

Describe one process, as it really runs.

What happens today, where it slows down, and who is involved. No specification is needed, and describing it commits you to nothing.